Algorithms for parallel machine scheduling: a case ... - Springer Link

Journal of the Operational Research Society (2003) 54, 806–821

r 2003 Operational Research Society Ltd. All rights reserved. 0160-5682/03 $25.00 www.palgrave-journals.com/jors

Algorithms for parallel machine scheduling: a case study of the tracking and data relay satellite system S Rojanasoonthon1, JF Bard1,* and SD Reddy2 1 Graduate Program in Operations Research, University of Texas, Austin, TX, USA; and 2Computer Sciences Corporation, New Carrollton, MD, USA

This paper presents two algorithms for scheduling a set of jobs with multiple priorities on non-homogeneous, parallel machines. The application of interest involves the tracking and data relay satellite system run by the US National Aeronautics and Space Administration. This system acts as a relay platform for Earth-orbiting vehicles that wish to communicate periodically with ground stations. The problem is introduced and then compared to other more common scheduling and routing problems. Next, a mixed-integer linear programming formulation is given but was found to be too difficult to solve for instances of realistic size. This led to the development of a dynamic programming-like heuristic and a greedy randomized adaptive search procedure. Each is described in some detail and then compared using data from a typical busy day scenario. Journal of the Operational Research Society (2003) 54, 806–821. doi:10.1057/palgrave.jors.2601575 Keywords: parallel machine scheduling; range scheduling; job priorities; GRASP; heuristics; dynamic programming

Introduction Planning problems associated with the operation of groundbased systems for satellite command, control, and communications are referred to as range scheduling problems. The name derives from the need to allocate resources over a range of times to satisfy user requirements. Early work in this area, starting in the 1980s, was aimed at automating rules and procedures used by operations personnel. Arbabi1,2 was the first to develop a computer-based planning system. His heuristic was called the continuous time scheduling algorithm and made use of a complex set of priorities, rules and exceptions that one learned by extensive on-the-job training. A team at IBM developed a second method for the National Aeronautics and Space Administration (NASA) using mathematical programming, but their approach was only suitable for small problems due to unacceptably long run times. The purpose of this paper is to present two improved algorithms for solving the range scheduling problem associated with NASA’s tracking and data relay satellite system (TDRSS). The major components of this system consist of two satellites in geosynchronous orbit, each serving as a relay platform for communications between low-orbiting spacecraft and ground terminals. Spacecraft

*Correspondence: JF Bard, Graduate Program in Operations Research, ETC 5.160, C2200, University of Texas, Austin, TX 78712-1063, USA. E-mail: [email protected]

can communicate with the TDRSS only when they are within line-of-sight range. The scheduling problem encountered in managing the TDRSS closely reflects the problem of scheduling jobs with time windows on parallel, unrelated machines. In our case, an antenna on the satellite can be viewed as a machine and a request to relay a message can be thought of as a job. The problem involves the assignment of the available antenna time to a subset of requests: it may not be possible to handle all of them. A solution requires three inter-related considerations: (i) which subset of the jobs to process, (ii) how to assign the selected jobs to the antennae, and (iii) when to start a specific job. The situation is complicated by the fact that users may have different priorities. The objective is to allocate the antennae over the planning period to meet the users’ requests in such a way that some function of the scheduled requests is maximized with strict priority enforcement. Scheduling a job in a higher priority class provides infinitely more benefit than scheduling any number of lower priority jobs. Reddy and Brown3 addressed the single machine problem with job priorities, arbitrary ready times, and deadlines. Their objective was to either maximize the number of jobs completed on time in one case, or to maximize the total work completed in the other. A network-based algorithm was developed to find solutions. In this paper, we present the Reddy–Brown (R–B) heuristic along with a greedy randomized adaptive search procedure (GRASP) that makes use of modern ideas from

S Rojanasoonthon et al—Algorithms for parallel machine scheduling 807

intelligent search. The performance of the two approaches is compared using a typical busy day scenario obtained from NASA. In the next section, we describe the operations of TDRSS and relate them to the parallel machine scheduling problem. This is followed by a discussion of related work and a formal definition of the scheduling problem. We then present the GRASP and the dynamic programming heuristic along with the computational results.

TDRSS and parallel machine scheduling The tracking and data relay satellite system allows various earth-orbiting satellites, the space shuttle and the international space station to communicate with personnel and data collection equipment on the ground. As these users know where they will be well in advance, planning can be done days or weeks ahead of time. In particular, users (spacecraft) with unique priorities, request blocks of contiguous antenna time by specifying the antenna preference, the contacting priority, and the time period in which contact is possible (time window). Each TDRSS antenna can handle at most one request at a time. In some situations, users may request periodic contacts or multiple simultaneous contacts. Between requests, the ground crew requires a certain amount of time to reconfigure the antennae. This time depends, for the most part, on the number of degrees the antenna needs to be turned—a function of the user locations. Figure 1 shows a diagram of the satellite system. The primary TDRSS ground terminal is at White Sands, New Mexico. Spacecraft that use the system can be divided into the following three categories. 1. Low-altitude satellites. These satellites orbit at an altitude below 500 miles and are visible to ground antennae for only 10 min per pass. Requests are given high priorities and have fixed time windows (processing times span the entire time window, so a TDRSS antenna must be reserved for the full period). 2. Medium-altitude satellites. These satellites orbit at around 12 000 miles above the Earth and are within line of site of the ground antennae for up to 11 h. Requests are made for a 10-min contact within a 45-min time window. The users normally specify which antenna they prefer.

TDRSS Ground Terminal

TDRS East

User Earth

Figure 1

TDRSS operations.

TDRS West

3. Near synchronous satellites. These satellites fly at an altitude of about 22 000 miles. Contacts can be made with the ground antennae for several hours when they are in the right position. Various request durations are possible. Each TDRS has two single access (SA) antennae and one phased array multiple access (MA) antenna. Each antenna can provide a service to one spacecraft at a time. The setup time for the MA antenna is constant at 15 s, while the setup time for an SA antenna depends on the number of degrees required to move it from one user to another. It typically varies from 15 s to 5 min. The problem faced by TDRSS planners is a variation of the classical parallel machine scheduling problem with time windows (eg, see Cheng and Sin4). Such problems arise when each job has a prespecified time interval in which processing must begin. Other characteristics of our problem include job priorities, setup times, and a heterogeneous machine environment in the sense that each job has a specific subset of machines on which it can be processed. Generally speaking, the problem under investigation can be viewed as two different problems. The first is a multiple traveling salesman problem with time windows (m-TSPTW) which, itself, is a special case of the vehicle routing problem (VRP) with time windows. To see this, let the machines and jobs be treated as vehicles and customers, respectively. The setup time between job i and j is the travel distance between customers i and j. Assume a single depot where all the vehicles must start and end their route. Let the travel distance from the depot to every customer be the initial startup time required for each equivalent job and the distance from each customer back to the depot be zero. The depot also has a time window that is determined by the earliest time that the vehicles can leave and the latest time by which they must return. This time window is associated with the total planning period of the problem. Therefore, the scheduling problem can be viewed as a heterogeneous fleet, common depot, multiple traveling salesman problem with time windows. The fleet is heterogeneous because each vehicle can visit only a predefined subset of customers. Typical objectives for VRPs are minimizing the total routing cost, minimizing the number of vehicles required, and minimizing the distanced traveled. The objective of the problem addressed here is maximizing a function of customers visited (or minimizing a function of unvisited customer). In generic terms, the VRP is stated as a covering problem, while our scheduling problem is stated as a packing problem. Second, the TDRSS scheduling problem can be viewed as a special case of the orienteering problem. The latter is defined by a starting point, an ending point, and a number of intermediate locations having associated scores. The objective is to select a subset of locations such that each can be visited in the amount of time available (or within the budget

808 Journal of the Operational Research Society Vol. 54, No. 8

limitations) and that the sum of the scores collected is maximized. The solution also requires specifying the order in which the locations are visited. The problem is a generalization of the TSP and is sometimes called the traveling salesman’s subtour problem5 or the maximum collection problem.6,7 Applications include finding a route for a technician who can provide support to only a restricted number of customers due to his availability constraint (preferring those with higher revenue potential),5 routing of oil tankers to service ships at various locations,8 and scheduling the daily operations of a steel rolling mill.9 The orienteering problem was shown to be NP-hard by Golden et al.10 The parallel machine scheduling problem with time windows can be thought of as a multiple tour, maximum collection problem with time windows.

Related literature In their original work, Reddy and Brown3 approached the TDRSS scheduling problem from a network point of view. In the network, a super-source node and super-sink node were used to represent the start and end times of the scheduling period, while each job was represented by an intermediate node. Directed arcs were used to account for precedence relations established by several dominance rules. For the single machine case without priorities, the contribution of a job to the objective function was represented by the weight of the arc leaving that node. The weights were set to one when the objective was to maximize the number of scheduled jobs, and set to the processing time of the job when the objective was to maximize total system utilization (the total work completed on time). The longest path through the network determined the optimal solution. They next addressed the multi-machine problem with different priority classes. The first step was to modify the job weights to enforce strict priority. Their dynamic programming-like algorithm was then used as a heuristic by applying it sequentially to one machine at a time. The machine with least total demanded processing time was scheduled first. Their Fortran implementation proved to be quite efficient compared to the procedures NASA was using at the time. Reddy11 extended this work to account for jobs with sequence-dependent setup times. He derived new dominance rules that led to a set of precedence relations for each job. Once again, dynamic programming was used to find the longest path through the network model. Solutions to the parallel machine case were obtained by applying the algorithm sequentially. Gabrel12 focused on the problem of scheduling non-preemptive jobs, each with a given start-time interval, on identical parallel machines. Each job was only permitted to be processed on a subset of the machines. Two variations of the problem were considered: (i) the fixed job scheduling problem (FSP) where the start-time interval is a point, and

(ii) the variable job scheduling problem (VSP) where the interval has a non-zero range. In either case, the objective was to maximize the number of jobs processed. The majority of the paper dealt with the FSP. By defining an incompatibility graph in which each node represents a job–machine combination and each edge a conflict, lower bounds were obtained by finding the maximum independent set on the graph. A simple heuristic was developed for this purpose. Upper bounds were obtained using a heuristic to find the minimum partition into cliques. No computational results were reported for the VSP. Randhawa and Kuo13 studied how different problem properties and heuristics interact with one another. The paper dealt with the non-homogeneous parallel machine problem in which the machines have different processing speeds and a job can only be processed within its ready time and due date on a subset of machines. Objectives of minimizing flow time, job tardiness, percentage of tardy jobs, and process utilization spread were studied. Instances were characterized by different properties: that is, the number of machines and jobs, machine capacities, distributions of job processing times, percentages of available capacity, and setup times. To find solutions, they developed several two-phase heuristics that first allocate jobs to machines and then sequence them. Analysis of variance was applied to the results to determine the interaction between the heuristics and the effects of different problem characteristics on the solution. Gensch5 attacked the orienteering problem by formulating it as a mixed-integer linear program and used Lagrangian relaxation to obtain a tight upper bound. A branch-andbound scheme provided optimal solutions to problems with 30 cities. With some modifications, it could also be used as a heuristic that sacrificed little in optimality. Tsiligirides14 proposed a solution methodology based on two approximation schemes, and claimed that it provided good, if not optimal, solutions. Kataoka and Morito7 presented two formulations for the problem and proposed an exact branchand-bound algorithm. The bound was obtained from a relaxation that took the form of a generalized assignment problem. Laporte and Martello15 referred to the orienteering problem as the selective TSP, and claimed to be the first to solve it optimality for instances of realistic size. Their algorithm was based on branch and bound and was able to solve randomly generated instances involving between 10 and 90 locations. As part of their procedure, lower bounds were obtained with nearest neighbor and cheapest insertion heuristics, while upper bounds were obtained by solving a 0–1 knapsack problem. Ramesh and Brown16 also investigated the orienteering problem and presented a heuristic for the case where the objective function is defined by a general (non-Euclidean) cost metric. Ramesh et al17 proposed an optimal branchand-bound scheme based on Lagrangian relaxation when the


starting and ending points were required to be the same. The Lagrangian relaxation was solved by a degree-constrained spanning tree algorithm. Results were given for problems having up to 150 locations. Kantor and Rosenwein18 studied the orienteering problem with time windows. Their objective was to maximize the total profit collected without violating the time window constraints while returning to the starting point within the allotted time. Three types of decisions characterized the problem: the selection of customers to be serviced, customer routing, and the scheduling of the customer collection times. Solutions were obtained with an exhaustive search of the feasible region for problems with up to 21 cities. Butt and Cavalier6 presented a heuristic for solving the multiple tour, maximum collection problem (MTMCP). This problem involves finding m time-constrained tours that visit a subset of weighted nodes in a graph such that the total weight collected from the subset is maximized. A feasible tour must begin and end at the depot, visit a node in the subset at most once, and be completed by time T. All the nodes in the subset must be visited by exactly one tour. Observe that this problem reduces to a TSP or a VRP if it were possible to visit all the nodes within T. Also observe that the orienteering problem is a special case of the MTMCP when only one tour is allowed. The heuristic presented was based on a simple weighting scheme that assigned higher weights to the node pairs that gave more benefit when included on the same tour. Optimal solutions were found in 13 out of 17 instances with 10–20 nodes and two to three tours: the worst solution was within 5.7% of the optimum. With 100-node and 15-tour problems, their heuristic took 70 s to run on an IBM 3090/600 mainframe.

Problem definition The scheduling problem examined in this paper can be stated as follows. Each of n jobs in the set J ¼ {1,y, n} is independent and a candidate to be processed without interruption on a set of parallel machines M ¼ {1,y, m}. Associated with each job is a time window [ajk, bjk] (for job j on machine k, the earliest time it can begin processing is ajk and the latest time is bjk: 0pajkpbjk), a processing time pjk (the processing time of job j on machine k), and a set of machines MjDM on which job j can be processed. Also, there are r priority sets such that JpDJ, pA{1,y, r} is a set of jobs with priority p. When job j immediately succeeds job i on machine k a setup time sijk is incurred. If wp is the contribution of priority p jobs and np is the total number of priority p jobs, the strict enforcement of priorities requires wp4Srq ¼ p þ 1nqwq. Note that some job j may have two time windows (a1jk, b1jk) and (a2jk, b2jk) and may be processed in either one of them but not both.

An optimal schedule has the following properties: 1. each job is processed within its time window; otherwise, it is considered unscheduled; 2. each job is processed exactly once without interruption on one of its permissible machines; 3. each machine processes at most one job at a time; 4. the total contribution of the scheduled jobs is maximized.

Mathematical formulation As the parallel machine scheduling problem with time windows can be viewed as a special case of the m-TSPTW, the mathematical formulation of either is similar. This is reflected in the model presented below. The following notation is used in the developments. Indices and sets J:

J1 and J2 : JpDJ : M: Mj : Fij :

set of jobs; i, jAJ ¼ {1,y, n}; J 0 ¼ J [ {0}, where 0 is a dummy job that represents the starting and ending of the sequences on all machines. set of jobs with one and two time windows, respectively. set of jobs with priority p; p ¼ 1,y, r where r is the number of different priority classes. set of machines; kAM ¼ {1,y, m}. set of machines on which job j can be processed; jAJ. set of machines on which both jobs i and j can be processed; Fij ¼ Mi \ Mj, i, jAJ.

Parameters Pi : np : bi : pp :

pjk : ajk :

Aj : bjk :

priority class of job iAJ. total number of jobs with priority p (np ¼ 7Jp7). benefit associated with processing job iAJ. positive contribution to the objective function of a priority p job; pp4Srq ¼ p þ 1pqSiAJq bi, p ¼ 1,y,r–1, where pr ¼ 1. processing time of job j (machine-dependent); 0ppjk, jAJ, kAM. earliest time processing of job j can begin on machine k; ajkX0, jAJ, kAM. The dummy job 0 is assumed to start processing at time 0 on each machine and take 0 time. If j has two time windows, a1jk and a2jk are the earliest times processing of j can begin in its first and second time window, respectively. earliest starting time of job j across all machines: Aj ¼ mink2Mj ðajk Þ; j 2 J. latest time processing of job j can begin on machine k: bjkXajk, jAJ, kAM. If bjk þ pjk is greater than the shut down time of the whole operation, bjk will be replaced by (shut down time pjk) during the preprocessing step. If j


X

has two time windows. b1jk and b2jk are the latest times processing of j can start in its first and second time window, respectively. latest time processing can begin for job j across all machines; Bj ¼ maxk2Mj ðbjk Þ jAJ. setup time between job i and job j if j is scheduled immediately after i on machine k; sijkX0, i, jAJ, kAM. The setup time of the first job in every machine schedule. s0ik, is assumed to be 0. large number, mij ¼ maxk2Mi ðbik Þ mink2Mj ðajk Þ, iajAJ. Note that bik and ajk are replaced with b2ik and a1jk, respectively, if i and j have two time windows.

Bj : sijk :

mij :

a1ik y1ik þ

k2Mi

0

a2ik y2ik pti ;

i 2 J2

ð8Þ

k2Mi

1

X X

@1

X

xkij ABi þ

j2J 0 nfig k2Mi

X

X

bik

k2Mi

xkij Xti ;

j2J 0 nfig

ð9Þ

i 2 J1 1

X

! ðy1ik

þ

y2ik Þ

Bi þ

k2Mi

þ

X

b2ik y2ik Xti ;

X

b1ik y1ik

k2Mi

i 2 J2

ð10Þ

k2Mi

Variables xkij :

(flow variables, iajAJ0, kAFij) where xkij ¼ 1 if machine k processes job j immediately after job i; xkij ¼ 0 otherwise. Note that xkij ¼ 0 for all the undefined indices. (time variables) start time of job jAJ. tj : y1ik and y2ik : (time window variables, iAJ2, kAMi) where y1ik ¼ 1 if job i is processed in its first time window on machine k; y1ik ¼ 0 otherwise, and y2ik ¼ 1 if job i is processed in its second time window on machine k; y2ik ¼ 0 otherwise.

Model 1 One service only for each job. We now give a mixed-integer linear programming (MILP) formulation for the problem when each job requires only one service. 0 1 X X X Maximize pPi bi @ xkij A ð1Þ i2J

j2J 0 nfig k2M

X X

subject to

xkij p1;

i2J

ð2Þ

j2J 0 nfig k2M

X

xk0j p1;

k2M

ð3Þ

j2J

X i2J 0 nfjg

ti þ

X

xkij

xkji ¼ 0;

j 2 J 0; k 2 M

ð4Þ

i2J 0 nfjg

X

ðpik þ

sijk Þxkij

1

k2M

X

! xkij

mij ptj ;

k2M

ð5Þ

i; j 2 J; i 6¼ j y1ik þ y2ik

X

xkij ¼ 0;

i 2 J 2; k 2 M

ð6Þ

j2J 0 nfig

X k2Mi

aik

X j2J 0 nfig

xkij pti ;

i 2 J1

ð7Þ

xkij 2 f0; 1g for i; j 2 J 0 ; k 2 M; y1ik ; y2ik 2 f0; 1g for i 2 J 2 ; k 2 Mi ; and Aj ptj pBj

for j 2 J

ð11Þ

The objective function (1) is designed to maximize the weighted number of scheduled jobs. As defined, the vector pp must be selected so that scheduling a job in a higher priority class benefits the objective function ‘infinitely’ more than scheduling any number of lower priority jobs. Constraint (2) allows each job to be processed by at most one machine. It also ensures that if a job is scheduled, it has no more than one successor, which might be the dummy job 0. Constraint (3) limits the number of machines used and the maximum number of initial jobs to at most m. It also specifies that each machine can process at most one job at a time. Constraint (4) ensures that the same machine processes every job in a scheduled sequence: that is, if job j is assigned to machine k, both the predecessor and successor of j must be processed by machine k. This equality is usually referred as the conservation of flow constraint. Inequality (5) is the compatibility requirements of consecutive jobs. It also ensures subtour elimination, since it forces the service initiation times, ti and tj, of any two consecutive jobs i and j in a sequence to be strictly increasing. Therefore, the sequence cannot include any of the previously assigned jobs. Constraint (6) in conjunction with (2) limits jobs with two time windows to be processed in at most one of them. Constraints (7) and (9) restrict jobs with one time window to be within their bounds, while constraints (8) and (10) provide similar restrictions for jobs with two time windows. Note that ti is still bounded by mink2Mi ðaik Þ and maxk2Mi ðbik Þ even when it is not scheduled. Using (5) and these bounds, mij can be defined as small as maxk2Mi ðbik Þ mink2Mj ðajk Þ .


If machines can be partitioned into homogeneous subsets, the number of constraints can be reduced by redefining k as an index of a machine type. To see this let Mk represent the set of machines of type k. As previously defined, M is the set S of all machines. Therefore, M kAKMk where K is the set of machine types. An MILP formulation for the problem, when taking advantage of homogeneity among machines, is very similar to (1)–(11). The differences are that M is replaced by K and constraint (3) is replaced by X xk0j pjMk j; k 2 K: ð12Þ j2J

As such, the summations over k in the original formulation should be interpreted as summations over different machine types rather than machines. Constraint (12) ensures that the number of type k machines used will not exceed |Mk|, the number available. Model 2 Two services for each job. In the TDRSS application, some users may request two contacts. These do not necessarily have to be on the same machine and must be attempted on different machines if they are required to be made simultaneously. To extend the model to account for this situation, let ti be the offset time between the start of services 1 and 2 for job i, where ti can be any real number. For example, ti ¼ 300 indicates that service 2 for job i starts exactly 300 time units before the start of service 1, ti ¼ 0 indicates that the two services must start simultaneously, and ti ¼ 300 indicates that service 2 starts exactly 300 time units after the start of service 1. The MILP formulation for Model 1 can be modified to handle the two-service case by splitting each two-service job into two jobs, one for service 1 and the other for service 2. Taking this approach, we relabel the job indices such that if job i represents service 1 of some two-service request, job i þ 1 will represent service 2 of that request. For job i, the parameter bi can be interpreted as the benefit received when both jobs i and i þ 1 are scheduled. If only one of the jobs can be scheduled, the request is considered unsatisfied and no contribution is made to the objective function. Let S1 and S2 be the set of jobs representing services 1 and 2, respectively. The augmented model is 0 1 X X X Maximize ppi bi @ xkij A ð13Þ i2J1

j2J 0 nfig k2M

subject to (2)–(11) X j2J 0 nfi1g

X k2M

xki1;j

X X j2J 0 nfig

xkij ¼ 0; i 2 S2

ð14Þ

i 2 S2

ð15Þ

k2M

t i þ ti ¼ t i þ 1 ;

Constraint (14) assures that if a job requiring two services is selected, then both services are scheduled. Constraint (15) assures the correct offset time between the start of services 1 and 2.

Computational issues To avoid dealing with excessively large values of pp, either formulation needs to be repeatedly solved in the following manner. Initialization step: Let S1 J1. Solve the MILP for jobs jAS1 only, and call the resulting objective function as z1. Set p ¼ 2. General step: Sp ¼ Sp–1 [ Jp. Solve the MILP for all jobs jASp with the additional constraints (16). These constraints require the objective function for all the jobs jASh to be at least as great as zh for h ¼ 1,y, p–1, where zh is the objective function obtained when only jobs jASp–1 are considered. X

0 pPi bi @

i2Sh

X X

j2J 0 nfig

1 xkij AXzh ; h ¼ 1; . . . ; p 1:

ð16Þ

k2M

Call the resulting objective value zp. Put p’p þ 1. Repeat the General step until p4r. Limited success with this approach for even two-priority examples using a standard commercial code (CPLEX) led to the development of two heuristics. In the remainder of the paper, we describe each and compare their performance on a real-world data set.

GRASP GRASP combines greedy heuristics, randomization, and local search.19 The computations are performed in two phases. The first phase involves the sequential construction of feasible solutions. At each iteration, all feasible moves are ranked according to an adaptive greedy function that takes into account the present state, and then one move is randomly selected from a restricted candidate list. In the second phase, neighbourhood search is used to obtain a local optimum. As the entire procedure is repeated many times, an efficient construction phase is imperative. Moreover, the inherent complexity of local search suggests that it may be preferable to construct a number of feasible solutions and then apply phase 2 to the most promising. GRASP is most successful when the construction phase produces feasible solutions that are close to a local optimum. This leads to the fundamental difference in philosophy between GRASP and other metaheuristics such as tabu search and simulating annealing. For GRASP to work well, it is essential that high-quality solutions be constructed during the first phase of the algorithm. By way of contrast, tabu search and simulated annealing do not argue for highquality initial feasible solutions. They spend virtually all of


their time improving the incumbent and trying to surmount local optimality. As the objective of our problem (PMSPTW) is to maximize the number of jobs processed with strict priority enforcement, the GRASP is applied repeatedly to subsets of jobs, starting with the subset comprising the highest priority class. The process is repeated with the set of jobs from the next highest priority class until all subsets are considered. We now provide an outline of phases 1 and 2. Those interested in more detail are referred to Rojanasoonthon and Bard.20

Phase 1 Starting with an empty schedule, jobs are sequentially selected and inserted into positions in the sequence on one of the m machines. The process is repeated until no more jobs can be inserted. Because of the priority restrictions, only jobs from one priority class are considered for insertion at a time. Assume that (a,y, b) is a partial sequence of some feasible schedule. The forward time slack of job a, denoted by F(b) a , is the maximum forward shift in time that a can begin processing without causing any violation of the time windows along the subsequence (a, y, b). Recall that some of the jobs may have two time windows. Given a feasible schedule (1, y, nk) on machine k, where jobs may have two ðn Þ time windows, the forward time slack, Fi k , and the start time, ti, of each job i can be calculated by the following backward recurrence relations. If job i has a single time window, ðnk Þ

Fi

¼ minfðbik ti Þ; ðFi þ 1 þ ti þ 1 ri þ 1 Þg

ð17Þ

ti þ 1 ¼ maxfðti þ pik þ si;i þ 1;k Þ; ai þ 1;k g

ð18Þ

considered separately for insertion using two different criteria. When aik ¼ bik for all k, job i has a fixed starting time. Within a priority class, these jobs are inserted first. The criterion is based on the weighted conflict that a particular job has with the other unscheduled jobs. The criterion for inserting jobs whose start times can vary is based on maximizing a flexibility function that measures how much slack a schedule has after the insertion is made. To see how these criteria are applied, let the time window tightness for job i on machine k be defined as (pik/bik þ pik– aik). Call it TWTik and note that a value exists for each time window associated with the pair (i,k). Next define a conflict value for job j on machine k as the summation of the time window tightnesses of all other jobs i whose time segments [aik,bik þ pik] overlap [ajk, ajk þ pjk] of job j. Call it CVik and similarly note that a value exists for each time window. Finally, define a r-dimensional vector of time window conflicts for job j, machine k, and each time window, such that each of its components represents the conflict value j has with respect to other jobs from each of the r priority classes. Call this vector TWCjk. (Actually, the components of TWCjk need only be defined with respect to jobs of equal or lower priority.) One conflict vector is considered greater than another if it is lexicographically greater within priority classes. The flexibility function for an unscheduled job is derived from a modification of the forward time slack that would result if the job was inserted into the current schedule. Let i kp and i kp þ 1 be two consecutive jobs on machine k. The flexibility function associated with inserting an unscheduled job u between i kp and i kp þ 1 is defined as follows. If u has a single time window,

r f i kp ; u; i kp þ 1 ¼ min ðbuk tu Þ; Fi k r new k k i i pþ1

If job i has two time windows, 8 > b1 ti > > ik > < if b1 t oF 2 i i þ 1 þ ti þ 1 ri þ 1 oaik ti ðn Þ ik Fi k ¼ > > minfðb2ik ti Þ; ðFi þ 1 þ ti þ 1 ri þ 1 Þg > > : otherwise

ti þ 1

8 > a1i þ 1;k > > > > < ¼ a2i þ 1;k > > > > > : ti þ pik þ si;i þ 1;k

ð19Þ if ti þ pik þ

si;i þ 1;k pa1i þ 1;k

if b1i þ 1;k oti þ pik þ si;i þ 1;k pa2i þ 1;k otherwise ð20Þ

where rj is the ready time of job j, that is, the time machine k completes processing the job immediately preceding j; rj ¼ tj–1 þ pjk þ Sj–1,j,k . Unscheduled jobs are separated into two disjoint subsets depending on whether they have fixed starting times, and

pþ1

pþ1

ð21Þ If u has two time windows,

f i kp ; u; i kp þ 1 ¼ 8 > 1 new > > min ðbuk tu Þ; Fi kp þ 1 ri k ri kp þ 1 > pþ1 > > > > > > < if b1 tu oF k þ t k rnew oa2uk tu i pþ1 i pþ1 uk i kp þ 1 > > > > 2 new > > > min ðbuk tu Þ; Fi kp þ 1 ri kp þ 1 ri kp þ 1 > > > : otherwise

ð22Þ

where rj is the ready time of job j and the superscript new indicates the updated value of the corresponding variables after the insertion of job u. The insertion point that maximizes the slack of the resulting schedule is used to determine where an unscheduled job u should be inserted. This is achieved by finding the pair

i kp ; i kp þ 1


jobs. The operations are done sequentially starting with moves associated with jobs on the same machine. The order of execution is as follows.

that maximizes

f i kp ; u; i kp þ 1 As such, define the best flexibility function associated with an unscheduled job uAU as follows:

ð23Þ f ðuÞ ¼ max f i kp ; u; i kp þ 1 i kp ;i kp þ 1

The next step is to select a job for insertion. We pick job un that maximizes f(u): that is, un ¼ arg maxff ðuÞ : u 2 Ug

ð24Þ

The insertion locations for unscheduled jobs are determined by maximizing the job insertion criterion as discussed previously, and hence, are deterministic. To introduce randomness into phase 1, a restricted candidate list (RCL) of predetermined size l is used at each iteration to store a corresponding number of best jobs. Here ‘best’ means the highest values of f(u) as determined by (24). The job that is actually inserted is randomly chosen from those on the list. Phase 1 for jobs from the same priority class can be summarized as follows: Step 1: Let U1 be the set of unscheduled jobs with fixed starting time. For each job jAU1, identify the smallest conflict vector TWCjk. Then sort these jobs in descending order of TWCjk to form a sequence S. Step 2: Attempt to insert jobs. Randomly select a job for insertion from the first l jobs of S. The job is checked for insertion on the machine exhibiting the smallest conflict. If the insertion is infeasible, the machine with the next smallest conflict for that job is considered. Either the job is inserted or all the machines are exhausted. If the job cannot be inserted, remove it from S and repeat this process until S ¼ |. Step 3: Let U2 be the subset of unscheduled jobs with a range of starting times, and find the top l jobs in U2 that maximize f(u) in (24). Form an RCL with these jobs. Randomly select a job, uˆ, from the RCL. Step 4: Insert uˆ at the appropriate point in the current sequence, U2’U2\{uˆ}. Step 5: Repeat Step 3 using an updated RCL until no more jobs can be inserted.

Phase 2 In phase 2, a neighbourhood of the feasible schedule is repeatedly searched in an effort to achieve local optimality. For the PMSPTW, two different neighbourhoods are considered, the first defined with respect to relocating scheduled jobs and the second with respect to interchanging

1. Relocating scheduled jobs. Up to three jobs are relocated at a time beginning with a single job. This is the method proposed by Or21 for the TSP and is a partial implementation of the 3-opt procedure where now none of the tour segments is reversed. It is often referred to as the Or-opt procedure. Two neighbourhoods for relocation of jobs are defined as follows: N1 ðf Þ ¼fg 2 D : g is obtained by relocating jobs in f on the same machineg N2 ðf Þ ¼fg 2 D : g is obtained by relocating jobs in f from one machine to anotherg where D is the domain of feasible solutions and f is the current feasible solution. 2. Interchanging of jobs. Only two jobs are involved in each interchange; that is, one is exchanged with the other. The three neighbourhoods considered are: N3 ðf Þ ¼fg 2 D : g is obtained by interchanging jobs in f on the same machineg N4 ðf Þ ¼fg 2 D : g is obtained by interchanging jobs on two different machines associated with f g N5 ðf Þ ¼fg 2 D : g is obtained by interchanging an unsheduled job with a job in f g

Note that either interchanging or relocating jobs by themselves is not considered a move for the PMSPTW because the objective function remains unchanged. A complete move is a combination of a neighbourhood search and the insertion of an unscheduled job. The insertion is performed by the same method used in phase 1. In phase 2, these five neighbourhoods are searched sequentially from N1 to N5. The steps for jobs in the same priority class are summarized below. Step 1: Search through each neighbourhood one at a time. If the move is feasible and at least one more job can be inserted, update the schedule. Step 2: Repeat Step 1 until there is no feasible move that leads to more insertions.

Complexity of the GRASP Let n be the number of requests and let m be the number of machines. The dominant step in phase 1 is the calculation of


Table 1 Data for a single machine example Request (i)

Latest start time (bi)

Processing time (pi)

1 0 4 0 0

3 3 5 6 8

2 3 3 4 5

1 2 3 4 5

f(u) to determine the job to be inserted next. This calculation is O(n þ m) which is the number of possible insertion point on m machines times O(n) number of unscheduled jobs. The process is repeated O(n) times, so the complexity is O(n3 þ mn2). Phase 2 is dominated by the inter-machine relocation neighbourhood search. All O(m2) pairs of machines are considered. The number of scheduled jobs and the number of new insertion locations on another ðn Þ machine is bounded by O(n2). Updating Fi k in Equations (17) and (19), ti þ 1 in Equations (18) and (20), and making the insertion is O(1). Checking for feasibility and improvement is O(1) and O(n2), respectively. Therefore, the overall complexity of phase 2 is O(m2n4) (see Rojanasoonthon22).

GRASP example We now illustrate the computations associated with the GRASP. Data for an example involving five requests to be scheduled on a single machine are given in Table 1. The objective is to maximize the number of requests scheduled.

Phase 1 Iteration 1: The schedule is empty: ( ). Calculating f (j) for all j using Equations (21) and (22) gives:

j fð jÞ

Since

j

2

3

4

5

In front of job 1

fð jÞ Feasible

(1) Yes

n/a No

n/a No

n/a No

Following job 1

fð jÞ Feasible f (j)

(3) Yes (1)

(4) Yes (4)

(4) Yes (4)

(5) Yes (5)

Location

Earliest start time (ai)

1

2

3

4

5

(3)

(3)

(7)

(4)

(5)

max f ðjÞ ¼ fð1Þ

Job 2 is selected and insert before job 1. The processing start time and forward time slacks are t2 ¼ 0 and F2 ¼ 0, respectively. As a result of the insertion, F1 is updated to 0. Iteration 3: the schedule is: (2, 1). At this stage, three insertion points exist for the remaining jobs. The calculations are summarized below.

Location In front of job 2 Between jobs 2 and 1 Following job 1

j

3

4

5

Feasible Feasible fð jÞ Feasible f ( j)

No No (3) Yes (3)

No No (4) Yes (4)

No No (5) Yes (5)

Job 3 is selected and insert after job 1. The processing start time and forward time slacks are t3 ¼ 5 and F3 ¼ 0, respectively. The corresponding values for jobs 2 and 1 remain the same. Iteration 4: the schedule is: (2, 1, 3). At this stage, four insertion points exist for the remaining jobs. The calculations are summarized below.

Location In front of job 2 Between jobs 2 and 1 Between jobs 1 and 3 Following job 3

j Feasible Feasible Feasible fð jÞ Feasible f ( j)

4

5

No No No n/a No n/a

No No No (5) Yes (5)

Job 5 is chosen and inserted after job 3 with t5 ¼ 8 and F5 ¼ 0. The remaining job 4 cannot be inserted anywhere. Therefore, the schedule after phase 1 is (2, 1, 3, 5). After going through phase 2, no additional insertion can be made so the procedure terminates.

j

we select job 1 and insert it into the schedule giving t1 ¼ 1 and F1 ¼ 2. Iteration 2: the schedule is: (1). The next job may go either before or after job 1. The f values of the remaining four jobs and a statement as to whether or not they can be inserted in the schedule are summarized below.

The R–B heuristic For the TDRSS application, the first algorithm for solving the corresponding PMSPTW was developed by Reddy and Brown.3 They proposed a dynamic programming-like (DP) heuristic based on the idea of finding the longest path through a directed graph defined by precedence relationships among the requests. The major contribution of their work,


summarized presently, was the derivation of these precedence relations from several dominance rules applicable for the single machine case. For the multi-machine case, they applied the DP methodology sequentially such that the machine with the least amount of possible processing time is scheduled first, and so on. We begin with a description of the theory behind the heuristic, and then offer a useful generalization that leads to a more efficient way of setting up the dynamic program. This is followed by an overview of the heuristic and an example to illustrate the computations. Finally, we discuss the framework for extending the single machine heuristic to handle multiple machines. The single machine problem has the objective of maximizing the weighted number of requests scheduled from the set J ¼ {1, 2, 3,y, n}. The parameters are defined as follows: earliest starting time i; latest starting time of request i; duration of request i; latest ending time or the deadline of request i, di ¼ bi þ pi; ci : earliest end time of request i, ci ¼ ai þ pi.

ai : bi : pi : di :

For diX0, aiX0 for all i, and pipdi –ai, it is possible to establish the results presented below. These results are used to construct a directed graph in which each node represents a job and each arc a precedence constraint between job pairs. Theorem 1 For any request iajak such that aipajpak, request i will not immediately precede request k in an optimal schedule if dipbj and max(di , aj) þ pjpak. Proof By contradiction, assume request i immediately precedes request k in the optimal schedule. Let ti and tk be the actual starting times of i and k in the schedule, respectively, and let fi and fk be the actual ending times of i and k in the schedule, respectively. An optimal schedule must be a feasible one: therefore, fipdi and tkXak. Since dipbj, di þ pjpak, and aj þ pjpak, j can be scheduled during the interval between max(di,aj) and min(dj,ak) without changing the start times of i and k. This contradicts the assumption that the schedule with request i immediately preceding request k is optimal. & This theorem defines the lower bound on the latest ending time of potential immediate predecessors of a request. Thus, it limits the set of requests that must be considered when determining the immediate predecessor of a job in an optimal schedule. Theorem 2 For any adjacent requests i and j in an optimal schedule, if aioaj and diodj, request i can always precede request j without affecting the optimality of the schedule.

Proof Consider the following four cases. Case 1: biocj and cipbj. By contradiction, assuming that j precedes i in the optimal schedule. But since biocj, the schedule is infeasible, a contradiction. Case 2: biXcj and cipbj. In this case, i can precede j and j can precede i. Case 3: biocj and ci4bj. From biocj, j cannot precede i. From ci4bj, i cannot precede j. Contradict the fact that i and j are in the optimal schedule. Case 4: biXcj, and ci4bj. This implies di – piXaj þ pj and ai þ pi4dj – pj. Adding these two inequalities yields ai þ di4aj þ dj, which contradict the assumption that aioaj and diodj. & This theorem defines the upper bound on the earliest start time of potential immediate predecessors of a request. Thus, it also limits the set of jobs that must be considered when determining the immediate predecessor of a job in an optimal schedule. Theorem 3 For any requests iaj, if ci4bj, request i will not immediately precede request j in an optimal schedule. Proof If ci4bj, i cannot precede j since the resulting schedule would be infeasible. & This theorem eliminates infeasible requests from the set of potential immediate predecessors of a request as defined by Theorems 1 and 2.

Generalization When aipaj implies dipdj for all i,jAJ, Theorem 2 can be applied directly. As a result, the predecessor sets of the requests are precisely defined. When the condition does not hold for some pair of requests i and j, an artificial request referred to as a mutually exclusive artificial alternate request and denoted by i0 is created for i. In defining i0 , the goal is establish precedence relations such that i must precede j and i0 must succeed j. Nevertheless, a feasible solution can have either the original request or its alternate request but not both. Definition 1 Suppose that request i and j are such that aipaj, and di4dj. Then the mutually exclusive alternate request for i is i0 where its parameters are ai0 ¼ aj þ pj, di0 ¼ di and pi0 ¼ pi. Figure 2 shows an example of a mutually exclusive alternate request. Since i0 is an alternate request for i, scheduling i0 is equivalent to scheduling i. Therefore, an optimal schedule with request j and i0 generated under the assumption that i precedes j if aipaj is equivalent to an optimal schedule with request i and j without any assumptions about the precedence relationship between i and j. As a result, when some request pairs do not satisfy the condition that aioaj implies diodj, mutually exclusive artificial alternate for all


ai ′ aj ai

bj

cj

ci ′

di ′

bi

di

dj

ci

Figure 2

bi ′

Mutually exclusive alternate request.

such request pairs are created. Then the limited backtracking step of the heuristic, described in the next section, ensures the mutual exclusion of the original and the alternate requests.

Overview of heuristic for single machine problem Theorems 1–3 allow us to establish a set of immediate predecessors for each job. Based on this set, a network is created where the nodes represent the jobs and the directed arcs connecting any two nodes represent precedence constraints. In other words, the immediate predecessor set of job j defines the set of origin nodes for arcs that terminate at the node representing j. Fictitious super-source and a super-sink nodes are added to represent the start and end times of the scheduling horizon, respectively. The contribution to the objective function for processing job j is represented by the length of the arc leaving the corresponding node. For example, if job j has priority p, the length of the arcs leaving node j is pp, the positive contribution to the objective function of a priority p job. Given a path from source to sink, the corresponding schedule is feasible if all the jobs along the path can be processed within their time windows. A DP approach is used to find the longest path in the network in which the time windows are enforced as side constraints during the computations. The following notation is needed to present the model: zj : pj : fj : PREDj : OPT( j):

maximum cumulative objective through completion of job j; contribution of job j to the objective; end time of the event of job j, fj ¼ tj þ pj; set of immediate predecessors for job j; the optimal immediate predecessor for job j.

The element OPT(j) is determined by finding a job iAPREDj that maximizes pj þ zi

ð25Þ

subject to fi pbj

ð26Þ

Equation (26) guarantees that job j has sufficient time to meet its deadline. The end time of request j is calculated as fj ¼ maxf fi þ pj ; aj þ pj g:

ð27Þ

The heuristic for finding the longest path starts by sorting all jobs in increasing order of their start times. In case of ties,

the order is chosen by the earliest end time. The first job in the sequence is job 0, the fictitious node representing the start of the planning horizon, so we set z0 ¼ 0. Based on the job ordering, Equations (25) and (26) are used to find zi and the optimal immediate predecessor for each job i. Note that the method is not exactly a forward dynamic program because there is no step for recomputing the zi - values based on updated information. The solution is determined by backtracking through the optimal immediate predecessors. The process starts from the fictitious dummy sink node associated with the end of the planning horizon and continues until the source node is reached. The effective earliest start and latest end times of the requests are calculated during this process. These values define the band of time that each request can be processed without affecting the ordering of the final schedule. Mutually exclusive artificial alternate requests are introduced for jobs that do not satisfy the condition in Theorem 2; but only one of those jobs should exist in the final solution. To enforce feasibility in this case, the backtracking operation is limited. In particular, it does not allow the optimal immediate predecessors for a request to include any of its mutually exclusive alternates. In addition, if the data set contains requests with two time windows that have been decomposed into separate requests, we need to consider them in the same manner as we do mutually exclusive alternate requests. For a given pair of jobs, whenever a check is made to determine whether or not they are mutually exclusive, it is also necessary to check if they are the same job. The logic for doing this is included in the description of the algorithm presented in Appendix A.

R–B example The same data set as in Table 1 of the GRASP example will be used to illustrate the R–B heuristic. It is presented again in Table 2 with the addition of the latest ending times for each request. The scheduling period begin time is 0 ¼ min(1, 0, 4, 0, 0) and the scheduling period end time is 13 ¼ max(5, 6, 8, 10, 13). Let requests 6 and 7 be the dummy requests representing the period begin time and end time of the planning horizon, respectively. p6 ¼ 0:1; d6 ¼ 0:0; c6 ¼ 0:0; a6 ¼ 0:0 0:1 ¼ 0:1; b6 ¼ 0:0 0:1 ¼ 0:1 p7 ¼ 0:1; a7 ¼ 13:0; b7 ¼ 13:0; d7 ¼ 13:0 þ 0:1 ¼ 13:1; c7 ¼ 13:0 þ 0:1 ¼ 13:1 Since the condition aipaj implies dipdj for all i, jAJ in Theorem 2 does not hold for all pairs of requests, mutually exclusive artificial alternate requests need to be created. These additional requests are summarized in Table 3.


Table 2 Data of the requests for the R–B heuristic example Request (i)

Earliest start (ai)

Latest start (bi)


Latest end (di)

1 0 4 0 0

3 3 5 6 8

2 3 3 4 5

5 6 8 10 13

1 2 3 4 5

Table 3 Additional mutually exclusive artificial alternate requests Request (i)

From

Earliest start (ai)


Latest end (di)

8 9 10 11 12

(2,1) (4,1) (4,3) (5,1) (5,3)

3 3 7 3 7

3 4 4 5 5

6 10 10 13 13

Assuming each request contributes equally to the objective, we set p1 ¼ p2 ¼ p3 ¼ p4 ¼ p5 ¼ p6 ¼ p7 ¼ p8 ¼ p9 ¼ p10 ¼ p11 ¼ p12 ¼ 1. From Theorems 1 to 3, the immediate predecessor sets are PRED1 ¼ |, PRED2 ¼ {6}, PRED3 ¼ {2, 4, 5, 1}, PRED4 ¼ {2, 5}, PRED5 ¼ {4}, PRED6 ¼ |, PRED7 ¼ {2, 4, 5, 1, 8, 9, 11, 3, 10, 12}, PRED8 ¼ |, PRED9 ¼ |, PRED10 ¼ {2, 5, 1, 8}, PRED11 ¼ |, PRED12 ¼ {2, 4, 1, 8, 9, 3}. The immediate predecessor relations among the jobs are illustrated in Figure 3. Next, we sort the requests in the order of the earliest starting times, and in case of ties, by the order of the deadlines. This order is (6,2,4,5,1,8,9,11,3,10,12,7). For request 6: z6 ¼ 0.0; f6 ¼ 0.0. For request 2: PRED2 ¼ {6}; z2 ¼ z6 þ p2 ¼ 0.0 þ 1.0 ¼ 1.0; OPT(2) ¼ 6; f2 ¼ max(f6 þ p2, a2 þ p2) ¼ max(0.0 þ 3.0, 0.0 þ 3.0) ¼ 3.0.

8

Backtracking begins at node 7. The optimal immediate predecessors and the calculations of the effective earliest start and latest end times of the requests are as follows.

5 10

6

2

12

1

7

4 = 3

9

Figure 3

For request 4: PRED4 ¼ {2, 5}, omit 5 since it is not in front of 4 in the ordering; z4 ¼ (z2 þ p4) ¼ (1.0 þ 1.0) ¼ 2.0; OPT(4) ¼ 2; f4 ¼ max(f2 þ p4, a4 þ p4) ¼ max(3.0 þ 4.0, 0.0 þ 4.0) ¼ 7.0. For request 5: PRED5 ¼ {4}; z5 ¼ (z4 þ p5) ¼ 2.0 þ 1.0 ¼ 3.0; OPT(5) ¼ 4; f5 ¼ max(f4 þ p5, a5 þ p5) ¼ max(7.0 þ 5.0, 0.0 þ 5.0) ¼ 12.0. set PRED1 ¼ {6}; For request 1: PRED1 ¼ |, OPT(1) ¼ 6; f1 ¼ max z1 ¼ z6 þ p1 ¼ 0.0 þ 1.0 ¼ 1.0; (f6 þ p1, a1 þ p1) ¼ max(0.0 þ 1.0, 1.0 þ 2.0) ¼ 3.0. set PRED8 ¼ {6}; For request 8: PRED8 ¼ |, OPT(8) ¼ 6; f8 ¼ max z8 ¼ z6 þ p8 ¼ 0.0 þ 1.0 ¼ 1.0; (f6 þ p8, a8 þ p8) ¼ max(0.0 þ 3.0, 0.0 þ 3.0) ¼ 3.0. set PRED9 ¼ {6}; For request 9: PRED9 ¼ |, OPT(9) ¼ 6; f9 ¼ max z9 ¼ z6 þ p9 ¼ 0.0 þ 1.0 ¼ 1.0; (f6 þ p9, a9 þ p9) ¼ max(0.0 þ 4.0, 0.0 þ 4.0) ¼ 4.0. For request 11: PRED11 ¼ |, set PRED11 ¼ {6}; z11 ¼ z6 þ p11 ¼ 0.0 þ 1.0 ¼ 1.0; OPT(11) ¼ 6; f11 ¼ max (f6 þ p11, a11 þ p11) ¼ max(0.0 þ 5.0, 0.0 þ 5.0) ¼ 5.0. For request 3: PRED3 ¼ {2, 4, 5, 1}, since f44b3 and f54b3, predecessors 4 and 5 are infeasible; z3 ¼ max(z2 þ p3, z1 þ p3) ¼ max(1.0 þ 1.0, 1.0 þ 1.0) ¼ 2; OPT(3) ¼ 2; f3 ¼ max(f2 þ p3, a3 þ p3) ¼ max(3.0 þ 3.0, 4.0 þ 3.0) ¼ 7.0. For request 10: PRED10 ¼ {2, 5, 1, 8}, since f54b10, predecessor 5 is infeasible; z10 ¼ max(z2 þ p10, z1 þ p10, 1.0 þ 1.0, 1.0 þ 1.0) ¼ 2.0; z8 þ p10) ¼ max(1.0 þ 1.0, OPT(10) ¼ 2; f10 ¼ max(f2 þ p10, a4 þ p10) ¼ max (3.0 þ 4.0, 0.0 þ 4.0) ¼ 7.0. For request 12: PRED12 ¼ {2,4,1,8,9,3}; z12 ¼ max(z2 þ p12, z4 þ p12, z1 þ p12, z8 þ p12, z9 þ p12, z3 þ p12) ¼ max(1.0 þ 1.0, 2.0 þ 1.0, 1.0 þ 1.0, 1.0 þ 1.0 1.0 þ 1.0, 2.0 þ 1.0) ¼ 3.0; OPT(12) ¼ 4; f12 ¼ max(f4 þ p12, a5 þ p12) ¼ max(7.0 þ 5.0, 0.0 þ 5.0) ¼ 12.0. For request 7: PRED7 ¼ {2,4,5,1,8,9,11,3,10,12}; z7 ¼ max(z2 þ p7, z4 þ p7, z5 þ p7, z1 þ p7, z8 þ p7, z11 þ p7, z3 þ p7, z10 þ p7, z12 þ p7) ¼ z9 þ p7, max(1.0 þ 0.0, 2.0 þ 0.0, 3.0 þ 0.0, 1.0 þ 0.0, 1.0 þ 0.0, 1.0 þ 0.0, 1.0 þ 0.0, 2.0 þ 0.0, 2.0 þ 0.0, 3.0 þ 0.0) ¼ 3.0; OPT(7) ¼ 5; f7 ¼ max(f5 þ p7, a7 þ p7) ¼ max(12.0 þ 0.1, 13.0 þ 0.1) ¼ 13.1.

11

Immediate predecessor graph.

OPT(7) ¼ 5 implies request 5 is scheduled. The effective earliest starting time and deadline for request 5 are: 0 0 0 ¼ f5 – p5 ¼ 12.0 – 5.0 ¼ 7.0; d5 ¼ min(d5, a7 ) ¼ min a5 (13.0,13.0) ¼ 13.0. OPT(5) ¼ 4 implies request 4 is scheduled. The effective earliest starting time and deadline for request 4 0 0 0 are: a4 ¼ f4 – p4 ¼ 7.0 – 4.0 ¼ 3.0; d4 ¼ min(d4, a5 ) ¼ min (10.0,7.0) ¼ 7.0. OPT(4) ¼ 2 implies request 2 is scheduled. The effective earliest starting time and deadline for request 2

818 Journal of the Operational Research Society Vol. 54, No. 8 0

0

0

are: a2 ¼ f2 – p2 ¼ 3.0 – 3.0 ¼ 0.0; d2 ¼ min(d2, a4 ) ¼ min (6.0,3.0) ¼ 3.0. OPT(2) ¼ 6 implies that all the scheduled jobs are identified given that 6 is the dummy request representing the beginning of the planning horizon. The solution sequence is (6, 2, 4, 5, 7) which is shown as by the solid arrows in Figure 3.

Solving the multiple machine case To find solutions to the parallel machine problem, the single machine problem is solved sequentially m times. The order of application is based on the amount of schedulable service time; that is, the sum of the processing times of all requests that a machine can handled. The machine with the least amount of schedulable service time is selected first, and so on.

Complexity of the R–B heuristic The R–B heuristic for the single machine problem consists of two components as shown in Appendix A. In terms of the run time, the predominant effort is in building the network. Most of this work is embodied in Step 6 of the predecessor set determination procedure and can be done in O(k2) time, given that the kth jobs is being considered. As k takes on values from 1 to n, the overall complexity is Skn ¼ 1k2 ¼ O(n3).

Computational results Both the GRASP and R–B heuristic were implemented in C þ þ using the CC compiler version 2.0.1 on a SUN Sparcstation 10 with 96 MB of RAM. Each program was compiled with the optimization flag set to -O and CPU times were collected using the C function clock(). One busy day scenario associated with NASA’s TDRSS was used to compare the two approaches. This instance is similar to the one referenced in Dodd and Reddy23 and contains a total of 418 jobs to be processed over 24 h on six antennae (machines). In all, there are 20 priority classes, but there were no requests for class 14. Some requests may have discontinuous time windows within which they can be processed. Time windows are machine dependent, but the processing times are not. Some of the high-priority users may have requests with fixed time windows (no slack time) because they want to use the antennae whenever they are in view of the satellite. The total time of all the requests is 43 3580 s or 43 3580/6 ¼ 72 263 s per machine. The average processing time of the requests is 1037.27 s with the standard deviation of 701.43 s per machine. Out of the 418 request, 52 requests have discontinuous time windows, while 149 requests have fixed time windows. The number of requests that can be processed and the total processing time on machine 1–6 are (253, 279970), (253, 279970), (250, 273267), (250, 273267), (89, 40200), and (91, 41400), sequentially. The results, in terms of the number of jobs processed by priority level and the computation times for each heuristic, are summarized in Table 4. The GRASP was run with three

Table 4 Comparative results for the different heuristics Number of jobs processed Priority

User name

R-B

GRASP (3)

GRASP (5)

GRASP (7)

Total jobs

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

SPCE-STN SHUTTL-1 SHUTTL-2 TMS OTV SPCE-TEL ALOS LARS FIREX MET-1 MET-2 BRTS-W BRTS-E BRTS-S TOPEX TH-MAP AXAF UARS-B SURV-B GRAV-B Total CPU (s)

45 46 34 7 1 23 23 14 6 11 14 23 24 0 16 9 13 14 16 16 355 184

45 46 41 8 1 27 26 14 5 13 14 23 24 0 16 10 12 10 16 16 367 365

45 46 41 8 1 27 26 14 5 13 14 23 24 0 16 8 14 11 16 16 368 367

45 46 41 8 1 27 26 14 5 13 14 23 24 0 16 9 12 10 16 16 366 366

45 46 59 12 1 30 27 14 15 14 14 24 24 0 16 15 15 15 16 16 418


specified for the input parameter—‘number of iterations,’ and is often about twice the time required for the R–B heuristic.

References

Figure 4

Comparisons on the two-priority data sets.

different sizes for the restricted candidate list. Based on the strict priority enforcement criterion, all three solutions provided by the GRASP dominated the solution found with the R–B heuristic. This is evidenced once the priority 3 user, SHUTTL-2, is reached, and reinforces the results obtained in Rojanasoonthon and Bard20 for randomly generated data sets. The computational time of the GRASP depends significantly on the number of iterations specified in the run. With 60 iterations on each priority level, the GRASP took approximately twice as long as the R–B heuristic. Comparative results for 25 randomly generated data sets with six machines and 400 jobs evenly divided between two priority classes are plotted in Figure 4. Weight assignments were made to ensure strict priority enforcement. In particular, lower priority jobs were assigned a weight of one, while higher priority jobs were given weights of 201. This scheme implies an upper bound on the objective function of 40 400. In order to measure the distance of the GRASP solution from optimality, additional testing was conducted as described in Rojanasoonthon and Bard.20 Twenty-five 20-job, two-machine instances were solved for the MILP formulation and it was found that the GRASP solution was always within 5% of the optimum.

Conclusions Parallel machine scheduling is an extremely difficult combinatorial optimization problem, posing an array of challenges for the research community. In this paper, two heuristics were presented for a generalized version of the problem that arose in scheduling NASA’s tracking and data relay satellite system. The novelty of the work centers on the inclusion of job priorities, non-homogeneous machines, and multiple time windows in a single model. After thorough testing, the results showed that the GRASP consistently out-performed the R–B dynamic programming heuristic in its ability to find high-quality solutions. This was demonstrated by solving a typical busy day instance with both procedures. Nevertheless, the time required to find good solutions with the GRASP is highly dependent on the value

1 Arbabi M (1984). Range scheduling automation. IBM Technical Directions 10: 57–62. 2 Arbabi M and Pfeifer M (1987). Range and mission scheduling automation using combined AI and operations research techniques. In: Griffin S (ed). First Annual Workshop on Space Operations Automation and Robotics (SOAR ‘87): NASA Conference Publication 2491. Washington. DC, pp 315– 320. 3 Reddy SC and Brown WL. Single processor scheduling with job priorities and arbitrary ready and due times. Working paper, October 1986, Computer Sciences Corporation. Beltsville, MD. 4 Cheng TCE and Sin CCS (1990). A state-of-the-art review of parallel-machine scheduling research. Eur J Opl Res 47: 271– 292. 5 Gensch DH (1978). An industrial application of the traveling salesman’s subtour problem. AIIE Trans 10: 362–370. 6 Butt SE and Cavalier TM (1994). A heuristic for the multiple tour maximum collection problem. Comput Opns Res 21: 101–111. 7 Kataoka S and Morito S (1988). An algorithm for single constraint maximum collection problem. J Opns Res Soc Japan 31: 515–530. 8 Golden BL, Levy L and Dahl R (1981). Two generalizations of the traveling salesman problem. Omega 8: 439–441. 9 Balas E (1989). The prize collecting traveling salesman problem. Networks 19: 621–636. 10 Golden BL, Levy L and Vohra R (1987). The orienteering problem. Nav Res Logist Q 34: 307–318. 11 Reddy SD (1988). Scheduling of tracking and data relay satellite system (TDRSS) antennas: scheduling with sequence dependent setup times. Presented at ORSA/TIMS Joint National Meeting, Denver, CO. 12 Gabrel, V (1995). Scheduling jobs within time windows on identical parallel machines: new model and algorithms. Eur J Opl Res 83: 320–329. 13 Randhawa SU and Kuo CH (1997). Evaluating scheduling heuristics for non-identical parallel processors. Int J Prod Res 35: 969–981. 14 Tsiligirides T (1984). Heuristic methods applied to orienteering. J Opl Res Soc 35: 797–809. 15 Laporte G and Martello S (1990). The selective traveling salesman problem. Discrete Appl Math 26: 193–207. 16 Ramesh R and Brown KM (1991). An efficient four-phase heuristic for the generalized orienteering problem. Comput Opns Res 18: 151–165. 17 Ramesh R, Yoon YS and Karwan MH (1992). An optimal algorithm for the orienteering tour problem. ORSA J Comput 4: 155–165. 18 Kantor MG and Rosenwein MB (1992). The orienteering problem with time windows. J Opl Res Soc 43: 629–635. 19 Feo TA and Resende MGC (1995). Greedy randomized adaptive search procedures. J Glob Optimiz 6: 109–133. 20 Rojanasoonthon S and Bard JF (2001). A grasp for parallel machine scheduling with time windows. Working Paper, 2001, Graduate Program in Operations Research. University of Texas, Austin, TX. 21 Or I. Traveling salesmen-type combinatorial problems and their relation to the logistics of blood banking. PhD thesis, 1976,


Department of Industrial Engineering and Management Sciences, Northwestern University, Evanston, IL. 22 Rojanasoonthon S. Parallel machine scheduling with time windows. PhD thesis, 2003. Graduate Program in Operations Research and Industrial Engineering, University of Texas, Austin, TX. 23 Dodd JC and Reddy SD. The scheduling technology in the NASA TDRSS network control center (NCC). AAS paper, October 1987, Computer Sciences Corporation. Beltsville, MD.

b. Requests o[l] and o[k] are not mutually exclusive alternates. c. Latest ending time not greater than the earliest starting time of the current request plus the maximum band length. That is, do[l]pao[k] þ MAXTOL. d. The earliest starting time not greater than the begin time of the current request. That is, ao[l]pao[k].

Appendix A R–B single machine heuristic

e. Earliest end time not greater than the latest start time of the current request (Theorem 3). That is, co[l]pbo[k].

A.1. Procedure for determining the predecessor sets Step 1: Create mutually exclusive artificial alternate for all request pairs not satisfying the condition that aioaj implies diodj. Step 2: Determine the maximum band length MAXTOL

max ðdj aj Þ j

Step 3: Order the requests in increasing order of earliest starting times. That is, find o[1], o[2],y, o[n] such that ao½1 oao½2 o oao½n Step 4: Initialize the current request to the first in the above order. That is, put k’1 and K’o[k] Step 5: Set the current request to the next in the above order. That is, put k’k þ 1 and K’o[k]. Step 6: For the current request, find its earliest immediate predecessor. That is, find smallest j such that if aipajpak and requests i and j are not mutually exclusive alternates, then di obj 8i 2 fl : al oaj g and maxfdi ; aj g þ pj oak 8i 2 fl : al oaj g: Denote such j as ^j . Step 7: Set the latest time a request can start such that it ends before the earliest starting time of the current request. That is, LPTo½k

maxfdo½i ; ao½^j g 8i 2 fl : al oa^j g

Step 8: Include in the immediate predecessor set of the current request PREDo[k], every request l such that al4aˆ which satisfies the following conditions: a. Latest ending time is greater than the latest possible start time of its predecessors which was calculated in Step 7 (Theorem 1). That is, do[l]4LPTo[k].

Step 9: If kpn, go to Step 5; otherwise stop.

A.2. Heuristic for sequencing requests Step 1: Initialize the On-Schedule-Flags to zero for all requests. That is, put FLAGj’0 for all j. Step 2: Set the schedule generation period begin time to the earliest starting time of all the bands. That is, put SGB’minj aj. Step 3: Set the schedule generation period end time to the latest ending time. That is, put SGE’maxj dj. Step 4: Define a fictitious request to represent the schedule period begin time. Set its duration to a small value, for example, 0.1. Set its earliest starting time to the schedule generation period begin time minus the small value. Set its latest ending time to the schedule generation period begin time. That is, put p0’0.1, d0’SGB, c0’SGB, a0’SGB–0.1, and b0’SGB–0.1. Step 5: Define a fictitious request to represent the schedule period end time. Set its duration to a small value, for example, 0.1. Set its earliest starting time to the schedule generation period end time minus the small value. Set its latest ending time to the schedule generation period end time plus the small value. That is, put pn þ 1’0.1, an1’SGE, dn þ 1’SGB þ 0.1, and bn1’SGB, cn þ 1’SGB þ 0.1. Step 6: Set the benefit associated with each request. The appropriate benefit for a request is the duration of the request if the objective is to maximize the total time scheduled. The appropriate benefit is 1 if the objective is to maximize the number of events scheduled. That is, pj

pj if objective is to maximize time scheduled

pj

1 if objective is to maximize the requests scheduled


(Note that pj has value 0 for fictitious requests, and value equal to that of the original request if j is an artificial mutually exclusive alternate.) Step 7: Determine the set of immediate predecessor requests for each request using the above procedure. That is, determine PREDj for each j. (Note that since a fictitious request is added and it can precede any request, PREDj is not empty for any j.) Step 8: Order the requests in increasing order of earliest starting times and, in case of ties, in increasing order of latest ending times. That is, find o[1], o[2], y, o[n] such that ao½1 pao½2 pao½n and do½j pdo½j þ 1

if ao½j ¼ ao½j þ 1

(Note that n is the number of the original requests plus the number of mutually exclusive alternates created for each original request. In addition, there are two fictitious requests giving a total of n þ 2. However, the index of the first and last fictitious requests are zero and n þ 1, so the request indices are 0, 1,y, n þ 1.) Step 9: Initialize the end time and the maximum cumulative benefit realized through the completion of an event for the schedule generation period begin time fictitious request. That is, put f0’SGB and z0’0. Step 10: Set the current request to the first request in the above order. That is, put k’1 and K’o[k]. Step 11: Set the current request to the next request in the above order. That is, put k’k þ 1 and K’o[k]. Step 12: Determine the maximum cumulative benefit and the optimal predecessor for the current request using the following algorithm. Define zj as the maximum cumulative benefit realized through completion of the event for request j, fj as the end time of the event for request j, PREDj as the set of predecessors for request j, OPT(j) as the optimal predecessor for request j. Find pAPREDo[k] to maximize zo[k] such that (i) fppbo[k], (ii) the optimal predecessor chain for request p does not include a mutually exclusive alternate for the current request,

(iii) poo[k] (to make sure that zp is already defined). Then put zo½k

po½k þ zp

fo½k

maxffp þ po½k ; ao½k þ po½k g

OPTðo½kÞ

p

Step 13: If kpn, go to Step 11. Step 14: Set the current request to the fictitious request representing the schedule generation period end time. That is, put k’n þ 1. Step 15: Calculate the earliest starting time of the effective band for the current request. That is, put EFF(ak)’fn þ 1 – pn þ 1. Step 16: Calculate the latest ending time of the effective band for the current request. That is, put EFF(dk)’fn þ 1. Step 17: Initialize the earliest starting time of the effective band of the immediate successor request. That is, put BSUCCR’EFF(ak). Step 18: Find the optimal immediate predecessor of the current request. That is, put p’OPT(k). Step 19: Go to Step 26 if the optimal immediate predecessor of the current request is the schedule generation period begin time fictitious request. That is, go to Step 26 if p ¼ o[0]. Step 20: Set the On-Schedule-Flag for the optimal immediate predecessor of the current request to 1. That is, put FLAGj’1. Step 21: Set the earliest starting time of the effective band for the optimal immediate predecessor of the current request. That is, put EFF(ap)’fp – pp. Step 22: Set the latest ending time of effective band for the optimal immediate predecessor of the current request. That is, put EFFðd p Þ minfd p ; BSUCCRg. Step 23: Reset the earliest starting time of the effective band of the immediate successor request. That is, put BSUCCR’EFF(ap). Step 24: Set the current request to its optimal immediate predecessor. That is, put k’p. Step 25: Go to Step 18. Step 26: Stop. The sequence of scheduled requests described by On-Schedule-Flags and the effective bands define the schedule.

Received April 2002; accepted January 2003