Two Processor Scheduling with Real Release Times and Deadlines

Transcription

1 Two Processor Scheduling with Real Release Times and Deadlines Hui Wu School of Computing National University of Singapore 3 Science Drive 2, Singapore wuh@comp.nus.edu.sg Joxan Jaffar School of Computing National University of Singapore 3 Science Drive 2, Singapore joxan@comp.nus.edu.sg ABSTRACT In a hard real-time system, critical tasks are subject to timing constraints such as release times and deadlines. All timing constraints must be satisfied when tasks are executed. Nevertheless, given a set of tasks, finding a feasible schedule which satisfies all timing constraints is NP-complete even on one processor. In this paper, we study the following special non-preemptive two processor scheduling problem: Given a set of UET (Unit Execution Time) tasks with arbitrary precedence constraints, individual real release times and deadlines, find a feasible schedule on two identical processors whenever one exists. The complexity status of this problem has been open for a long time. we propose the first polynomial algorithm for this problem. Our algorithm is underpinned by the key consistency notion: successor-tree-consistency. The time complexity of our algorithm is O(n 4 ), where n is the number of tasks. Categories and Subject Descriptors F.2.2 [Theory of Computation]: Non-numerical Algorithm and Problem; J.7 [Computer Applications]: Computers in Other Systems General Terms Algorithms Keywords task scheduling, release time and deadline, feasible schedule, successor-tree-consistency. 1. INTRODUCTION Deterministic task scheduling with timing constraints has been extensively studied [1, 2, 3, 6, 7, 8, 9]. Even on one processor, it is NP-complete to determine if there is a feasible Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SPAA 02, August 10-13, 2002, Winnipeg, Manitoba, Canada. Copyright 2002 ACM /02/ $5.00. schedule for a set of independent tasks with different execution times, individual integer release times and deadlines [7]. A few special cases have been shown to be polynomially solvable [5]. One of them is scheduling UET tasks on two processors. Garey and Johnson [3] proposed a polynomial algorithm for scheduling UET tasks with individual integer release times and deadlines. Their algorithm computes the modified deadlines for all tasks and uses modified deadlines as priorities to compute a schedule. Computing modified deadlines, which is the dominating factor in the time complexity, requires O(n 3 ) time, where n is the number of tasks. Their algorithm can find a feasible schedule whenever one exists. In addition, their algorithm can be used to find a schedule with minimum lateness on two identical processors. The resulting time complexity is O(n 3 log n). In the case where there is no precedence constraint and all release times and deadlines are real numbers, the problem of finding a feasible schedule for a set of non-pre-emptive tasks on multiple identical processors is polynomially solvable. Simon proposed an algorithm for this problem with the time complexity of O(n 3 log log n) [6]. Simon and Warmuth [7] improved Simon s algorithm to O(n 2 m), where m is the number of processors. However, the problem of determining if there is a feasible schedule for a set of non-pre-emptive UET tasks with arbitrary precedence constraints, individual real release times and deadlines on two identical processors is still open 1. This open problem was first proposed by Garey and Johnson [3]. In this paper, we propose the first polynomial algorithm for this problem. Our algorithm computes a feasible schedule whenever one exists. The time complexity of our algorithm is O(n 4 ). The key idea of our algorithm is computing the successor-tree-consistent deadlines for all tasks. The successor-tree-consistent deadline of a task T i is the upper bound on the latest completion time of T i in any feasible schedule for the relaxed problem instance where only the precedence between T i and each of its successor is considered. By using successor-tree-consistent deadlines as priorities, forward scheduling will compute a feasible schedule whenever one exists. 2. PROBLEM FORMULATION AND DEFI- NITION In the rest of this paper, we assume that all tasks are non- 1 This problem is equivalent to the problem with arbitrary precedence constraints, equal execution times, real release times and deadlines. 127

2 pre-emptive, i,e, once a task starts to run on a processor, it will keeprunning on the same processor until it terminates. Scheduling UET tasks with precedence constraints, individual real release times and deadlines on two identical processors is described as follows. Given a problem instance P :asetv ={T 1,T 2,,T n } of UET tasks with precedence constraints represented by a DAG (Directed Acyclic Graph) G=(V,E), where E={(T i,t j ):T i,t j V and T i immediately precedes T j },asetrt ={r i : r i is the pre-assigned release time of T i and a real number } of individual real release times, a set D={d i : d i is the pre-assigned deadline of T i and d i is a real number } of individual real deadlines, and two identical processors, compute a feasible schedule σ satisfying all constraints whenever one exists. Formally, a feasible schedule σ on two identical processors is a total function σ : V [0, ) which satisfies the following constraints: 1. Precedence constraint: (T i,t j ) E(σ(T i )+1 σ(t j )). 2. Release time and deadline constraint: T i V (r i σ(t i ) d i 1). 3. Resource constraint: t [0, )( {T i V : σ(t i ) t<σ(t i )+1} 2). In a DAG G=(V,E), if there is a path from T i to T j,then T j is the successor of T i and T i is the predecessor of T j ; especially, if (T i,t j ) E, thent j istheimmediatesuccessor of T i and T i istheimmediatepredecessoroft j.thesetof all successors of a task T i is denoted by Succ(T i ). If there is apathp ij from T i to T j, the path length of P ij, denoted by L(P ij ), is the number of edges in P ij.ift i is the predecessor of T j, the distance between T i and T j, denoted by l ij,is max{l(p ij ):P ij is a path from T i to T j }. Definition 1. Given a problem instance P,the edge-consistent release time of a task T i is defined as max{r i,max{r k + l ki : T k is the predecessor of T i }}. Theedge-consistent deadline of a task T i is defined as min{d i,min{d k l ik : T k is the successor of T i }}. The edge-consistent release times and the edge-consistent deadlines of all tasks can be computed in O(e) timebyusing breadth-first search, where e is the number of edges in the precedence graph. Definition 2. Given a DAG G=(V,E) andataskt i,the successor tree of T i is a directed tree ST(T i ) = (V i,e i ), where V i = {T i } {T j : T j Succ(T i )}, ande i = {(T i,t j ): T j Succ(T i )}. The key idea of our algorithm is to compute the successortree-consistent deadline for each task. Given a problem instance P, the successor-tree-consistent deadline of each task T i, denoted by d i, is the upper bound on the latest completion time of T i in any feasible schedule for the relaxed problem instance P (i) which is recursively defined as follows. P (i) consists of the same set of tasks as in P with the following constraints. 1. Precedence constraints. The precedence constraints are represented by the successor tree ST(T i )oft i. 2. Release time constraints. The release time of each task is its edge-consistent release time. 3. Deadline constraints. For each task T j, if it is not the successor of T i and its edge-consistent release time is not greater than that of T i, its deadline is its edgeconsistent deadline; otherwise, its deadline is its successor-tree-consistent deadline. 4. Resource constraints. Only two identical processors areavailableatanytime. Formally, d i = min{d i, max{σ(t i )+1 : σ is a feasible schedule for the relaxed problem instance P (i)}}. 3. FORWARD SCHEDULING AND BACK- WARD SCHEDULING In order to compute the successor-tree-consistent deadlines, our algorithm uses both forward scheduling and backward scheduling. Inthissection,wedescribetheforward scheduling and the backward scheduling for a set of independent tasks. The modified forward scheduling for a set of tasks with precedence constraints will be described in the next section. Given a problem instance P :asets = {T 1,T 2,,T p } of p independent UET tasks with individual real release times and deadlines, the objective of the forward scheduling is to find a feasible schedule with the minimum completion time on two identical processors whenever one exists. A schedule computed by forward scheduling is called a forward schedule. The forward scheduling algorithm was first proposed by Simon [6]. Simon s forward scheduling algorithm works as follows. 1. EDF (Earliest Deadline First) strategy is used when no task misses its deadline. By Earliest Deadline First strategy, whenever a processor is available, among all unscheduled ready tasks, the task with the earliest deadline is chosen and scheduled as early as possible in the partial forward schedule σ f. 2. If a task T i misses its deadline in the partial forward schedule σ f, two cases are distinguished. If no task in the partial forward schedule has a larger deadline than T i s, then no feasible schedule exists. Otherwise, backtracking is performed as follows. Let T j1,t j2,,t jm be all tasks in the partial schedule satisfying 1) the deadline of each T jk deadline is larger than T i s, and 2) for any two tasks T js and T jt (t>s), either σ f (T jt ) > σ f (T jt ) holds or σ f (T jt )=σ f (T jt )andd jt d js hold. For s = m, m 1,, 1, do the following. (a) Remove T js and each T k with σ f (T k ) >σ(t js ) from σ f. (b) Reschedule all tasks in {T k : T k was just removed from σ f } {T jm,,t js } {T i } by using EDF. (c) If T i does not miss its deadline in the new partial forward schedule, then stopbacktracking. When the backtracking is finished. Two cases are possible. If T i does not miss its deadline in the new partial forward schedule, then go to step1 and continue to schedule the remaining tasks. Otherwise, there is no feasible schedule and the forward scheduling algorithm terminates. 128

3 Processor 1 Processor 2 T T T T T 3 T 4 T Figure 1: A forward schedule σ f for example 1. Processor 1 Processor 2 T T T T T 1 T 4 T Figure 2: A backward schedule σ b for example 1. A faster forward scheduling algorithm was proposed by Simon and Warmuth [7]. In the case of two identical processors, the time complexity of their algorithm is O(n 2 ), where n is the number of tasks. Given a problem instance P defined before, the objective of the backward scheduling is to find a feasible schedule on two identical processors such that the minimum start time is maximized whenever one exists. A schedule computed by backward scheduling is called a backward schedule. A backward schedule σ b for the problem instance P can be computed by using forward scheduling algorithm as follows. 1. Let r i and d i (i =1, 2,,p) be the release time and thedeadlineoft i respectively in the problem instance P and d max =max{d i }. Construct a new problem instance P b:asetr = {v 1,v 2,,v p } of p independent UET tasks with a set RT = {d max d i : d max d i is the release time of v i } of individual real release times and a set D = {d max r i : d max r i is the deadline of v i }, and two identical processors. 2. Compute a forward schedule σ f for P b. 3. For each task T i (i = 1, 2,,p), σ b (T i ) = d max σ f (v i ) 1. Example 1 Given a problem instance P : a set V = {T 1,T 2,,T 7 } of 7 independent UET tasks with the following real release times and deadlines: r 1 = r 2 =0,r 3 =0.3, r 4 =1.8, r 5 =2.3, r 6 =2.5, r 7 =3.1, d 1 =2.5, d 2 =3.1, d 3 =1.8, d 4 =3.7, d 5 =4,d 6 =3.8, d 7 =4.5, and two identical processors, a forward schedule σ f for P is shown in Figure 1. A backward schedule σ b for P is shown in Figure SCHEDULING ALGORITHM The input of our algorithm is a problem instance P :aset V ={T 1,T 2,,T n } of UET tasks, a set of precedence constraints in the form of a DAG G=(V,E), a set RT ={r 1,r 2,, r n } of individual real release times, a set D={d 1,d 2,, d n } of individual real deadlines, and two identical processors. The output of our algorithm is a feasible schedule σ for P whenever one exists, or No feasible schedule exists. if no feasible schedule exists. Our algorithm consists of three main steps. The first step performs preprocessing. The preprocessing includes computing the edge-consistent release times and the edgeconsistent deadlines for all tasks and sorting an array L which is used to choose a task to compute its successor-treeconsistent deadline. The second stepcomputes the successortree-consistent deadlines for all non-sink tasks. According to the definition of the successor-tree-consistent deadline, the following two rules are used to choose a task T i to compute its successor-tree-consistent deadline: 1) The successor-treeconsistent deadlines of all successors of T i have been computed, and 2) among all tasks whose successors successortree-consistent deadlines have been computed, T i has the largest edge-consistent release time. Ties are broken in arbitrary order. To follow these two rules, we sort all tasks in L in non-ascending order of their edge-consistent release times in the first step. The last step constructs a schedule for P by using the modified forward scheduling algorithm. The modified forward scheduling algorithm works essentially the same way as Simon s forward scheduling algorithm where no precedence constraints exist. The modified forward scheduling algorithm computes a forward schedule for the problem instance P wherethereleasetimeofeach task is its edge-consistent release time and its deadline is its successor-tree-consistent deadline. The only difference between the modified forward scheduling and the forward scheduling is that the modified forward scheduling algorithm considers the precedence constraints when computing a forward schedule. Specifically, in the modified forward scheduling algorithm, a task is ready only if all its predecessors have been scheduled and its release time has passed. The framework of our algorithm is shown in pseudo code as follows. procedure T wo P rocessor Scheduling(P ) Input: A problem instance P defined in Section 2. Output: A feasible schedule σ whenever one exists. variable L: array of all tasks in V ; /* Preprocessing */ for each task in V do begin compute its edge-consistent release time and deadline; change its release time to its edge-consistent release time; change its deadline to its edge-consistent deadline; end sort L in non-ascending order of their edge-consistent release times; /* Compute the successor-tree-consistent deadline of each non-sink task */ for i =0, 1,,n 1 do if L[i] is not an sink task begin compute the successor-tree-consistent deadline for L[i]; 129

4 set the deadline of L[i] to its successor-tree-consistent deadline; end /* Compute a feasible schedule */ compute a forward schedule σ by using the modified forward scheduling algorithm; if all tasks meet their successor-tree-consistent deadlines in σ then return(σ); /* σ is a feasible schedule; */ else return( No feasible schedule exists. ); Computing the successor-tree-consistent deadline for a nonsink task L[i] is the core of our scheduling algorithm. For a sink task, its successor-tree-consistent deadline is its edgeconsistent deadline. Next we describe how to compute the successor-tree-consistent deadline for a non-sink task T i.recall that the successor-tree-consistent deadline d i of task T i is the upper bound on its latest completion time in any feasible schedule for the relaxed problem instance P (i) defined in Section 2. Note that all successors of T i must be scheduled after T i,and there may exist a minimum set U min (i) ofthetasks which are not the successors of T i and must be scheduled after T i in any feasible schedule for P (i) due to their tight release times and deadlines. Therefore, to compute the successor-tree-consistent deadline of T i, we have to determine the minimum task set U min (i) ={T j : T j Succ(T i )andt j must be scheduled after T i in any feasible schedule for P }. In the rest of this paper, unless their meanings are explicitly stated, r i will denote the edge-consistent release time of T i and d i will denote the current deadline of T i, i.e. its successor-tree-consistent deadline if it has been computed, or its edge-consistent deadline otherwise. The algorithm for computing the successor-tree-consistent deadline for T i is shown as follows. 1. Preprocessing. (a) Let U 0 = V {T i } Succ(T i ). Compute a forward schedule σ f 0 for U 0 and a backward schedule σ0 b for Succ(T i ), where the release time of each task is its edge-consistent release time and the deadline of each task is its current deadline. (b) t min = min{σ0(t b k ) : T k Succ(T i )} and t = min{d i,t min }. (c) Let L 1 be an array containing all tasks in U 0. Sort L 1 such that for any two tasks L 1 [j] and L 1 [j+1], either 1) σ f 0 (L 1[j]) <σ f 0 (L 1[j+1]), or 2) σ f 0 (L 1[j]) = σ f 0 (L 1[j+1]) and the current deadline of L 1 [j] is not larger than that of L 1 [j +1]. (d) Let m and p be two non-negative integers satisfying the following constraints: 1) σ f 0 (L 1[m]) t 1, 2) for each task L 1 [j](j = m+1,, L 1 1) σ f 0 (L 1[j]) >t 1, 3) σ f 0 (L 1[p]) r i,and4)for each task L 1 [j](j =0, 1,,p 1)σ f 0 (L 1[j]) <r i. 2. Performing sequential search to compute the successortree-consistent deadline for T i.foreachtaskl 1 [j](j = m, m 1,,p) do the following. (a) Compute a backward schedule σj b for Succ(T i ) {L 1 [k] :k = j,j +1,, L 1 1}. Let t min = min{σj(t b k ):T k Succ(T i ) {L 1 [k] :k = j,j + 1,, L 1 1}}. (b) If σ f 0 (L 1[j 1]) + 1 >t min and j = p, thenno feasible schedule exists for the relaxed problem instance P (i) and our algorithm terminates. (c) If σ f 0 (L 1[j 1]) + 1 t min, do the following. i. Let T s and T t be two tasks in Succ(T i ) {L 1 [k] :k = j,j +1,, L 1 1} satisfying that for each task T k Succ(T i ) {L 1 [k] : k = j,j +1,, L 1 1} {T s,t t } σj(t b k ) σj(t b s )andσj(t b k ) σj(t b t ). ii. If σj(t b s )=σj(t b t ), let t 1 = σj(t b t )(t 1 might be the successor-tree-consistent deadline of T i ); otherwise, check if T i can be scheduled at time t 2 =max{σj(t b s ),σj(t b t )} 1asfollows. Compute a backward schedule σ b on two identical processors for the following problem instance P 0 (i): a set Succ(T i ) {L 1 [k] : k = j,j +1,, L 1 1} of UET tasks with the following constraints: 1) The deadline of each task is its current deadline, 2) for each task T k Succ(T i ), its release time is max{r k,t 2 +1}, and 3) for each task T k {L 1 [k] :k = j,j +1,, L 1 1}, itsrelease time is its edge-consistent release time. If σ b is a feasible schedule, let t 1 = t 2 +1; otherwise, let t 1 =min{σj(t b s ),σj(t b t )}. iii. Let t 0 =min{σ f 0 (L 1[j 1]),σ f 0 (L 1[j 2])} + 1. If t 1 t 0 1, then the successor-treeconsistent deadline of task T i is t 1 and the procedure for computing the successor-treeconsistent deadline of T i terminates. If the successor-tree-consistent deadline of T i is not available upon the completion of the above loop, then no feasible schedule exists for the relaxed problem instance P (i). Note that P (i) is the relaxed problem instance of P.Therefore, if there is no feasible schedule for P (i), then there is no feasible schedule for P. 5. PROOF AND ANALYSIS From our scheduling algorithm for computing the successortree-consistent deadlines, we can prove the following lemma. Lemma 5.1. Given a problem instance P, a schedule σ for P has no late task with respect to successor-tree-consistent deadlines iff it has no late task with respect to pre-assigned deadlines. Before proving our main theorem, we introduce two types of idle intervals used in the proof. Given a schedule σ for aprobleminstancep and a processor M, a time interval π =[t 1,t 2 ) is called an idle interval w.r.t. M and σ if M is idle during the time interval π in the schedule σ. Anidle interval π is called an artificial idle interval if at least one task is ready at a time point in π. Otherwise, it is called a true idle interval. Artificial idle intervals are caused by the forward scheduling where all ready tasks are delayed due to an urgent task. 130

5 Theorem 1. Given a problem instance P,ouralgorithm computes a feasible schedule iff one exists. Proof Assume that there is a feasible schedule for P and a schedule σ computed by our algorithm has at least one late task. Let T k be the first late task and t be the earliest time which satisfies the following two constraints. No processor has a true idle interval in the time interval [t, σ(t k )). The successor-tree-consistent deadlines of all tasks partially or fully scheduled in [t, σ(t k ))arelessthanor equal to d k. Without loss of generality, we assume that T k is scheduled on processor 1 in σ. Let S = {T k } {T j : t σ(t j ) σ(t k ) 1}. Consider all possible cases. 1. t = σ(t k ). There are two cases. (a) There is a true idle interval [t 1,σ(T k )) or the task T i scheduled in time interval [σ(t k ) 1,σ(T k )) on processor 1 has a larger successor-tree-consistent deadline than T k s. This case means that T k s release time is σ(t k ). Therefore, T k must miss its deadline in any schedule, which contradicts the assumption that there is a feasible schedule for P. (b) There is a task T i scheduled in time interval [σ(t k ) 1,σ(T k )) on processor 1 such that d i d k. By the definition of t, T k must be the successor of T i. By our algorithm for computing the successor-tree-consistent deadlines, T i must miss its successor-tree-consistent deadline, which contradicts the assumption that T k is the first late task. 2. t = 0. If we ignore all tasks in V S, wherev is the set of all tasks in P,thenσ is a forward schedule for the problem instance P 1 : A set S of independent UET tasks with the following constraints: 1) the release time of each task is its edge-consistent release time, 2) the deadline of each task is its successor-treeconsistent deadline, and 3) two identical processors. By the property of the forward scheduling, there must be a late task in any schedule for P 1. Therefore, there must be a late task in any schedule for P, which contradicts the assumption. 3. There is a true idle interval [t 1,t) or a task scheduled in [t 1,t) has a larger successor-tree-consistent deadline than T k s on processor 1. Consider the following cases. (a) There is a task T i in S scheduled on processor 2 with σ(t i ) <tand σ(t i )+1 >t. In this case, for each task T j S {T i },eithert j is a successor of T i or T j cannot be released before t. By our algorithm for computing the successortree-consistent deadlines, T i must also miss its successor-tree-consistent deadline, which contradicts the assumption that T k is the first late task. (b) There is an artificial idle interval [t 0,t)onprocessor 2. The following two cases are possible. i. Either there is a true idle interval [t 2,t 0 )or there is a task T i scheduled in [t 0 1,t 0 ) on processor 2 such that the successor-treeconsistent deadline of T i is greater than that of T k. Similar to case 2, one of the tasks in S must miss its deadline in any schedule, which contradicts the assumption. ii. There is a task T i scheduled in [t 0 1,t 0 ) on processor 2 such that the successor-treeconsistent deadline of T i is not greater than that of T k. In this case, for each task T j S, either T j is the successor of T i or T j cannot be released before t. Similar to case 3(a), T i must also miss its successor-tree-consistent deadline, which contradicts the assumption. (c) There is a true idle interval [t 3,t) on processor 2. In this case, no task in S can be released before t. Similar to case 2, one of the tasks in S must miss its deadline in any schedule for P, which contradicts the assumption. (d) A task T i is scheduled in [t 1,t) on processor 2. Two cases are possible. i. The successor-tree-consistent deadline of T i is not greater than that of T k.inthiscase,for each task T j in S, eithert j is the successor of T i or r j t holds. Similar to case 3(a), T i must also miss its deadline in σ, which contradicts the assumption that T k is the first late task. ii. The successor-tree-consistent deadline of T i is greater than that of T k. Thisimpliesthat no task in S can be released before t. Similar to case 2, one of the task in S must miss its deadline in any schedule for P. 4. There is an artificial idle interval [t 1,t) on processor 1. The following cases are possible. (a) There is a true idle interval [t 4,t 1 )orthetask scheduled in [t 1 1,t 1 ) on processor 1 has a larger successor-tree-consistent deadline than T k s. Similar to case 2, one of the tasks in S must miss its successor-tree-consistent deadline, which contradict that assumption that there is a feasible schedule for P. (b) There is a task scheduled in [t 1 1,t 1 ) such that the successor-tree-consistent deadline of T i is not greater than that of T k. Similar to case 3(a), T i must miss its successor-tree-consistent deadline, which contradicts that assumption that T k is the first late task. 5. There is a task T i scheduled in [t 1,t) on processor 1 such that the successor-tree-consistent deadline of T i is not greater than that of T k. Similar to case 3(a), T i must miss its successor-tree-consistent deadline, which contradicts that assumption that T k is the first late task. Therefore, σ has no late task and the theorem holds. In our algorithm, the dominating factor of the time complexity is computing successor-tree-consistent deadlines for 131

6 all tasks. When our algorithm computes the successor-treeconsistent deadline for each non-sink task, Simon and Warmuth s forward scheduling algorithm is called at most O(n) times. Since Simon and Warmuth s forward scheduling algorithm runs in O(n 2 )timeontwoidenticalprocessors,computing the successor-tree-consistent deadline for each nonsink task takes O(n 3 ) time. Therefore, the time complexity of our algorithm is O(n 4 ). 6. CONCLUSION In this paper, we have proposed the first polynomial algorithm for scheduling UET tasks with arbitrary precedence constraints, individual real release times and deadlines on two identical processors. This problem is solved by computing the successor-tree-consistent deadlines for all tasks. The successor-tree-consistent deadlines are tighter deadlines which are consistent with respect to the successor tree of each task. The time complexity of our algorithm is O(n 4 ). Our algorithm can be made faster by using binary search similar to that in [9]. The details will be described in the full paper. The successor-tree-consistency is a powerful technique for handling precedence constraints. Many polynomially solvable scheduling problems with precedence constraints can be solved by using successor-tree-consistency [2, 3]. We conjecture that it could be used to get a good approximation algorithm for the general scheduling problem where the execution times are different. In the category of minimum makespan scheduling problems, the complexity status of scheduling UET tasks with arbitrary precedence constraints on n (n 3andn is fixed) processors so that the maximum completion time is minimized is still unknown. The latest advance on this problem was made by Garey, Johnson, Tarjan and Yannakakis [4]. They proved that in the case where the precedence constraints are in the form of opposing forests, if the number of processors is fixed, then the problem is polynomially solvable; otherwise, it is NP-complete. We have examples which show that successor-consistency cannot solve three processor scheduling problem. However, it is not known if there is any stronger consistency which can helpsolve three processor scheduling problem. [6] B. Simon. Multiprocessor scheduling of unit-time jobs with arbitrary release times and deadlines. SIAM J. Comput., 12(2): , [7] B. Simon and M. Warmuth. A fast algorithm for multiprocessor scheduling of unit length jobs. SIAM J. Comput., 18(4): , [8] H. Wu, J. Jaffar, and R. Yap. A fast algorithm for scheduling instructions with deadline constraints on risc machines. In The Proceedings of 2000 International Conference on Parallel Architecture and Compilation Technique, pages Philadelphia, USA, Oct [9] H. Wu, J. Jaffar, and R. Yap. Instruction scheduling with timing constraints on a single risc processor with 0/1 latencies. In The proceedings of the Sixth International Conference on The Principles and Practice of Constraint Programming, pages Lecture Notes in Computer Science, Volume Springer Verlag, Sept REFERENCES [1] M.Garey,B.S.D.S.Johnson,andR.Tarjan. Scheduling unit-time jobs with arbitrary release times and deadlines. SIAM J. Comput., 10(2): , [2] M. Garey and D. Johnson. Scheduling tasks with nonuniform deadlines on two processors. J. ACM, 23(3): , [3] M. Garey and D. Johnson. Two processor scheduling with start-times and deadlines. SIAM J. Comput., 6(3): , [4] M.Garey,D.Johnson,R.Tarjan,andM.Yannakakis. Scheduling opposing forests. SIAM J. Alg. Disc. Meth., 4(1):72 93, March [5] E.L.Lawler,J.Lenstra,A.R.Kan,andD.Schmoy. Sequencing and scheduling: Algorithms and complexity. Handbooks in Operations research and management science, volume 4:Logistic of production and inventory, edited by S.C. Graves, A.H.G. Rinnooy Kan and P. Zipkin, North-Holland, pages ,