Approxiating Total Flow Tie on Parallel Machines Stefano Leonardi Danny Raz y Abstract We consider the proble of optiizing the total ow tie of a strea of jobs that are released over tie in a ultiprocessor setting. This proble is N P -hard even when we allow preeption, and have only two achines. Although the total (or average) ow tie is widely accepted as a good easureent of the overall quality of service, no approxiation algoriths were known for this basic scheduling proble. This paper contains two ain results. We rst prove that when preeption is allowed, Shortest Reaining Processing Tie (SRPT) is an O(log(inf n ; P g)) approxiation algorith for the total ow tie, where n is the nuber of jobs, is the nuber of achines, and P is the ratio between the axiu and the iniu processing tie of a job. We also provide an (log n ) and an (log P ) lower bounds on the (worst case) copetitive ratio of any randoized algorith for the on-line proble in which jobs are known at their release ties. Thus, we show that up to a constant factor SRPT is an optial on-line algorith. Our second ain result addresses the non-preeptive case. We present a general technique that allows q to transfor any preeptive solution into a non-preeptive solution at the n expense of an O( ) factor in the approxiation q ratio of the total ow tie. Cobining n this technique with our previous result yields an O( log n ) approxiation algorith for this case. We also show an (n 1 3? ) lower bound on the approxiability of this proble (assuing P 6= NP ). Dipartiento di Inforatica e Sisteistica, Universita di Roa \La Sapienza". This work was partially done while the author was a post-doc at the International Coputer Science Institute (ICSI), Berkeley. This work is partly supported by EU ESPRIT Long Ter Research Project ALCOM-IT under contract n 044, and by Italian Ministry of Scientic Research Project 40% \Algoriti, Modelli di Calcolo e Strutture Inforative." Eail: leon@dis.uniroa1.it y International Coputer Science Institute (ICSI), Berkeley. Research supported in part by National Science Foundation operating grants CCR-93047 and NCR-9416101. Eail: draz@icsi.berkeley.edu 1
1 Introduction Guaranteed quality of service is one of the ost challenging aspects in any areas of coputer science. In areas like networks and parallel coputing, guaranteeing high perforances for each user is the ain task of algorith and protocol designers. One ajor proble that arises in this context is quantifying the overall quality of service. In other words, which functions should we try to optiize when designing such systes. One relevant objective function is the overall tie the users are spending in the syste (both waiting for a service and being served). Miniizing this tie will yield a better service in general. In this paper we study this function in the context of scheduling probles, in this counity this function is referred to as the total ow tie. It turns out that the proble of nding an optial ow tie for a set of jobs with release ties on identical achines, is NP -hard even if we allow preeption. Although optiizing the ow tie is known to be an iportant scheduling proble for ore than two decades [B74], no results were known for this case. In this paper we provide the rst non-trivial approxiation results for this proble on parallel achines. The Model: We are given a set J of n jobs, and identical achines M 1 ; : : : M. Job j (we indicate the generic job of the set J by the index j, j = 1; : : : ; n) is described by a pair of real nubers (r j ; p j ), where r j 0 is the release tie and p j 0 is the processing tie of the job. Assue w.l.o.g. that tie 0 is the earliest release tie of any job in J. In the non-preeptive version of the proble, each job j ust be processed without interruption for a tie p j 0 on one of the achines, each of which can process at ost one job at a tie. In the preeptive version, a job that is running can be preepted and continue later on any achine. Clearly, a job cannot be processed before its release tie. The algorith, { also called scheduler { decides exactly which of the jobs should be executed at each tie. Dene Cj S to be the copletion tie of job j in a schedule S. When it is clear to which schedule we refer, the superscript S will be dropped. The ow tie of job j is dened as F j = C j? r j, and the total ow tie is P jj F j. Our goal is to construct an algorith that iniizes the total ow tie for each given instance of the proble. In the on-line version of the proble, jobs are introduced to the algorith at their release ties. Thus, the algorith bases its decisions only upon inforation related to already released jobs. Previous work: The reader is referred to [LLRS90] and to the ore recent [H96] for an excellent survey on scheduling and approxiation algoriths. In particular we adapt their notations, and thus denote by P jptn; r P j j F j the preeptive version of the proble, and by P jr P j j F j the non-preeptive version. In this notation, jj denote: (i) is either 1 for a single achine or P for identical achines, (ii) contains r j to indicate release ties, and ay contain ptn to indicate that preeption is allowed, and (iii) is P F j indicating that we are interested in the optiization of the total ow tie. Although ow tie is widely accepted as the easure one really wants to optiize in any contexts, not uch was known about it. The single achine case, 1jptn; r P j j F j, is solvable in polynoial-tie, using the shortest reaining processing tie rule [B74]. However, when preeption is not allowed, the proble becoes NP -hard [L77]. In a recent paper Kellerer, Tautenhahn, and Woeginger gave an O( p n) approxiation algorith for this case [KTW96]. They also showed that unless P = NP no polynoial tie approxiation algorith can have a worst-case perforance guarantee of O(n 1? ), for any > 0. When there are ore than one achine, Du, Leung, and Young [DLY90] proved that
Non-preeptive Preeptive Upper bound Lower bound Upper bound Lower bound One achine O( p n) (n 1? ) 1 { [KTW96] [KTW96] [B74] achines O( q n log n ) (n 1 3? ) O(log(inf n ; P g)) (log n ), (log P ) (on-line) Table 1: Suary of results P jptn; r j j P C j, the proble of iniizing the total copletion tie with achines, is NP -hard. Note that an optial solution for P jptn; r j j P C j is also an optial solution for P jptn; r j j P F j, since P F j = P C j? P r j, and P r j is deterined by the input. In [HSSW96], Hall, Schulz, Shoys and Wein studied this proble, they gave constant-factor approxiation algoriths both for P jptn; r j j P C j and for P jr j j P C j. However, unlike optial solutions, approxiation results for the average (or total) copletion tie do not apply to ow tie. Results: Shortest Reaining Processing Tie (SRPT) is the well studied algorith that assigns to the available achines at each tie, those unnished jobs with shortest reaining processing tie. We prove that SRPT is an O(log(inf n ; P g)) approxiation algorith for P jptn; r P j j F j, where P = ax i;j ( p i p j ), that is, P is the ratio between the biggest and the sallest processing tie of a job in J. As the rst step toward proving this result we give an alternative (yet equivalent) denition of ow tie. Instead of suing over all jobs j the ow tie of this job, F j, we su over all ties t the nuber of jobs that are already released but not yet nished at tie t (this nuber is denoted by (t)). Using this way of looking at the ow tie, we observe that if the dierence in (t) between SRPT and any other scheduler is \big", then SRPT ust process \sall" jobs. This observation is quantied in Lea 1, that iplies the O(log P ) bound, and after further work also the O(log n ) bound. Note that SRPT is an online algorith; it bases its decisions only upon the jobs released so far. In this context P ay be ore eaningful than n, since if we have a strea of jobs, and we want an online algorith to schedule the as to optiize the ow tie, it would be nice to have a bound that does not depend on the length of the sequence n. It turns out that for online algoriths this is basically the best one can hope for. >Fro a rather siple exaple that shows that SRPT cannot perfor better than our upper bound, we derive a faily of input instances which shows that the copetitive ratio of any randoized online algorith is (log n ) and (log P ). Note that there is no contradiction to the perforance analysis of the SRPT algorith; the \bad" instance for SRPT (in fact for any online algorith) is one with n = O(P ). Our bound for the preeptive case is later used as a basis for an approxiation algorith for P jr P j j F j. Our algorith starts with a preeptive schedule and converts it into a nonpreeptive one. A siilar idea was used by Kellerer, Tautenhahn, and Woeginger for the O( p n) approxiation algorith in the single achine case [KTW96]. We propose a general technique that converts any preeptive solution into a non-preeptive one, at the expenses of an O( q n ) factor in the approxiation ratio. We cobine this technique with our result for P jptn; r j j P F j 3
tie tie tie tie 4 1 1 31 31 1 1 1 1 30 30 8 1 1 8 1 1 1 1 1 1 4 4 4 4 16 8 4 4 16 8 4 4 0 16 8 8 1 3 4 5 6 7 8 9 10 11 1 13 14 15 16 jobs 1 3 4 5 6 δ 0 16 8 8 1 3 4 5 6 7 8 9 10 11 1 13 14 15 16 1 3 4 jobs δ Figure 1: The lower bound for SRPT and the optial solution. to achieve an O( q n log n ) bound for P jr jj P F j. Despite its generality, our technique turns out to be rather siple (when copared with the known algorith for the single achine case [KTW96]), yet it still obtains the best achievable bound when specialized to a single achine. Our scheduler divides the jobs, according to their ow tie in the preeptive solution, to \big" and \sall" jobs. Unlike any cases when seeking to iniize the akespan, we schedule the \sall" jobs rst. Jobs with relatively sall ow tie cannot delay other jobs by uch. Then we schedule the \big" jobs; here we use the fact that the nuber of \big" jobs is relatively sall, and so we can delay each job for a longer tie. q Putting together, the overall additional ow tie n paid to reove preeption is bounded by O( ) ties the value of the preeptive solution. We nally show that unless P = NP no polynoial tie approxiation algorith can have a worst-case perforance guarantee of O(n 1 3? ), for any > 0. The idea here also follows the nice construction of [KTW96]. Since a straightforward generalization of the single achine case does not see to work, we odify the construction and end up with a dierent sequence. Our new results, and the known results for one achine, are suarized in Table 1. This paper: Section. contains the analysis of SRPT in the preeptive case. The description of the lower bound for online preeptive algoriths follows in section.3. In Section 3.1 we present the approxiation algorith for the non-preeptive case. Then in Section 3. we present the unapproxiability result for non-preeptive algoriths. We end with a brief discussion and soe open probles. The approxiation of total ow tie with preeption.1 Preliinaries Shortest Reaining Processing Tie (SRPT) is the algorith that assigns those unnished jobs with shortest reaining processing tie, to the available achines at each tie. Dene R(t) = fj Jjr j tg, the set of jobs released within tie t, and n(t) = jr(t)j. At each tie t we consider the instant snapshot of the scheduler as the non decreasing vector X(t) = x 1 ; : : : ; x n(t) of the reaining processing tie of each job in R(t). If job j has been 4
nished by tie t, then the corresponding coponent in X(t) is 0. The vector at tie 0 is just the nondecreasing sorted vector of the processing ties of the jobs introduced at tie zero. We will use X S(J) (t) to describe the reaining processing tie of jobs in R(t) in a scheduler S on input J. The instance J ay be oitted in the following when clear fro the context. Given a vector X S(J) (t), for a scheduler S, instance J, and tie t, its volue v S(J) (t) denotes the su of its entries, and its support S(J) (t) denotes the nuber of its positive entries. We denote by d S(J) (t) = SRP T (J) (t)? S(J) (t) the support dierence between SRPT and a scheduler S at tie t. Given an input J and a scheduler S, dene the ow tie of S on J to be F S (J) = t0 S(J) (t)dt: P In order to realize that this denition of ow tie is equivalent to the usual denition as j F j, consider the left part of Figure 1. This picture, that will be analyzed in better detail at the beginning of section., shows part of the SRPT schedule for an instance with =. The left diagra represents the status of the jobs at each tie. If white, they have not been released yet or are nished, if dark gray they are processed, if light gray they are waiting. The su of the dark and light gray areas for each job j is exactly F j and the overall su of the dark and light gray areas is the total ow tie. The function shown in the right diagra, represents at any tie the nuber of jobs that are either processed or waiting. It is easy to see that the integral of this function is equal to the su of the dark and light areas in the left diagra.. The analysis of SRPT In this section we prove that SRPT is an O(log(inf n ; P g)) approxiation algorith. Observe that its tie coplexity is O(n log n). We need soe ore notations. Denote by x S(J) j (t) the reaining processing tie of the j- th sallest positive entry of X S(J) (t), that is the j-th sallest reaining processing tie of an unnished job at tie t. The ( + 1)-th sallest positive entry is of particular interest, and hence we indicate it with l S(J) (t) = x S(J) +1(t). This value is the reaining processing tie of the sallest job not processed at tie t. For an input instance J dene P ax (J) and P in (J) to be the axial and the inial processing tie of a job in J, respectively. Let P (J) = Pax(J) P in. Moreover, dene T (J) = (J) ftj SRP T (J) (t) g to be the set of ties when no achine is idle in the SRPT schedule, and let T (J) = jt (J)j = R tt (J) dt be the size of this set. As a war up, we give an exaple for the case = and we show that SRPT achieves the claied bounds. This exaple can be generalized to any on-line algorith for any nuber of achines (see Theore 9). Let P, a power of, and 1 be the axiu and the iniu processing ties of a job. At each tie r i = P (1? 1 ), for i = 0; : : : ; log P i? 1, three jobs are released; one job of processing tie P i and two jobs of processing tie P i+1. Then, starting at tie (P? 1), and until tie P + P? 3, two jobs of processing tie 1 are released at each unit of tie. Figure 1 shows the behavior of SRPT and of an optial solution on a prex of that sequence with P = 16. The left diagra indicates for each job its processing tie at the tie of release, and the reaining processing tie at the end of the considered interval. (This is indicated only for those jobs that are not nished). 5
At tie r i, SRPT schedules the two jobs released at tie r i of processing tie. These i+1 jobs are copleted by tie r i + P P. The interval of units of tie between r i+1 i+1 i + P and r i+1 i+1 P is used for the third job released at tie r i and for the job of processing tie released at i?1 tie r i?1. Both jobs have reaining processing tie P at tie r i i + P ; clearly, only one job is scheduled when i = 0. i+1 Observe that log P jobs are unnished at tie (P? 1) in the SRPT schedule. Now, at each tie (P? 1) + k, k = 0; : : : ; P? 1, two jobs of processing tie 1 are released. Therefore, log P jobs are waiting to be processed for P units of tie, resulting in a total ow tie of at least P log P. On the other hand, an optial solution nishes the three jobs presented at tie r i by tie r i+1. The job of processing tie P is scheduled on one achine at tie r i i, while the other achine is used for the two jobs of processing tie P. This results in an increase of the ow tie when we restrict the attention to the rst groups of i+1 jobs: the ow tie of the jobs released at tie r i is 5 P, and the total ow tie of the log P groups of jobs is bounded by 5P. But all jobs are nished in i the optial solution by tie (P? 1), and the ow tie of the nal P groups of jobs is just P. The (log P ) lower bound on the approxiation ratio of SRPT for = is then derived. Since n = O(P ), it turns out to be also an (log n) lower bound on the approxiation ratio of SRPT for the case of achines ((log n ) can be obtained for any ). At this point, observe again Figure 1. The reaining processing tie of scheduled jobs exponentially decreases with the nuber of unnished jobs in the SRPT schedule. In fact this represents a general phenoenon that lies in the heart of our proof. We observe that on any instance J, the value of l SRP T (J) (t) exponentially decreases with d S(J) (t), that is, if the support dierence between SRPT and any scheduler S is \big", then SRPT is processing jobs with \sall" reaining processing tie. More forally, Lea 1 For any scheduler S, instance J and tie t, if d S(J) (t) > i, for i, then l SRP T (J) infpax(j);t (J)g (t). i? We rst prove a slightly stronger version Lea 1 in the special case where at tie t, a scheduler S has nished all jobs, that is d S(J) (t) = SRP T (J) (t). Later, we reduce the general case to this special case. This is done by showing that the clai holds for an instance J, if it also holds for an instance J 0, obtained fro J by reoving those jobs that are not nished by S at tie t. Lea Let c = b ds(j) (t)?i c, for a scheduler S, instance J, tie t, and an integer i d S(J) (t)?. If S(J) SRP T (J) (t) = 0, then x (t) i infpax(j);t (J)g c?1. Proof: Consider the vector X SRP T (t) of the reaining processing tie of jobs in the SRPT schedule at tie t. Let v 1 be the volue of the biggest jobs, v be the volue of the next jobs, and so on until v i+1 which is the volue of the last 0 jobs unnished at tie t. Each one of these groups of at ost jobs is referred to as a block of jobs. Figure shows this vector. The biggest reaining processing tie inside block k is denoted by l k. Denote by V (t 0 ) = v SRP T (t 0 )? v S (t 0 ) the dierence in volue between SRPT and S at any tie t 0, and let V k = P hk v h. Since S (t) = 0, we know that V (t) = V 1 = v SRP T (t) is the total volue dierence at tie t. Let t 0 be the earliest tie such that no one of the achines is idle in the interval (t 0 ; t] in the SRPT schedule. The volue dierence V (t 0 ) at any tie t 0 (t 0 ; t] is upper bounded by V (t 0 ) (it cannot increase if all achines are working in the SRPT schedule). P 6
v v 1 v i+1 l i+1 v i l i l l 1 Figure : The reaining processing tie of jobs in the SRPT scheduler at tie t. If t 0 = 0, then the volue dierence at tie t 0 is 0. Thus, the SRPT volue at tie t is 0 and the clai is proved. We can then concentrate on t 0 > 0. In this case at least one achine is idle at tie t 0, and hence the volue dierence at tie t 0 is bounded by P ax. Dene the tie t k to be the last tie in [t 0 ; t] a job of reaining processing tie bigger than l k+1 is processed. If no such jobs are ever processed in the interval (t 0 ; t], then t k = t 0. We denote by k the total volue of those jobs with reaining processing tie less or equal than l k+1 at tie t k. Observe that all these jobs are processed at tie t k. In fact, if t k > t 0 there is a job of reaining processing tie bigger than l k+1 processed at that tie; otherwise, if t k = t 0, all jobs are processed at tie t 0 and have reaining processing tie saller than l k+1. Denote by Vk 0 the total volue of those jobs with reaining processing tie bigger than l k+1 at tie t k (they ay be scheduled or unscheduled at that tie). Figure 3 shows a typical case of this vector. Observe now that no job with reaining processing tie bigger than l k+1 at tie t k will be processed between tie t k and t, and hence they stay in the rst k blocks of jobs at tie t. Therefore, the volue of the rst k blocks of jobs at tie t, plus the value k is an upper bound over the volue at tie t k. Moreover, the volue at tie t k is not less than the volue dierence at tie t k, that is not less than the volue dierence at tie t, that is, due to our hypothesis, exactly equal to the volue at tie t. We obtain the following inequalities (v SRP T (t)? V k+1 ) + k V 0 k + k = v SRP T (t k ) V (t k ) V (t) = v SRP T (t) fro which we derive V k+1 k. Observe now that k l k+1 v k, and then V k+1 v k. Adding V k+1 to both ters of the previous inequality we get V k+1 1V k. We now separately prove the two parts of the clai: x SRP i T (t) P ax = c?1 and x SRP i T (t) T= c?1. >Fro V k+1 1 V k it follows that V c V 1 = c?1 P ax = c?1. But l c+1 v c V c, and hence we derive l c+1 P ax = c?1. Since c = b ds(j) (t)?i c, x SRP T i (t) l c+1, and the rst part of the clai is proved. For the second part of the clai, observe that 1 l. >Fro V 1, and using the sae arguent used to prove the rst part of the clai, we obtain x SRP i T (t) l = c?. We are left to 7
V k k l k+1 k Figure 3: The reaining processing tie of jobs in the SRPT scheduler at tie t k. prove that l t? t 0 T. The second inequality is true by denition of T. If we proved the existence of a job released in the interval (t 0 ; t] with processing tie bigger or equal than l, then we would prove l t? t 0 since such job is nished by scheduler S within tie t. But this is true, since less then jobs were running at tie t 0 and there are jobs with reaining processing tie bigger than l at tie t. Then, a job with processing tie bigger than l has been released in (t 0 ; t]. In order to prove Lea 1 we show that if Lea is true for an instance J 0 obtained by deleting fro J all the jobs that are not nished by S at tie t, then the clai of Lea 1 is true for J. To siplify notation we use x J SRP T (J) k(t) instead of xk (t). The exact clai is: Clai 3 Let J = J 0 [ j, and t be any tie t r j. Then either (i) J (t) = J0 (t) + 1 and for all 1 k J0 (t) x J k(t) x J0 k (t) x J k+1(t), or (ii) J (t) = J0 (t) and for all 1 k J0 (t) x J0 k (t) x J k(t) x J0 k+1(t). Proof: At tie t = r j, (i) holds. If (i) holds, 3 kinds of events can happen at any tie t: 1. J and J 0 end the sae nuber of jobs or no job is nished (they both end zero jobs). It follows that (i) still holds, since the rst jobs are processed for the sae aount of tie.. A new job is released. Also in this case (i) still holds since the new job is inserted into the appropriate place in both vectors. 3. J ends one ore job than J 0. In this case we switch to (ii), since we have that X J (t) is shifted to the left one position further than X J0 (t). Note that by condition (i), if J ends r jobs at soe tie then J 0 ust end at least r? 1 jobs at this tie, so 1-3 are the only possible events. In a siilar way, if (ii) holds, 3 kinds of events can happen at any tie t: 8
1. J and J 0 end the sae nuber of jobs or no job is nished (they both end zero jobs). It follows that (ii) still holds, just like in the previous case.. A new job is released. Also in this case (ii) still holds since the new job is inserted into the appropriate place in both vectors. 3. J 0 ends one ore job than J. In this case we switch to (i), since we have that X J 0 (t) is shifted to the left one position further than X J (t). In particular the last clai shows that 1 J (t)? J0 (t) 0. We can nally present the proof of Lea 1. Proof of Lea 1: Let J 0 be an input instance in which all jobs that are not nished by S at tie t are deleted. Let d = d S(J 0 ) (t)? d S(J) (t), and let s be the biggest integer such that d S(J) (t) > s. We want to prove the following sequence of inequalities: l SRP T (J) (t) x SRP T (J 0 ) +1+d (t) infp ax(j 0 ); T (J 0 )g b ds(j0 ) (t)??d?1 c?1 infp ax(j); T (J)g infp ax(j); T (J)g b ds(j) (t)??1 c?1 b ds(j) (t)?1 infp ax(j); T (J)g s? : The rst inequality follows fro Clai 3 since d is exactly the nuber of jobs in J? J 0 that are nished by SRPT until tie t. The second inequality is exactly Lea. For the third inequality, note that J 0 is a subset of J and hence P ax (J 0 ) P ax (J), T (J 0 ) T (J), and that d S(J) (t) = d S(J 0 ) (t)? d. The last inequality follows directly fro the denition of s, and proves the lea. Lea 1 allows to bound the support dierence between SRPT and any scheduler S. Lea 4 For any scheduler S, instance J and tie t, d S(J) (t) (3 + log P (J)). Proof: Since scheduled jobs with reaining processing tie less than P in are never preepted, any unnished job not scheduled has reaining processing tie bigger or equal than P in, that is l SRP T (t) P in for any t. >Fro Lea 1, that applies for d S (t) >, we derive Pax P s? in where s is the biggest integer i such that d S (t) > i. We then obtain s + log P and d S (t) (3 + log P ). >Fro Lea 4 we derive one of our ain results. Theore 5 SRPT is a 4 + log P approxiation algorith for P jptn; r P j j F j. Proof: For any scheduler S and instance J, the ow tie of SRPT is given by t0 t=t SRP T (t)dt = = t=t SRP T (t)dt + t=t t=t SRP T (t)dt + tt SRP T (t)dt + tt S (t)dt + tt c? SRP T (t)dt = ( S (t) + d S (t))dt tt (3 + log P )dt SRP T (t)dt + F S + (3 + log P )T 9
F S + (3 + log P ) X jj p j (4 + log P )F S : The rst equality is obtained by partitioning the tie into the set of ties T when all achines are working and the set of ties when at least one achine is idle. We obtain the second equality by introducing d S (t), the support dierence between SRPT and S. We apply Lea 4 to obtain the third inequality. The reaining inequalities are derived by observing that the global tie spent processing jobs by the achines is bounded by P jj p j that is itself bounded by F S, the ow tie of scheduler S. We now turn to prove that SRPT is an O(log n ) approxiation algorith for P jptn; r P jj F j. The proof is ore coplex than the proof of the O(log P ) approxiation. For instance, observe that it is no longer true that the support dierence between the SRPT scheduler and any algorith is bounded by O(log n). This can be observed in the lower bound proposed for SRPT at the beginning of this section, where at the end of the rst part of the sequence, one third of the jobs presented are not nished by SRPT, while they are all nished by a feasible scheduler. Our proof is based upon Lea 1, that relates the size of d S (t) to the reaining processing tie of a job not scheduled by SRPT at tie t. The idea behind the proof is that the worst case ratio between the SRPT ow tie and any scheduler ow tie can be raised only if a \big" dierence in the respective support values is kept for a \long" tie. But this requires, as in the second phase of the lower bound for SRPT, the release of a nuber of jobs with sall processing tie, and thus increasing the value of n. For the rest of this section x an instance J and any scheduler S. We partition T into a collection of disjoint intervals I k = [t k ; t k+1 ), k = 0; : : : ; s? 1, denote by x k = t k+1? t k the size of interval I k, and associate an integer i k to each interval such that (i k? 1) < d S (t) < (i k + 1), t [t k ; t k+1 ), as specied in the following. The t k 's are dened in the following way for any axial interval of ties [t b ; t e ) contained in T. Let t k = t b for soe value k. If at tie t b d S (t b ) < then i k = 0, otherwise i k = 1. (Observe that d S (t b ) <.) If t k and i k are dened then t k+1 = fin(t; t e )jt > t k ; d S (t) (i+1) or d S (t) (i?1)g, that is, t k+1 is the rst tie the support dierence reaches the value (i + 1) or (i? 1). We set i k+1 = i + 1 if d S (t k+1 ) (i + 1), i k+1 = i? 1 if d S (t k+1 ) (i? 1). Clearly, the last interval in which [t b ; t e ) is partitioned ends with t e, and d S (t e ) SRP T (t e ) <. Recall that we dene T i = f[i k ji k = ig, i 0, and we indicate T i = jt i j the size of set T i. The following lea relates the nuber of jobs, n, and the values T i. Lea 6 The following lower bound holds for the nuber of jobs: n 6T X i3 T i i?3 : Proof : The clai is obtained by charging a nuber of jobs n k to each interval, in a way that each job is charged at ost three ties. Interval I k T i, i, starts when the support dierence between SRPT and S reaches the value i, i. Consider the case in which d S (t k ) i. Observe that d S (t k ) < (i + 1) since d S (t) can vary at ost by at a single instance of tie. If the interval ends at tie t k+1 with d S (t k+1 ) (i + 1), the support dierence has increased by at least between t k and t k+1 and then scheduler S has nished at least jobs in that interval. We charge of these jobs to interval I k, but, observe that soe of the jobs nished by S at tie t k ay be charged to the previous interval, and soe of the jobs nished by S at tie t k+1 ay be charged to the next interval. 10
On the contrary, if the interval ends when d S (t k+1 ) (i? 1) then the support dierence has decreased by at least in the interval I k and then SRPT has nished at least jobs during the interval. In both cases we charge n k jobs to any interval I k T i, i. Observe that an interval I k of T i, i, is never truncated by the end of a axial interval [t b ; t e ) of T, since d S (t e ) SRP T (t e ) <. The case in which d S (t k ) < i is analogous to the previous one. We can then conclude with a rst lower bound n k on the nuber of jobs charged to any interval I k T i, i. Next we give a second lower bound, based on Lea 1, stating that any job scheduled during T an interval I k = [t k ; t k+1 ) has reaining processing tie bounded by, since d S (t) > (i i k?3 k? 1) for any t [t k ; t k+1 ). We partition the interval I k on each achine into a nuber of contiguous subintervals (recall that no achine is idle during T ) of axiu length T that are terinated i k?3 either with the end of a job or with the preeption of a job. Observe that any preeption corresponds to the release of a new job. Therefore, for each achine we can associate a job that is T either released or nished with any subinterval of size. A second lower bound on the nuber i k?3 of jobs charged to any interval is then given by n k b x k i k?3 c. T Observe now that each job is considered at ost three ties, when it is released, when it is nished by SRPT and when it is nished by S. Then, fro the following inequalities: T Pi3 T i P i?3 kji k 3 ax(1; b x k i k?3 c) 3n; the clai follows. Theore 7 SRPT is an O(log n ) approxiation algorith for P jptn; r P jj F j. Proof: The ow tie of SRPT is given by t=t t0 = SRP T (t)dt = = t=t t=t t=t SRP T (t)dt + T SRP T (t)dt + tt SRP T (t)dt + F S + X i0 tt SRP T (t)dt = ( S (t) + d S (t))dt tt i (i + 1)dt SRP T (t)dt + F S + 3(T 0 [ T 1 [ T ) + X i3(i + 1) T i = t=t SRP T (t)dt + F S + 3T + X i3(i? ) T i X X 3 p j + F S +? ) T i jj i3(i 4F S + X i3(i? ) T i : The third inequality is obtained by partitioning T into the T i 's and by observing that at any tie t T i the support dierence between SRPT and S is bounded by (i + 1). The fourth inequality is obtained fro the observation that at any tie t T 0 [ T 1 [ T the support dierence between SRPT and S is bounded by 3. The sixth inequality follows since the overall work done by the achines is bounded by the su of the processing ties P jj p j, while the nal 11
expression is obtained fro the fact that the su of the processing ties is a lower bound on the optial ow tie. To prove that SRPT is an O(log n ) approxiation algorith, we are left to prove that F (n) = P i3(i? ) T i = O(log n )F S. We do that by proving F (n) = O(T log n ), and then, fro T P jj p j F S the clai of the theore follows. To prove our nal clai, we use the relation, given in Lea 6, between the values of the T i 's and the nuber of jobs n. Our optiization proble is ax ft3 ;:::gf (n) = P i3(i? P ) T i n 6T i3 T i i?3 ; T P i3 T i : We rewrite the proble using variables Y i = P ji T j, i 3: ax fy3 ;:::gf (n) = P Pi3 Y i n 6T i3(y i? Y i+1 ) i?3 ; T Y 3 Y 4 : : : : The second constraint can be rewritten as n 6T (Y 3 + P i4 Y i i?4 ), and then the function is upper bounded by assigning T = Y 3 = : : : = Y l, and 0 = Y l+1 = Y l+ = : : : where l is the iniu integer such that the constraint is tight or violated, naely it is the iniu integer such that T 6T (1 + P l i=4 i?4 ) n. We then obtain for l the value l 4 + dlog 6n e, and then F (n) = O(T log n )..3 A lower bound for on-line preeptive algoriths In this section we show an (log n ), (log P ) lower bound on the copetitive ratio of on-line randoized algoriths for ; jptn; r j j; P F j. The iniu processing tie of a job in the sequence is 1, while the axiu processing tie is denoted by P. We require P to be big enough such that L = log P? 3 log( log P ) is soe positive integer value. We present a faily of instances, such that for any randoized on-line algorith there exists an instance in this faily that proves the lower bound. Any instance of the lower bound is divided into two parts in a way that at the end of the rst part of the sequence the on-line randoized algorith has an expected nuber of ( log P ) unnished jobs. The second part of the sequence, that starts iediately after the rst part, consists of releasing jobs with processing tie 1 at any of P successive integer instances of ties. The on-line expected total ow tie is then lower bounded by P log P, while we show an algorith that copletes the sequence with a total ow 4 tie of O( P ). The rst part of the sequence is fored by at at ost L phases. During any such a phase we release \long" jobs, and a set, denoted by S i, of \short" jobs, each having a processing tie of one unit. More forally, during phase i, i = 0; : : : ; L? 1, the following set of jobs are presented: jobs with p i = P i and r i = P (1? 1 i ), and jobs with p ij = 1 and r ij = r i + j; 8j = 0; : : : ; p i? 1: 1
Jobs of phase i are released between tie r i and tie r i + p i? 1. The \long" jobs of length p i are released at tie r i, while jobs of unit processing tie are released at any integer tie between r i and r i + p i? 1. The rst part of the instance is ended at soe phase when the expected nuber of jobs that are unnished by the on-line algorith is ( log P ). Let U i be the nuber of jobs of S i not nished at tie r i + p i by an on-line algorith, and let E(U i ) be the expected value of U i over the rando choices of the on-line algorith. We distinguish two cases: Lea 8 1. Either there exists a phase i such that E(U i ) log P, or. the probability that ore than 1 long job is nished by tie r L is therefore bounded by O( 1 log P ). Proof: Let us assue that case 1 never occurs, that is E(U i ) < log P for any i = 0; : : : ; L? 1. We want to bound the probability that a single long job, say a job of length p i = P presented in phase i, is nished by an on-line algorith by tie r i L. The axiu processing tie available on a single achine for this job in a phase j i is p j + U j. The probability that the job of length p i is nished is bounded by X L?1 P r[ j=i ( p j + U j) p i ] P r[p i? p L + X L?1 = P r[ U j p L ]: j=i L?1 X j=i U j p i ] = Since E(U i ) < log P, using Markov inequality we obtain that the probability that U i is bigger or equal than 3 (log P ) 1 is bounded by. Fro the denition of L we have L log P, and log P p L = ( log P ) 3. Now, P r[ P L?1 j=i U j p L = 3 (log P ) 3 ] 1 since it iplies that at least one log P of at ost L rando variables U j be bigger than 3 (log P ), which proves the lea. The expected nuber of unnished jobs in the on-line solution at the end of the rst part of the sequence is ( log P ). This is by denition if Case 1 occurs. If Case occurs, the expected nuber of long jobs that are nished at tie r L, when the Lth phase ends, is P L= 1 log P P L= i=1 log P 4, and therefore the ex- i=1 i P r[i long jobs are nished by tie r L ] pected nuber of unnished long jobs is ( log P ). If the rst part of the sequence ends in Case 1 during phase i, then the second part of the sequence consists of releasing jobs of processing tie 1 at any integer tie r i + p i + k, k = 0; : : : ; P? 1. The expected total ow tie of the on-line solution is then ( P log P ). Otherwise, if Case occurs, jobs with processing tie 1 are presented at any tie r L + k, k = 0; : : : ; P? 1. Also in this case the expected total ow tie of the on-line solution is ( P log P ). We prove in the following that in both cases the optial total ow tie is O(P ). Observe that all the jobs of phase i can be nished by tie r i+1 = r i + p i using the following schedule that we denote as standard schedule: (i) the long jobs of length p i are processed non-preeptively, each on one of achines, between tie r i and r i + p i ; (ii) of jobs of length 1 released at 13
tie r i + k, k = 0; : : : ; p i? 1 are processed at tie r i + k. The reaining jobs released at tie r i + k, k = 0; : : : ; p i? 1, are processed at tie r i + k + p i. The total ow tie of this schedule for phase i is p i + ( p i ). In case 1, the standard schedule is used for the jobs released during the rst i? 1 phases, with a total ow tie bounded by P + 4P. With regard to jobs released during phase i, the 4 P i jobs of unit length are scheduled at their release ties on the achines available and then copleted by tie r i + p i, with a contribution of P i to the total ow tie. The set of P pairs of jobs of unit length, released between tie r i + p i and r i + p i + P? 1, are also assigned at their release ties to the achines available, and then their ow tie is P. Finally, the long jobs (each of length p i ) of phase i are processed starting at tie r i + p i + P with a contribution of (P + 3p i) to the total ow tie. In case, the standard schedule is applied to all L phases of the rst part of the sequence. All the jobs of the rst part are then copleted by tie r L with a total ow tie bounded by P + 4P. The P jobs of unit length are processed at their release ties with a contribution of P to the total ow tie. Therefore, in both cases the standard schedule has a ow tie of O(P ). We can now state the following. Theore 9 Any randoized on-line algorith for P ; jptn; r P j j F j is (log P ), (log n ) copetitive. Proof: We have shown for any on-line randoized algorith an input sequence where the ratio between the expected ow tie of the algorith and the optial ow tie is (log P ). To prove the (log n ) lower bound it is enough to observe that for any of such sequence the nuber of jobs released is n = O( P ). 3 The approxiation of total ow tie without preeption In this section we present an approxiation algorith for the total ow tie in the non-preeptive case. This algorith is based on a technique that converts any preeptive schedule for q the given n input instance into a non-preeptive schedule. In doing so we \pay" an additional O( ) in the approxiation ratio, therefore by using our previous approxiation result for P jptn; r j j P F j we get an algorith with O( q n log n ) approxiation ratio for P jr jj P F j. We also show an (n 1 3? ), for any > 0, lower bound on the approxiation ratio of polynoial algoriths for the proble. 3.1 A non-preeptive algorith to approxiate total ow tie Denote by S p j, C p j, F p j = C p j?r j and S j, C j, F j = C j?r j the starting, copletion, and ow tie in a preeptive and in a non-preeptive solution, respectively. Since a job is processed continuously until its copletion in the non-preeptive case, we have C j = S j + p j, while for the preeptive case C p j S p j + p j holds. F p = P jj F p j and F = P jj F j indicate the total ow tie of the preeptive and non-preeptive solution. Observe that the ow tie of the optial preeptive solution, denoted by F, is a lower bound over the optial non-preeptive solution. 14
The algorith The set of jobs of an instance J are divided into two sets according to the preeptive solution. The set of sall jobs S = fj JjF p j F p p n g; The set of big jobs B = fj JjF p j > F p p n g. The sall jobs are scheduled rst. These jobs are sorted in order of starting tie in the preeptive solution and are assigned to the rst available achines, not before its starting tie in the preeptive solution. Once all the sall jobs are scheduled, big jobs are assigned one by one in an arbitrary order. Consider job j B. Select a achine M j Pwith no ore than ( + ) n scheduled jobs for a total processing tie less or equal than ( + ), where is an arbitrarily sall positive constant. jj p j Dene q ( + ) n intervals in the following way. Interval [t i; t i+1 ], i = 0; : : : ; q ( + ) n? 1, t 0 = S p j, contains p j units of idle tie on achine M j. Now, select an interval [t i ; t i+1 ] that q contains no ore than ( + ) n jobs, and schedule job j with starting tie S j = t i. Shift ahead the jobs of the interval without changing the relative order, if necessary. (The idea of dening this kind of interval is borrowed fro [KTW96].) Lea 10 The solution given by the algorith is feasible. Proof: Observe that all jobs are scheduled not before their starting ties in the preeptive solution, and hence not before their release ties. For any big job j, we require the selection of a achine M j eeting two requireents: (i) The nuber of jobs scheduled on M j is no ore than ( + ) n ; (ii) The total processing tie of jobs scheduled on M j is no ore than ( + ). It is easy to prove that ore than achines eet each one of the two requireents. It follows that P jj p j at least one eets both requireents. The selection of the interval for a big job j is also feasible. >Fro the selection of the achine, the nuber of scheduled jobs on M j is at ost ( + ) n. It follows that at least one of q ( + ) n intervals contains no ore than q ( + ) n jobs. The analysis We copute the approxiation ratio of the algorith by coputing the increase of the total ow tie with respect to the preeptive solution due to its transforation into a non-preeptive solution. The analysis for sall jobs is based on the following lea that bounds the starting tie of a job in the non-preeptive solution. Lea 11 For any job j S, S j S p j + p F p n. Proof : Consider any job j S. If S j = S p j, the clai is proved. Otherwise, since jobs are considered in order of starting tie in the preeptive solution, and assigned in the non-preeptive solution not before their starting ties in the preeptive solution, no achine is idle between tie S p j and S j. Dene t S p j to be the latest tie when all achines becoe assigned with a job; if such tie does not exist, then t = 0. There is a job j 0 with a starting tie S j 0 = S p j 0 = t. 15
Our goal is to bound the total processing tie P scheduled on the achines since tie t, until tie S j when job j is considered to be assigned. Since job j is assigned to the rst achine available, we have S j t + P. When job j 0 is assigned at tie t, all the other achines are assigned with jobs starting not later than tie t, and are busy at ost until tie t + ax hs p h. A rst contribution to P is then (? 1)ax hs p h. A second contribution to P is given by the su of the processing ties of jobs of S, with starting tie in the preeptive solution between t and S p j. All these jobs are started in the preeptive solution not before tie t and ended not later than S p j + ax hs F p h. Their contribution to P is bounded by ((S p j? t) + ax hsf p h ). We then obtain S j t + P Sp j + ax hs p h + ax hs F p h, fro which the clai follows. The increase of ow tie with respect to the preeptive solution due to the schedule of any sall job j S is then bounded by p F p n. We now turn to q big jobs. Assue that job j B is scheduled at the beginning of the ith interval, i = 0; : : : ; ( + ) n? 1. The starting tie of job j is delayed with respect to the starting tie in the preeptive solution by at ost the su of the processing ties of the jobs scheduled q on M j, plus p j units of idle tie for any previous interval. Moreover, each of at ost ( + ) n jobs scheduled in the ith interval are shifted by at ost p j units of tie. However, observe that jobs in other intervals are not aected fro the scheduling of job j. The increase in the total ow tie due to schedule of a big job j is then bounded by P r jj p j ( + ) + p j ( + ) n : We nally put everything together, obtaining for the total ow tie the following expression: X js F = X jj F j (F p j + F p X P p ) + n jb(f p jj p j j + ( + ) F p + r n F p + ( + ) r n X jj p j + r + p j ( + ) n (1 + r n )F p + (( + ) + p + )r n F = = O(r n )F p r ( + ) n ) The rst inequality derives by adding the increase in the ow tie, due to the non-preeptive schedule, to the value of the preeptive solution. The second inequality is obtained by observing that there can be (n) sall jobs, but at ost p n big jobs. The third inequality stes fro the fact that the su of the processing ties is a lower bound over the optial preeptive solution. All together we have proved the following theore. Theore 1 Given an f(n; ) approxiation algorith for P jptn; r j j P F j, one can construct an O( q n f(n; )) approxiation algorith for P jr jj P F j. X jb p j 16
Observe that the algorith can be ipleented with a running tie bounded by O(n 3= ). Since SRPT is an O(log n ) approxiation for the optial preeptive solution we can also conclude the following corollary. Corollary 13 There exists an O( q n log n ) approxiation algorith for P jr jj P F j. In the single achine case, SRPT provides the optial preeptive solution. Therefore, the approxiation ratio of the non-preeptive algorith is O( p n). 3. A lower bound for non-preeptive approxiation algoriths In this section we prove that no polynoial tie approxiation algorith for P jr j j P F j can have a guaranteed worst-case ratio of O(n 1 3? ), for any > 0 and n 4. We consider a reduction fro the sae NP-coplete proble { Nuerical 3-Diensional Matching (N3DM) { used in [KTW] to prove an (n 1? ) lower bound for this proble on a single achine. The use of a reduction fro N3DM is justied since it reains NP-hard even if the input instance is encoded in unary for. We extend their technique to give a lower bound on any polynoial tie algorith for any xed nuber of parallel achines. Observe that such a lower bound iediately extends to algoriths, as the one designed in Section 3.1, that receives as part of its input. An instance of N3DM (see [GJ76]) is fored by three sets of k positive integers fa i g; f b i g; and fc i g, 1 i k, with P k i=1 a i + b i + c i = kd. The proble is to decide whether there exist perutations, and, such that a i + b (i) + c (i) = D holds for all i. Fix a value of. We transfor any instance I of N3DM into a second instance I 0 for which k is a ultiple integer of, and has a solution if and only if I has a solution. If k od > 0 then the instance I 0 is obtained by adding 3(? k od ) jobs, with size a i = D, b i = c i = 0, for i = 1; : : : ;? k od. It is easy to check that this new instance has the desired property. Given an instance of the proble with k ultiple integer of, and 0 < 1, we dene the 3 corresponding instance of P jr P j j F j as follows. Dene nubers: n = d(30k) 4= D 3= e; r = d3dn (1?)=3 e; g = 100rk : The scheduling instance contains the following jobs: 3k \big" jobs with release tie 0 and processing ties r + a i, 4r + b i, and 8r + c i, for 1 i k. kgr \tiny" jobs of type T 1, all of the with a processing tie of 1=rg. There are jobs with release ties of l(14r + D + 1)? 1 + p=rg for l = 1; : : : ; k, and p = 0; : : : ; rg? 1. g r \tiny" jobs of type T, all of the with a processing tie of 1=rg. There are jobs with release ties of k (14r + D + 1) + lr? 1 + p=rg for l = 1; : : : ; g, and p = 0; : : : ; rg? 1. The total nuber of jobs is 3k + kgr + g r g r 900 D 3 n 1? k 4 n; fro which we derive n 4, since k. Additional jobs with release tie and processing tie 0 are added to reach the value n. 17
k/(14r+d+1) + gr r k/(14r+d+1) 14r+D 1 Figure 4: A view of the instance for the lower bound In words, we release a group of rg tiny jobs of type T 1 every 14r + D + 1 units of tie, between tie 0 and k (14r + D + 1). Each of such groups is fored by jobs with processing tie 1=rg released every 1=rg units of tie. One can schedule all the tiny jobs of these k groups at their release ties, with a total ow tie of k. If this is the case, they leave \holes" of size 14r + D (see Figure 4 for a pictorial view of this schedule). Into these holes one can t three jobs of the for r + a i, 4r + b (i), and 8r + c (i), if a i + b (i) + c (i) D. Therefore, if the given instance has a solution, one can schedule all the tiny jobs at their release ties, and nish all the big jobs by tie k (14r + D + 1)? 1. The total ow tie in this case, denoted by F sol, is bounded by the following: F sol k (14r + D + 1)3k + k + g 150rk : On the other hand, if we assue that the given instance of N3DM has no solution, then at least one out of the 3k big jobs cannot t into the holes dened by the release ties of the jobs of type T 1. Furtherore, if the tiny jobs of type T are also scheduled at their release ties, they leave holes of size r? 1, where no big job can t. Such a big job is then either delayed until tie k (14r + D + 1) + gr, or scheduled to overlap the release ties of a set of tiny jobs of type T 1 or T that arks the end of a hole. Observe that, since the processing tie of big jobs is an integer value, they overlap the release tie of rg tiny jobs arking the end of a hole. Therefore, either one big job is delayed until tie 18
k (14r + D + 1) + gr and hence has a ow tie bigger that gr, or it is scheduled to overlap the release ties of a set of rg tiny jobs of type T 1 or T, with these release ties concentrated P in one unit of tie. This second case results in a total ow tie lower bounded by 1 rg rg j=1 j gr since one ore job is waiting to be scheduled each 1 rg these tiny jobs are released. units of tie during the entire interval when Now, we can prove the following theore: Theore 14 For all 0 < 1, and 0 < < 1, and xed, there does not exist a polynoial 3 tie approxiation algorith for P jr P j j F j, with n 4, having worst-case approxiation ratio n 1 3?, unless P = NP. Proof: Assue such an approxiation algorith A exists for soe xed 0 < 1, and 0 < < 1. 3 Take an instance of N3DM, encoded in unary, transfor it into an instance with k ultiple integer of, and construct an instance of P jr j j P F j for achines, as described in this section. The constructed instance of P jr j j P F j is polynoial in the size of the instance of N3DM encoded in unary for. Now, apply algorith A to the result schedule. If the given instance of N3DM has a solution, then we have the following bound on F A, which is the approxiated ow tie of algorith A. F A n 1 3? F sol < r 3 150rk 50r k : On the other hand, if the given instance of N3DM has no solution then the previous discussion iplies that F A F no rg = 50r k holds. Therefore, with the help of algorith A one can decide whether a given instance of N3DM has a solution or not, which is a contradiction. 4 Discussion In this paper we provided the rst results on approxiation algoriths for total ow tie in a ultiprocessor setting. The ain proble left open by this paper is the existence of better approxiation algoriths for the preeptive case. >Fro our results it is clear that such an algorith cannot be an online algorith, but at the present we do not know of any algorith that has a guaranteed approxiation ratio better than SRPT. A recent paper [PSTW97] points out that on-line algoriths can approach the optial solution when allowed to use ore achines or ore powerful achines than the corresponding o-line adversary. A better approxiation algorith for the preeptive case also iplies (using Theore 1) a better approxiation algorith for the non-preeptive case. This iproveent, however, ight be liited to an O(log n ) factor as we conjecture the existence of an (n 1? ) unapproxiability lower bound for any value of. In real life, preeption, like any other things, is not free. There is often a cost for each preeption, (paging, initializing variables, etc.), and thus the following objective function F P M = P Fj + c(# of preeptions), where c is a cost function to be specied, is of interest. Note that in our lower bound for online algoriths, the optial solution does not use preeption, therefore it is a lower bound for this proble too. Furtherore, SRPT uses at ost n preeptions, thus if 19