Parallel machine scheduling under a grade of service provision

Transcription

1 Computers & Operations Research 31 (200) Parallel machine scheduling under a grade of service provision Hark-Chin Hwang a;1, Soo Y. Chang b;, Kangbok Lee b a Department of Industrial Engineering, Chosun University, 375 Susuk-Dong, Dong-Gu, Gwangju , South Korea b Industrial Engineering Department, Division of Electrical and Computer Engineering, Pohang University of Science and Technology, San 31 Hyoja-Dong, Pohang, Kyungbook , South Korea Abstract We consider the problem of scheduling parallel machines that process service requests from various customers who are entitled to many dierent grade of service (GoS) levels. We propose and analyze one simple way to ensure such dierentiated service. In particular, we investigate how the longest processing time rst algorithm (LPT) would perform in the worst case and show that a slight modication of LPT could signicantly improve its worst-case performance.? 2003 Elsevier Ltd. All rights reserved. Keywords: Parallel machine scheduling; Longest processing time rst; Eligibility; Grade of service 1. Introduction In service industry, the service providers often have special customers, such as, silver, gold, or platinum members who are more valued than the regular members. Those special members are usually entitled to premium services, and, hence, some kind of dierentiated service policy must be implemented by the service provider. One simple scheme for providing dierentiated service is to label machines and jobs with prespecied grade of service (or GoS) levels and allow each job to be processed by a particular machine only when the GoS level of the job is no less than the GoS level of the machine. In eect, the processing capability of the machines labelled with high GoS levels tends to be reserved for the jobs with high GoS levels. Hence, if we label relatively higher GoS levels on the jobs from valued Corresponding author. address: syc@postech.ac.kr (S.Y. Chang). 1 Supported by research funds from Chosun University /$ - see front matter? 2003 Elsevier Ltd. All rights reserved. doi: /s (03)0016-3

2 2056 H.-C. Hwang et al. / Computers & Operations Research 31 (200) customers, we can ensure better service to more valued customers. In such situation, assigning jobs to the machines becomes a parallel machine scheduling problem with a special eligibility constraint. Although the makespan is not always the best choice for measuring the goodness of the schedule, it is chosen as the objective function to be minimized in this paper for the following reason. We are looking at the particular case where we have a few clusters of the same number of identical parallel processors and one special processor called load balancer. The load balancer receives and collects customer service requests over a short period of time and assigns the batch of collected jobs to one of the idle clusters. The load balancer recognizes each cluster to be idle only when each cluster completes the processing of all the jobs in the batch under processing and register its idle state to the load balancer. In order to have each cluster get ready as soon as possible for the next batch, the makespan of the schedule for each batch is certainly the most appropriate measure to be minimized. For more formal denition of our problem instance, we dene J ={a 1 ;:::;a n } and M ={ ;:::; } to be the sets of jobs and machines, respectively. Each job a j requires the processing time of p(a j ) and is labelled with the GoS level of g(a j ). Each machine b i is also labelled with the GoS level g(b i ) and b i is allowed to process job a j only when g(b i ) 6 g(a j ). A schedule is, then, a partition of J into m disjoint sets, S = S 1 ;:::;S m, such that S i is allowed to include a j only if g(b i ) 6 g(a j ). The makespan of a schedule S can be dened as max 16i6m t(s i ), where t(s i )= a j S i p(a j )ifs i, and 0, otherwise. Then, an instance of our scheduling problem can be denoted by (J; M; p; g) or (J; M) for short, which we call an instance of the parallel machine scheduling with GoS eligibility. When all the jobs have the same GoS level, say, we may delete all the machines with their GoS level greater than, and only have to deal with the machines having their GoS level less than or equal to. In such special case, if the number of machines that we need to deal with is m, we see that our problem is the ordinary identical parallel machine scheduling problem of minimizing the makespan which is often denoted by P m C max, following the notational convention developed in [1]. The decision version of this problem is NP-complete but pseudo-polynomially solvable for m = 2. It is NP-complete in the strong sense for m 3, since the 3-PARTITION problem, which is known to be NP-complete in the strong sense, can be reduced to the decision version of P 3 C max [2]. To tackle NP-hard problems, theoretical research has been focused on analyzing the worst-case performance of approximation algorithms. In the case of P m C max without eligibility constraints, LPT (longest processing times rst) and MULTIFIT [3] yield schedules with makespan no more than m [] and times the optimum [5], respectively In the case of the problem with eligibility, Azar et al. [6] presented a kind of list scheduling algorithm, AW, and proved that it always generates a schedule with makespan no greater than log 2 2m times optimum. However, this bound is not a constant but an increasing function of m. Lenstra et al. [7] proposed a binary search algorithm based on linear programming and proved the constant worst-case bound of two for the most general problem of unrelated parallel machine scheduling which certainly covers the case of the problem with eligibility. However, their algorithm must employ linear programming solution module whose computational complexity is not yet proven to be strongly polynomial. In other words, its complexity is polynomially bounded with respect not to the number of constraints and variables but to the actual magnitudes of the values of data dening the particular linear programming problem to be solved. In this paper, we propose a simple algorithm, that we call lowest grade-longest processing times rst (LG-LPT) whose computational complexity is strongly polynomial and the worst-case makespan

3 H.-C. Hwang et al. / Computers & Operations Research 31 (200) of the generated schedule is no more than twice the optimum. In particular, the makespan of the schedule generated by the proposed algorithm is proven to be no more than 5 for m = 2 and 2 1=(m 1) for m 3 times the optimum. In Section 2, we demonstrate the importance of taking the eligibility into account and establish a basic property of our proposed algorithm. In Section 3, we present the result of our worst-case analysis. 2. Algorithm AW The algorithm AW, proposed by Azar et al. in [6], simply picks and assigns an arbitrary unassigned job to one of the eligible machines that has the least load, while breaking ties by choosing the machine with the lowest index. We note that AW does not take the eligibility into account in deciding the order of jobs to be assigned. Due to this, for some of our problem instances, AW may yield a schedule with theoretically proven worst-case makespan of log 2 2m times the optimum, as demonstrated in the following example. Example 1. Consider a problem with J and M, where m = n =2 k for some positive integer k. Every job has the same processing time of 1 and the GoS levels of machines and jobs are set as; g(a 1 )=m; g(a 2 )=m 1;:::;g(a m )=1 and g( )=1;g( )=2;:::;g( )=m. Then, AW may yield a schedule that the rst m=2 jobs, a 1 ;a 2 ;:::;a m=2, are assigned to the machines ; ;:::;=2, next m= jobs are assigned to the machines ; ;:::;= and so on, until the last two jobs a m and a m 1 are both assigned to the machine yielding the makespan of log 2m as shown in Fig. 1. However, an optimal schedule with makespan of 1 can be constructed by assigning job a j to machine j+1 for all j, 16 j 6 m. A worthwhile thing to be noted at this point is the fact that even LPT could also yield exactly the same schedule as AW, since every job has identical processing time in this particular example. This clearly suggests a better approach to the problem in which not only the processing time but also the eligibility of each job is taken into account. In fact, as demonstrated below, we can even get an optimum solution for this problem, if we assign jobs to their eligible machines in a proper order obtainable by the use of the eligibility information. a 1 a 2 a m/2+1 a m-3 a m/2+2 a m-1 a m-2 a m a m a m-1 / a m/ / a m/-1 /2 a m/2 /2 /2+1 /2+1 a m/2+1 a m/2 (a) (b) a 1 Fig. 1. (a) AW and (b) optimal schedule.

4 2058 H.-C. Hwang et al. / Computers & Operations Research 31 (200) Instead of an arbitrary ordering, consider the ordering of jobs where the job a j precedes a k when g(a j ) g(a k ), or if g(a j )=g(a k ), p(a j ) p(a k ) holds. And we denote such precedence by a j a k, and call it LG-LPT order. In the case of the above example, one can easily observe that an optimum solution can be obtained, if AW picks and assigns jobs in the order of LG-LPT instead of choosing jobs arbitrarily. The development of our algorithm is motivated by this simple observation. Throughout the remaining of this paper, we assume that a j 1 a j, j =2; 3;:::;n and g(b i 1 ) 6 g(b i ), i=2; 3;:::;m, for notational simplicity. Also, we assume that the optimum makespan is always 1, since we can redene p(a j )asp(a j ) divided by the optimum makespan, without loss of generality. For further notational convenience, we introduce the concept of the range of each job, denoted by (a j ) which is simply the number of machines that are eligible to process a j, namely the number of machines with g(b i ) 6 g(a j ). Then, due to the nature of (a j ) and the assumed ordering of machines, we observe that the job a j can be assigned to any one of the rst (a j ) machines, i.e. through b (aj). Also note that we can assume that (a n )=m, since, otherwise, we can delete all b i s with g(b i ) g(a n ), without changing the structure of the problem. 3. Algorithm LG-LPT The algorithm LG-LPT fetches the rst one from the list of unassigned jobs sorted in LG-LPT order and assigns it to the least-loaded eligible machine, as formally described in Fig. 2. In the next theorem, we analyze the worst-case performance of LG-LPT. Fig. 2. Algorithm LG-LPT.

5 H.-C. Hwang et al. / Computers & Operations Research 31 (200) Theorem 1. For identical parallel machine scheduling problem with GoS eligibility, LG-LPT always yields a schedule with its makespan. 6 5 times the optimum makespan for m =2, 6 2 1=(m 1) times the optimum makespan for m 3. Proof. We prove the theorem in two separate cases. Case 1: m 3. Suppose that the theorem is false for m 3. Then, there must exist a counterexample (J; M) with m 3 for which LG-LPT cannot yield a schedule with makespan no more than 2 1=(m 1) times the optimum makespan. Let us further suppose that the problem instance (J; M) isminimal, meaning that the set J contains the least number of jobs among all counterexamples. Then, due to this minimality, we claim that the makespan of the minimal counterexample is determined by the last job a n. This claim is true due to the following. If (J; M) is a minimal counterexample, LG-LPT should successfully assign jobs a 1 ;:::;a n 1 within time 2 1=(m 1) and fail to do so only for the last job a n. This is because if LG-LPT failed to assign a job a j for j n within time 2 1=(m 1), we can construct another counterexample (J ;M) with J = {a 1 ;:::;a j } which has strictly less number of jobs than (J; M). Hence, a clear contradiction to the minimality of (J; M) results. Let S be the partial schedule that we have at the time right before the job a n is assigned. Then, noting that job a n was not assigned within time 2 1=(m 1), we can easily see that t(s i )+p(a n ) 2 1 for 1 6 i 6 m: (1) m 1 We note, then, S m must contain at least one job, since, otherwise, we have t(s m )+p(a n )= p(a n ) 2 1=(m 1) 1 for m 3 which is a clear contradiction. Hence, let a k be the job contained in S m. Then, a k S m implies (a k )=m and, therefore, p(a k ) should be as large as p(a n ), due to LG-LPT order. Hence, t(s m ) p(a k ) p(a n ): (2) By summing up inequalities (1) for i = 1 through m 1, we get m 1 t(s i )+(m 1)p(a n ) 2m 3: i=1 Then by (2) m t(s i )+(m 2)p(a n ) 2m 3: i=1 And, since m i=1 t(s i)+p(a n ) 6 m, we have (m 3)p(a n ) m 3; (3) which can never hold since m 3 and 0 p(a n ) 6 1. Case 2: m=2. Suppose that the theorem is false. Then, again, there must exist a minimal problem instance (J; M) with m = 2, for which LG-LPT yields a schedule with makespan greater than 5. Then, due to minimality, the makespan is determined by the last job a n and certainly (a n )=2.

6 2060 H.-C. Hwang et al. / Computers & Operations Research 31 (200) Suppose that S is the schedule which we have at the time right before the job a n is assigned. Then we have t(s 1 )+p(a n ) 5 and t(s 2 )+p(a n ) 5 : () Hence, t(s 1 )+t(s 2 )+2p(a n ) 5 2. But, since t(s 1)+t(S 2 )+p(a n ) 6 2, p(a n ) 1 2 : Hence, we can have at most two jobs with (a j )=2 and S 1 contains all but only the jobs with (a j ) = 1. On the other hand, S 2 must contain at least one job, since, otherwise, we have t(s 2 )+ p(a n )=p(a n ) 5. Hence, if we let a k be the job contained in S 2, p(a k ) p(a n ) (6) due to LG-LPT order. Now, suppose that S is the optimum schedule. Then, certainly S 1 is a subset of S 1 and there could be only two possibilities. The set S 1 contains either one of a k or a n. However, neither case is possible, due to () and (6). In fact, when m = 2, our problem is reduced to a case of the non-simultaneous parallel machine scheduling problem where the rst machine must process all the jobs with (a j )=1 before processing any other job with (a j ) = 2. In this case, LG-LPT reduced to the algorithm LPT presented in [8] which is proved to have the worst-case performance ratio of m. This equals to 5 when m =2, which indeed conrms our result. We conclude our paper with the following example which shows that the above bound is tight indeed. Example 2. Case 1: m 3. Consider a problem with J and M, where m 3, g(b i )=i for all 1 6 i 6 m. InJ, there are m 2 small jobs a 1 ;:::;a m 2 and m big jobs a+ 1 ;:::;a+ m. Each small job a j has processing time of 1=(m 1) and g(a j )=m 1. Next, we consider the rst m 2 big jobs, a + 1 ;:::;a+ m 2. These jobs have processing time 1 1=(m 1) with g(a+ j )=m 2. Then for the remaining two big jobs, g(a + m 1 )=g(a+ m)=m and p(a + m 1 )=p(a+ m) = 1. For the given jobs we can list them in the LG-LPT order as follows: a + 1 a+ m 2 a 1 a m 2 a + m 1 a+ m: The LG-LPT will assign the rst m 2 big jobs to machines 1 to m 2, respectively. Then all the m 2 small jobs are assigned to machine m 1. Next, a + m 1 is assigned to machine m. At this time, all the machine loads are the same as 1 1=(m 1) except with the load of 1. Finally, the last big job a + m is assigned to machine 1 yielding a schedule with the makespan of 2 1=(m 1) as in Fig. 3. However, we can construct an optimal schedule S as S i = {a + i ;a i } for 1 6 i 6 m 2; S i = {a + i } for m 1 6 i 6 m: Case 2: m = 2. Let M = { ; }, J = {a 1 ;a 2 ;a 3 ;a }, g( )=1, g( )=2, g(a 1 )=1, g(a 2 )= g(a 3 )=g(a )=2, p(a 1 )= 1, p(a 2)= 3 and p(a 3)=p(a )= 1. Then, LG-LPT yields a schedule 2 (5)

7 H.-C. Hwang et al. / Computers & Operations Research 31 (200) a + 1 a + m a + 1 a + 2 a + 2 {a - 1, a - 2,, a m-2} {a - 1, a - 2,, a m-2} -2 a + m-2-2 a + m a + m-1 (a) a + m-1 (b) a + m Fig. 3. (a) LG-LPT and (b) optimal schedule. S such that S 1 = {a 1 ;a 3 ;a } and S 2 = {a 2 }. The makespan of S is 5, but an optimum schedule S with makespan of 1 can be constructed by setting S1 = {a 1;a 2 } and S2 = {a 3;a }. References [1] Pinedo M. Scheduling: theory, algorithms, and systems. Englewood Clis, NJ: Prentice-Hall, [2] Garey MR, Johnson DS. Computers and intractability: a guide to the theory of NP-completeness. New York: Freeman, [3] Coman Jr. EG, Garey MR, Johnson DS. An application of bin-packing to multiprocessor scheduling. SIAM Journal on Computing 1978;7:1 17. [] Graham RL. Bounds on multiprocessor timing anomalies. SIAM Journal on Computing 1969;17: [5] Yue M. On the exact upper bound for the MULTIFIT processor scheduling algorithm. In: Yue M, editor. Operations research in China. Annals of Operations Research 1990; 2: [6] Azar Y, Naor J, Rom R. The competitiveness of on-line assignments. Journal of Algorithms 1995;18: [7] Lenstra JK, Shmoys DB, Tardos E. Approximation algorithms for scheduling unrelated parallel machines. Mathematical Programming 1990;6: [8] Lee CY. Parallel machine scheduling with nonsimultaneous machine available time. Discrete Applied Mathematics 1991;30:53 61.