Ecient approximation algorithm for minimizing makespan. on uniformly related machines. Chandra Chekuri. November 25, 1997.

Transcription

1 Ecient approximation algorithm for minimizing makespan on uniformly related machines Chandra Chekuri November 25, 1997 Abstract We obtain a new ecient approximation algorithm for scheduling precedence constrained jobs on machines with dierent speeds. The setting is as follows. There are n jobs, job j requires p j units of processing. The jobs are to be scheduled on a set of m machines. Machine i has a speed s i ; it takes p j =s i units of time for machine i to process job j. The precedence constraints on the jobs are given in the form of a partial order. If j k, processing of k cannot start until j is completely done. Let C j denote the completion time of job j. The objective is to minimize C max = max j C j conventionally called the makespan of the schedule. We consider non-preemptive schedules where a job is processed on a single machine with no preemptions. Recently Chudak and Shmoys [1] gave an approximation algorithm p with a performance ratio of O(log m) improving upon the earlier ratio of O( m) due to Jae [6]. Their algorithm is based on solving a linear programming relaxation of the problem. Building on some of their ideas, we present a new ecient and combinatorial algorithm which achieves a similar approximation ratio but runs in O(n 3 ) time. In the process we also obtain a new lower bound which is of independent interest. By a general result of Shmoys, Wein, and Williamson [9] this algorithm can be extended to obtain an algorithm with an approximation ratio of O(log m) even if each job j has a release date r j before which it cannot be processed. 1 Introduction The problem of scheduling precedence constrained jobs on a set of identical parallel machines to minimize makespan is one of the oldest problems for which approximation algorithms have been devised. Graham [4] showed that a simple list scheduling gives a ratio of 2 and it is the best known algorithm till date. We consider a generalization of this model in which machines have dierent speeds which in the scheduling literature are called uniformly related. We formalize the problem below. There are n jobs 1; : : :; n, with job j requiring processing of p j units. The jobs are to be scheduled on a set of m machines. Each machine i has a speed factor s i. Job j with a processing requirement p j takes p j =s i time units to run on machine i. We restrict ourselves to non-preemptive schedules where a job once started on a machine has to run to completion on the same machine. Our results carry over to the preemptive case as well. In the scheduling literature [5] where problems are classied in the jj notation, this problem is referred to as QjprecjC max. Supported by an IBM Co-operative Fellowship, an ARO MURI Grant DAAH and NSF Award CCR , with matching funds from IBM, Schlumberger Foundation, Shell Foundation, and erox Corporation. chekuri@cs.stanford.edu. 1

2 Liu and Liu [8] analyzed the performance of Graham's list scheduling algorithm and showed that the approximation guarantee depends on the ratio of the largest to the smallest speed. This ratio could be arbitrarily large even for a small number of machines. The rst algorithm to have a bound independent of the speeds was given by Jae [6], who showed that list scheduling restricted to the set of machines which are within a factor of p m of the fastest machine gives an O( p m) bound. More recently, Chudak and Shymoys [1] improved the ratio considerably and gave an algorithm which has a guarantee of O(log m). At a more basic level their algorithm has a guarantee of O(K) where K is the number of distinct speeds. The above mentioned algorithm relies on solving a linear programming relaxation and uses the information obtained from the solution to allocate jobs to processors. We present a new algorithm which nds an allocation without solving a linear program. The ratio guaranteed by our algorithm is also O(log m) but it oers a couple of advantages. First, our algorithm runs in O(n 3 ) time and is combinatorial, hence is provably more ecient than the algorithm in [1]. Second, we show a new combinatorial lower bound which is natural and might be useful in other contexts. We remark here that our algorithm was inspired by, and builds upon the ideas in [1]. The rest of the paper is organized as follows. Section 2 contains some of the ideas from Chudak and Shmoy's paper [1] that are useful to us. We present the new lower bound in Section 3, and give the approximation algorithm and the analysis in Section 4. 2 Preliminaries We summarize below the basic ideas in the work of Chudak and Shmoys [1]. Their main result is an algorithm which gives a ratio of O(K) for the problem of QjprecjC max where K is the number of distinct speeds. They also show how to reduce the general case with arbitrary speeds to one in which there are only O(log m) distinct speeds as follows. Ignore all machines with speed less than 1=m times the speed of the fastest machine. Round down all speeds to the nearest power of 2. They observe that the above transformation can be done while losing only a constant factor in the approximation ratio. Therefore we will restrict ourselves to the case where we have K distinct speeds. Graham's analysis shows that any schedule produced by list scheduling has a chain of jobs j 1 j 2 : : : j r where a machine is idle only when one of the jobs in the chain is being processed. The time spent processing the above chain is a lower bound on the optimal makespan. Similarly the time spent when all machines are busy is also a lower bound. Combining these two facts give the upper bound of 2 on the performance ratio of list scheduling. One can apply a similar analysis for the multiple speed case. As observed in [1], the diculty stems from the fact that we can no longer claim that the processing time of the chain is a lower bound. All that can be said is that the processing time of any chain on the fastest machine is a lower bound. The jobs in the chain guaranteed by the list scheduling analysis do not necessarily run on the fastest machine. Based on this, the authors of [1] observed that one of the important objectives is to nd an assignment of jobs to speeds (machines) which ensures that the processing time of any chain is bounded by some factor of the optimal. We will follow the notation of [1] for sake of continuity and convenience. Let m k be the number of P machines with speed s k, k = 1; : : :; K, where s 1 > : : : > s K. Let Mu v denote v the sum m l. Let k(j) denote the speed at which job j is assigned to be processed. 2

3 The average processing allocated to a machine of a specic speed k, denoted by D k is the following. D k = 1 p j : m k s k j:k(j)=k It is also possible to compute the maximum over all chains C, of the following quantity p j s j2c k(j) which will be denoted by C. A natural variant of list scheduling called speed based list scheduling is developed in [1] which is constrained to schedule according the speed assignments of the jobs. As in the classical list scheduling, a job is scheduled as soon as a machine is free, provided the free machine matches the speed assignment of the job. The following theorem whose analysis is a simple generalization of Graham's analysis is from [1]. Theorem 1 (Chudak & Shmoys) For any job assignment k(j), j = 1; : : :; n, the speedbased list scheduling algorithm produces a schedule of length C max C + The authors of [1] use a linear programming relaxation of P the problem to obtain a job K assignment which simultaneously satises the two conditions: k=1 D k (K + p K)Cmax and C ( p K+1)Cmax where C max is the optimal makespan. Combining these with Theorem 1 gives them an O(K) approximation. We will show how to use an alternate method based on chain decompositions to obtain an assignment satisfying similar properties. 3 A new lower bound In this section we develop a simple and natural lower bound which will be used in the analysis of our algorithm. Before formally stating the lower bound we provide some intuition. The two lower bounds used in Graham's analysis for identical parallel machines are the maximum chain length and the average load. As discussed in the previous section, the maximum chain length (maximum according to processing times) has to be redened for the case when machines have dierent speeds. A naive generalization implies that the maximum chain length divided by the fastest speed is a lower bound. However it is easy to generate examples where this bound is a factor of 1=m away from the optimal. We describe the general nature of such examples to motivate the new bound. Suppose we have two speeds with s 1 = D and s 2 = 1, and l > 1 independent chains of jobs each of the same length D. Suppose m 1 = 1, and m 2 = l D. The average load can be seen to be bound by 1. Similarly the time to process any chain on the fastest processor is 1. However if D l it is easy to observe that the optimal is (l) since only l machines can be used at any time. We try to capture these types of situations in our lower bound in a simple way. We can view the precedence relations between the jobs as a weighted poset where each element of the poset has a weight associated with it that is the same as the processing time of the associated job. We will assume that we have the transitive closure of the precedence constraints. We will need a few denitions. Denition 1 A chain P is a set of jobs j 1 ; : : :; j r such that for all 1 i < r, j i j i+1. The length of a chain P denoted by j is the sum of the processing times of the jobs in P. K k=1 D k : 3

4 Denition 2 A chain decomposition P of a set of precedence constrained jobs is a partition of the poset in to a collection of chains fp 1 ; P 2 ; : : :; P r g. A maximal chain decomposition is one in which P 1 is a longest chain and fp 2 ; : : :; P r g is a maximal chain decomposition of the poset with elements of P 1 removed. Denition 3 Let P = fp 1 ; P 2 ; : : :; P r g be any maximal chain decomposition of the precedence graph of the jobs. We dene a quantity called L P associated with P as follows. L P = max 1jmin(r;m) jp ij s i With the above denitions in place we are ready to state and prove the new lower bound. Theorem 2 Let P = fp 1 ; P 2 ; : : :; P r g be any maximal chain decomposition of the precedence n graph of the jobs. Let AL = j=1 p i P m which represents the average load. Then s i C max maxfal; L Pg Moreover the lower bound is valid for the preemptive case as well. Proof: It is easy to observe that Cmax AL. We will show the following for 1 j m Cmax jp ij s i which will prove the theorem. Consider the rst j chains. Suppose our input instance was modied to have only the jobs in rst j chains with the precedence constraints induced by the original instance. It is easy to see that a lower bound for this modied instance is a lower bound for the original instance. Since it is possible to execute only one job from each chain at any time instant, only the fastest j machines are relevant for this modied instance. j The expression jp ij is nothing but the average load for the modied instance, which as s i we observed before is a lower bound. Since the average load is also a lower bound for the preemptive case, the bound is valid for that case as well. 2 Theorem 3 A maximal chain decomposition can be computed in O(n 3 ) time. If all p j the same, the running time can be improved to O(n 2p n). are Proof: It is necessary to nd the transitive closure of the given graph of precedence constraints. This can be done in O(n 3 ) time using a BFS from each vertex. From a theoretical point of view this can be improved to O(n! ) where! 2:376 using fast matrix multiplication [2]. A longest chain in a weighted DAG can be found in O(n 2 ) time using standard algorithms. Using this at most n times, a maximal chain decomposition can be obtained. If all p j are the same (without loss of generality we can assume they are all 1) the length of a chain is the same as the number of vertices in the chain. It is possible to use this additional structure to obtain a maximal chain decomposition in O(n 2p n) time. We defer the details. 2 4

5 1. compute a maximal chain decomposition P = fp 1 ; : : :; P r g of the jobs. 2. set l = 1. set B = maxfal; L P g. 3. foreach speed 1 i k do P (a) let l t r be max index such that ljt j j=(m i s i ) 4B. (b) assign jobs in chains P l ; : : :; P t to speed i. (c) set l = t + 1. If l > r return. 4. return. Figure 1: Algorithm Chain-Alloc 4 The approximation algorithm The approximation algorithm we develop in this section will be based on the maximal chain decompositions dened in the previous section. As mentioned in Section 2, we will describe an algorithm to produce a job assignment where each job is assigned to a specic speed. Then we use the speed based list scheduling of Chudak and Shmoys with the job assignment produced by our algorithm. Essentially, the algorithm in Figure 1 computes a lower bound B on the optimal using a maximum chain decomposition, and allocates the chains in non-increasing lengths to the speeds such that no speed is loaded more than four times the lower bound. We now prove several properties of the above described allocation which leads to the performance guarantee of the algorithm. Lemma 1 If chain is assigned to speed i, then jj s i 2B. Proof: Suppose some chain violates the above condition. Then let be the chain with the least index which violates it (hence longest among the violating chains) and let s u be the speed to which it is assigned. From the denition of L P and B it follows that jp 1 j=s 1 B. Therefore it must be the case that P u > 1 and that j > m 1. Let v be the index such that M v?1 1 < j M1 v (recall that M 1 v = v m l). If j > m, no such index exists and we set v to K, the slowest speed. If j m, for convenience of notation we assume that j = M1 v simply by ignoring other machines of speed P s v. From P the denition of L P, AL, j and B, we get the following. If j m then L P ( jp v ij)=( m is i ). If j > m then m i s i ). In either case we obtain the fact that j P ij v m maxfl P ; ALg = B (1) ls l AL ( jp ij)=( P K Since j j=s u > 2B, it must be the case that jp i j=s u > 2B for all M 1 < i j. This implies that j jp i j > 2B(j? M M1 1 )s u 2B <i 5 v m l s l (2)

6 We claim that each of the machines in speeds 1 to u? 1 have an average load greater than 2B. This is because for all 1 i < j we have jp i j=s k(i) 2B and, the algorithm is willing to load the machines to an average load of 4B. In addition it is true that j j=s 2B. Therefore we have jp ij P m ls l > 2B (3) From Equations 1 and 2 we obtain the following sequence of inequalities. M j jp i j B m l s l M1 jp i j j + jp i j B( m l s l + M1 <i M1 jp i v j + 2B m l s l B( m l s l + 1 jp i j + B B v v m l s l B m l s l B v m l s l From Equations 1 and 4 we obtain the following j jp i j B v m l s l B( m l s l + 2B From Equation 1 and above we conclude that j v v m l s l ) m l s l ) using Equation 2 m l s l (4) v m l s l ) m l s l using Equation 4 jp i j 2B m l s l The last inequality above contradicts Equation 3. Hence our assumption about must be incorrect which proves the lemma. 2 Lemma 2 Algorithm Chain-Alloc allocates all chains to some speed. Proof: Let be the rst chain which is not allocated. As in the argument in the proof of Lemma 1, each speed is loaded to an average load greater than 2B. This is a contradiction since that would imply that AL > B where AL is the average load of each machine. 2 Lemma 3 For 1 k K, D k 4C max. 6

7 Proof: Since B C max and the algorithm never loads a speed to more than an average load of 4B the bound follows. 2 Lemma 4 For the job assignment produced C 2KC max. P Proof: Let P be any chain. We will show that p j2=s k(j) 2KCmax. Let A i be the set of jobs in P which are assigned to speed P i. Let P l be the longest chain assigned to speed i by the algorithm. We claim that jp l j j2a i p i. This is because the jobs in A i form a chain when we picked P l to be the longest chain in the max chain decomposition. From Lemma 1 we know that jp l j=s i 2B 2Cmax. Therefore it follows that k j2p p j s k(j) = ja i j s i 2KC max Theorem 4 Using speed based list scheduling on the job assignment produced by Algorithm Chain-Alloc gives a 6K approximation where K is the number of distinct speeds. Furthermore the algorithm runs in O(n 3 ) time. The running time can be improved to O(n 2p n) if all p j are the same. Proof: From Lemmas 3 we obtain that D k 4Cmax for 1 k K and from Lemma 4 we obtain C 2KCmax. Putting these two facts together, for the job assignment produced by the algorithm Chain-Alloc, speed based list scheduling gives the following upper bound by Theorem 1. C max C + K k=1 D k 2KC max + 4KC max 6KC max : It is easy to see that the speed based list scheduling can be implemented in O(n 2 ) time. The running time is dominated by the time to do the maximum chain decomposition. Theorem 3 gives the desired bounds. 2 Corollary 1 There is an algorithm which runs in O(n 3 ) time and gives an O(log m) approximation ratio to the problem of scheduling precedence constrained jobs on uniformly related machines. We remark here that the leading constant in the LP based algorithm in [1] is better. We also observe that the above bound is based on the lower bound which is valid for preemptive schedules as well. Hence our result is valid for preemptive schedules. In [1] it is shown that the lower bound provided by the LP relaxation is a factor of (log m= log log m) away from the optimal. Surprisingly it is easy to show using the same example as in [1] that our lower bound from Section 3 is also a factor of (log m= log log m) away from the optimal. Theorem 5 There are instances where the lower bound given in Theorem 2 is a factor of (log m= log log m) away from the optimal. Proof: The proof of Theorem 3:3 in [1] provides the instance and it is easily veried that any maximum chain decomposition of that instance is a factor of (log m= log log m) away from the optimal

8 4.1 Release Dates Now consider the scenario where each job j has a release date r j before which it cannot be processed. By a general result of Shmoys, Wein, and Williamson an approximation algorithm for the problem without release dates can be tranformed to one with release dates losing only a factor of 2 in the process. Therefore we obtain the following. Theorem 6 There is an O(log m) approximation for the problem Qjprec; r j jc max runs in time O(n 3 ). which 5 Conclusions The main contribution of this paper is a simple and ecient O(log m) approximation to the scheduling problem QjprecjC max. Chudak and Shmoys [1] provide similar approximations for the more general case when the objective function is the average weighted completion time (Qjprecj P w j C j ) using linear programming relaxations. We believe that the techniques of this paper can be extended to obtain a simpler and combinatorial algorithm for that case as well. It is known that the problem of minimizing makespan is hard to approximate to within a factor of 4=3 even if all machines have the same speed [7]. However, for the single speed case a 2 approximation is known, while the best known ratio for the multiple speed case is only O(log m). Obtaining a constant factor approximation, or improving the hardness are interesting open problems. References [1] F. Chudak and D. Shmoys. Approximation algorithms for precedence-constrained scheduling problems on parallel machines that run at dierent speeds. Proceedings of the Eighth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), [2] D. Coppersmith and S. Winograd. Matrix multiplication via arithmetic progression. Proceedings of the 19th ACM Symposium on Thoery of Computing, 1{6, [3] M.R. Garey and D.S. Johnson. Computers and Intractability: A Guide to the Theory of NP-completeness, Freeman, San Francisco (1979). [4] R.L. Graham. Bounds for certain multiprocessor anomalies. Bell System Tech. J. 45:1563{81, [5] R.L. Graham, E.L. Lawler, J.K. Lenstra and A.H.G. Rinnooy Kan. Optimization and approximation in deterministic sequencing and scheduling: a survey. Ann. Discrete Math. 5:287{326, [6] J. Jae. Ecient scheduling of tasks without full use of processor resources. Theoretical Computer Science, 26:1{17, [7] J.K. Lenstra and A.H.G. Rinnooy Kan. Complexity of scheduling under precedence constraints. Operations Research, 26:22{35, [8] J.W.S. Lui and C.L. Lui. Bounds on scheduling algorithms for heterogeneous computing systems. In J.L Rosenfeld (ed.), Information Processing 74, North-Holland, 349{353,

9 [9] D. Shmoys, J. Wein, and D. Williamson. Scheduling parallel machines on-line. SIAM Journal on Computing, vol 24, 1313{31,