PARTIALLY CLAIRVOYANT SCHEDULING FOR AGGREGATE CONSTRAINTS

The problem of partially clairvoyant scheduling is concerned with checking whether an ordered set of jobs, having nonconstant execution times and subject to a collection of imposed constraints, has a partially clairvoyant schedule. Variability of execution times of jobs and nontrivial relationships constraining their executions, are typical features of real-time systems. A partially clairvoyant scheduler parameterizes the schedule, in that the start time of a job in a sequence can depend upon the execution times of jobs that precede it, in the sequence. In real-time scheduling, parameterization of the schedule plays an important role in extending the flexibility of the scheduler, particularly in the presence of variable execution times. It has been shown that the existence of partially clairvoyant schedules can be determined in polynomial time, when the constraints are restricted to be “standard,” that is, relative timing constraints. In this paper, we extend the class of constraints for which partially clairvoyant schedules can be determined efficiently, to include aggregate constraints. Aggregate constraints form a strict superset of standard constraints and can be used to model performance metrics.


Introduction
Variability in the execution times of jobs is a common characteristic in real-time systems.There are a number of reasons for this feature, including input-dependent loops and measuring error [2,3,29,30].For instance, the running time of a sorting subroutine in a program, depends on the size of the input set, and in general, will be greater for an input set of size 1000, than for an input set of size 10.In the literature, there exist two broad approaches for addressing execution time variability, viz., stochastic and deterministic.In stochastic scheduling, the goal is to provide probabilistic guarantees that the constraints imposed on the job-set will be met for the most likely values of execution times.Such a guarantee requires that the execution times belong to a fixed, well-understood distribution [11,23,26] and is tempered with the knowledge that there is a finite, nonzero probability that the constraints may be violated at run time.This approach is not applicable in the case of "hard" real-time systems [19,24,29], where the guarantees have to be absolute and there is no room for error.Hard real-time systems are typically composed of mission-critical jobs, wherein the consequences of failure, that is, a violation of the imposed constraints, can be catastrophic.Such real-time systems therefore call for deterministic approaches to the issue of uncertainty.Some of the common approaches include worst-case (largest value) assumptions [4,23], Zero clairvoyant scheduling [31] and partially clairvoyant scheduling [6,13,32].Assume that a job J 1 has execution time e 1 in the range [3,10] and it is required that the job finish at or after time t = 10, that is, c 1 : s 1 + e 1 ≥ 10.If we take the largest value of e 1 to satisfy this constraint, then we get s 1 = 0 as a possible solution.However, during the actual execution of J 1 , e 1 could be 3, in which case the constraint c 1 is broken.Thus, we see that worst-case assumptions regarding execution times, run the risk of constraint violation at run time and hence such a strategy is not always correct.
In Zero clairvoyant scheduling [31], we make extremely conservative assumptions about each constraint, in order to determine the existence of a feasible schedule.This approach is correct, inasmuch as the goal is to provide a set of start-times that cannot cause constraint violation.In the above example, a Zero clairvoyant scheduler would substitute e 1 = 3 in c 1 to get s 1 ≥ 7. Observe that this assignment ensures that c 1 is not broken at run time.However, Zero clairvoyant scheduling is extremely inflexible and even simple constraint sets may not have Zero clairvoyant schedules.For instance, consider a pair of jobs {J 1 ,J 2 } with start times {s 1 ,s 2 } and execution times {e 1 ∈ [3,5], e 2 ∈ [2,4]}, with the following two constraints imposed on their execution: Note that the conservative Zero clairvoyant approach forces the following system to be satisfied (1.1) System (1.1) is clearly infeasible and hence there does not exist a Zero clairvoyant schedule.
On the other hand, consider the schedule described by system (1.2).
It is a valid, albeit parametrized schedule; in particular, s 2 depends on the actual value assumed by e 1 during run time.
We see that partially clairvoyant scheduling increases the flexibility of a scheduler, in that a constraint system which cannot be scheduled by a Zero clairvoyant scheduler, may be scheduled by a partially clairvoyant scheduler.
In the real-time scheduling literature, it has been shown that polynomial time algorithms exist for determining the existence of partially clairvoyant schedules, when the constraints are restricted to be "standard" [7,13].In this paper, we are concerned with the following question: can the existence of partially clairvoyant schedules in a constraint system be determined efficiently for nonstandard constraints, with at most two jobs per constraint?
We provide an affirmative answer to the above question by designing a polynomial time algorithm for a class of constraints, termed as aggregate constraints.
The rest of this paper is organized as follows: Section 2 provides a formal description of the problem under consideration.Section 3 discusses the motivation underlying our research, while related approaches are detailed in Section 4. A quantifier elimination based algorithm for deciding the partially clairvoyant schedulability of a constraint system is presented in Section 5, along with the proof of its correctness and an analysis of its running time.We conclude in Section 6, by summarizing our results in this paper and outlining problems for future research.

Statement of problem
In this section, we provide a formal description of the problem under consideration.The specification of a real-time scheduling problem entails the specification of the type of jobs involved, the nature of the constraints that are imposed on them and the type of clairvoyance afforded to the scheduler [30].This paper is concerned with the partially clairvoyant schedulability of an ordered set of nonpreemptive jobs, subject to a set of aggregate constraints.

Job model.
Assume an infinite time-axis divided into windows of length L, starting at time t = 0.These windows are called periods or scheduling windows.There is a set of nonpreemptive, ordered jobs, = {J 1 ,J 2 ,...,J n }; these jobs execute in each scheduling window.The jobs have start times {s 1 ,s 2 ,...,s n } and execution times {e 1 ,e 2 ,...,e n }, with (s i ,e i ) denoting the start and execution times of job J i , respectively.e i is a range-bound variable, in that during actual execution, it may assume any value in the nonempty range [l i ,u i ].In real-time systems such as Maruti, a number of runs of the job set are carried out to statistically estimate the range [l i ,u i ] for job J i , with a high degree of confidence [14].

Constraint model.
The constraints on the jobs are described by system (2.1): where, (i) A is an m × 2 • n rational matrix, in which every row represents an aggregate constraint (to be defined below), (ii) E is the axis-parallel hyper-rectangle (aph) (2.2) (iii) s = [s 1 ,s 2 ,...,s n ] is the start time vector of the jobs, and (iv) e = [e 1 ,e 2 ,...,e n ] ∈ E is the execution time vector of the jobs.The characterization of E as an aph is intended to model the fact that the execution time e i of job J i is not a fixed constant, but can assume any value in the pre-specified range [l i ,u i ], depending on factors such as loop-length.
Observe that system (2.1) can be rewritten in the form (2.3) Definition 2.1.Standard Constraint-A constraint is defined to be standard, if represents a relative separation relationship between at most two jobs, that is, the matrices G and H are flow network, totally unimodular, with the added provision, that the entry For instance a constraint of the form: s i − s j ≤ −8, which specifies that job J j must start 8 units after job J i starts, is a standard constraint, whereas a constraint of the form s i + s j ≥ 9 is not a standard constraint.A detailed description of standard constraints is available in [13].Standard constraints can be represented by edges of a flow network [10]; these constraints are also called difference constraints and relative timing constraints.Definition 2.2.Aggregate Constraint-A constraint is said to be an aggregate constraint, if it is a standard constraint or it can be expressed in one of the following forms: (1) (s i + e i ) + (s j + e j ){≤,≥}k.
For instance, the requirement that the sum of the finish times of J 1 and J 2 should not exceed 14, can be modeled by the aggregate constraint (s 1 + e 1 ) + (s 2 + e 2 ) ≤ 14.Aggregate constraints also have a graph structure; the "edge" representing the set of constraints between two jobs J i and J j , forms a polyhedron in the four variables s i , e i , s j , e j with e i and e j being universally quantified [1,15].It is clear that aggregate constraints are a strict superset of standard constraints.

Query model.
Given the sequence in which the jobs execute, that is, a partially clairvoyant scheduler decides on a value for s 1 , so that J 1 can be scheduled.When J 1 finishes execution, the scheduler knows the values of e 1 ; it then uses the value of e 1 to compute s 2 ; the values of e 1 and e 2 are then used to compute s 3 and this process continues till s n is decided.The constraints must be respected by the s i values that are chosen.The goal of the scheduler is to check in advance whether such an assignment is possible.
Accordingly, the schedulability query can be described as: We note that the "solution" to query (2.4) is not a numeric vector in general, but a vector of Skolemized functions, capturing the dependence of s i on {e 1 ,e 2 ,...,e i−1 }.
It is convenient to think of partially clairvoyant schedulability as an n round, 2-person game.In round i, the start time player guesses a value for s i , while the execution time player guesses a value for e i in the range [l i ,u i ].Let s and e be the n-vectors guessed by the 2 players, at the end of n rounds.If A • [ s e ] T ≤ b, then the game is a win for the start time player; otherwise it represents a win for the execution time player.The guesses are nondeterministic, in that if there is a strategy for the start time player to win, he will win; similarly if the execution time player has a winning strategy, he will win.Thus, deciding query (2.4), corresponds to checking whether the start time player has a winning strategy.In the succeeding sections, we will argue that if the constraints are restricted to be aggregate constraints and if a winning strategy exists for the start time player, then such a strategy has polynomial size and can be determined in polynomial time.
The combination of the Job model, Constraint model, and the Query model constitutes a scheduling problem specification within the E-T-C scheduling framework [30].

Motivation
In Section 1, we argued that partially clairvoyant schedules are more flexible than Zeroclairvoyant schedules, in that constraint sets which are not schedulable by a Zeroclairvoyant scheduler may be scheduled by a partially clairvoyant scheduler.The research upto this point has focussed on "standard" constraints only and established the existence of a polynomial time strategy that determines the existence of a partially clairvoyant schedule.An interesting line of research is obtaining schedules that satisfy certain optimization criteria.The complexity of Partially Clairvoyant Optimization for general constraints, is not known [17].However, we can approximate optimization functions involving at most two jobs through the use of aggregate constraints.Optimization criteria, formulated as performance metrics arise in various situations including Job-shop, Flowshop and Machine-Shop [4,23].Typical performance metrics are Makespan, Sum of Start times and Sum of Completion times.For instance, the need to minimize the sum of completion times of jobs J 1 and J 2 can be approximated through (s 1 + e 1 ) + (s 2 + e 2 ) ≤ k, for suitably chosen k [28,29].Likewise the Makespan performance metric can be modeled through s n ≤ k. (Recall that job J n finishes last in the sequence.)

Related work
Applications in which partially clairvoyant scheduling plays a role, arise in two, somewhat unrelated fields, viz., Operating Systems scheduling and AI planning.
From the Operating Systems perspective, the concept of partially clairvoyant scheduling was introduced in [24] (where it was called parametric scheduling).In [13], polynomial time algorithms were presented for the case, when the constraints imposed on the job-set are "standard."[32] argued that "standard" constraints could be represented by a flow, graph.[6,7] extend the "standard constraint" model to include the case, in which constraints can exist between adjacent scheduling windows.
In AI planning, dealing with uncertainty in problem parameters is a fundamental issue, as evidenced by [10,20,21,22,33,34].In a typical AI planner, timing constraints are used to ensure temporal consistency of plans.We will now briefly describe the various types of constraint networks and their relationship to each other, in terms of expressibility.
The temporal constraint network structure was introduced in [10].In this structure, the only constraints that are permitted are those of the form x i − x j ≤ [a,b], a < b, where a and b are fixed numbers and x i and x j are points in time, which are controlled by the agent.Note that this constraint can be expressed by the pair of relationships (conjunction): If there is precisely one constraint between every pair of time points, then the resultant constraint system is a conjunction of difference constraints, which can be solved in polynomial time, using a Bellman-Ford type propagation algorithm [8].Such a system is also called a Simple Temporal Constraint Network, since such a system can be represented as a directed graph with the interval [a,b] representing two opposite arcs or links [10].
As was pointed out in [34], simple temporal constraint networks are not adequate to model real-world situations, in which certain links may not be under the control of the agent.For instance, a given interval constraint may represent the time taken for a job to complete execution and it may vary in a range, depending upon external factors.Accordingly, the simple temporal constraint networks with uncertainty (STNU) framework was proposed in [22,34].In this framework, some of the links (constraints) are free, while the rest of the links are contingent.The duration of a free link is chosen by the agent, whereas the duration of a contingent link is chosen by the environment.A contingent link always relates two strictly ordered time points, with the latter point being determined by the environment.
Our notion of partially clairvoyant schedulability corresponds to their notion of Dynamic Controllability, in that the plans change on the fly, depending on the outcome of previous events; however there exist the following important differences.
(1) We explicitly accommodate aggregate or sum constraints.These constraints cannot be represented in Constraint Networks, since by definition, the nodes of the network represent points in time and the links represent constraints on their difference.Accordingly, our constraint framework is a strict superset of the constraint framework in [22].
(2) In [22,34], the condition that two contingent arcs cannot have the same finish time, is explicitly enforced.In our case, this condition is implicitly enforced as follows: We have nonzero execution times for each job and there is a total ordering on the job execution sequence.
(3) Consider a constraint of the following form: the finish time of J 2 is at most 5 units, from the finish time of J 1 .This constraint can be easily represented in our framework as: s 2 + e 2 ≤ s 1 + e 1 + 5.However, this constraint cannot be represented in the framework of [22], since the link from s 1 to s 2 depends on both e 1 and e 2 .While s 2 can legitimately depend upon the value of e 1 , it cannot depend upon the value of e 2 .Thus, there is no way to designate this link as a contingent link in their framework, since the value of this link can be determined completely, only after s 2 has been assigned.
(4) In the AI applications described in [20], constraints are of the form s 1 + e 1 − s 2 ∈ [−5,5], that is, the environment decides what value in [−5,5] is actually assumed by the link.It is not clear that this constraint can be put within our scheduling framework.
(5) It is also important to note that the algorithm in [22], to determine dynamic controllability bears no resemblance whatsoever, to our quantifier elimination approach.Indeed, they have used Triangular Reductions as the basis of their approach, to determine  dynamic controllability, whereas quantifier elimination over conjunctions of aggregate constraints forms the basis for our algorithm.
Figure 4.1 shows how uncertainty has been incorporated into various scheduling frameworks and the relationships among them.
In both [7] and [13], polynomial time bounds are derived by observing that the number of standard constraints between any two jobs is bounded, if only strict relative constraints are permitted (in fact, at most 8 nonredundant constraints can exist).In this paper, we develop two new concepts viz.Constraint Domination and Constraint Orientation, which in turn are used to develop polynomial time algorithms for testing partially clairvoyant schedulability in the presence of aggregate constraints.
Linear programs with at most 2 variables per constraint (LI(2)s) have received quite a bit of attention in the Operations Research community.[27] was the first to observe the correspondence between LI(2)s and graphs; [1] gave the first polynomial time algorithm for this problem.In [15], the Fourier-Motzkin elimination procedure was used to provide a strongly polynomial algorithm, which to date is the fastest known algorithm for this problem.Our constraints are similar to those found in LI(2)s; however the coefficient of a nonzero variable is either 1 or −1 in aggregate constraints.

Algorithms and complexity
Algorithm 5.1 presents our strategy for testing partially clairvoyant schedulability.The strategy is based on quantifier elimination over a conjunction of linear constraints.To start with, the innermost quantified variable (e n ) in specification (2.4) is eliminated, followed by the next variable and so on.The quantifier elimination process is solution preserving, that is, if the constraint system has a solution prior to the elimination then the constraint system that results after the elimination, also has a solution and vice versa.The elimination process reduces a 2 • n variable constraint system to a constraint system Function Part-clair- sched (E,A, b) (1) for (i = n down to 2) do (2) Elim-Univ-Variable(e i ) ( 3) if (Check-Inconsistency()) then (4) return (false) (5) end if (6) Prune-Constraints() (7) Elim-Exist-Variable(s i ) ( 8) if (Check-Inconsistency()) then (9) return (false) (10) end if (11) end for (12) Elim-Univ-Variable (e 1 ) ( 13) if (a ≤ s 1 ≤ b, a,b ≥ 0) (14) Valid partially clairvoyant schedule exists.( 15) return ( 16) else (17) A partially clairvoyant schedule does not exist.( 18) return (19)  in one variable, viz., s 1 .If it is possible to satisfy this trivial constraint system, then the original constraint system is satisfiable.As the quantifier string unwinds, that is, variables are eliminated, it is possible that inconsistencies and redundancies occur; the Check-Inconsistency() procedure handles inconsistencies, while the Prune-Constraints() procedure eliminates redundancies.The following types of inconsistencies and redundancies could occur: (1) A constraint s i ≤ a and another constraint s i ≥ b, where b ≥ a + 1-In this case the system is declared infeasible.(2) A constraint of the form e i ≤ g-If g ≥ u i , we declare the constraint redundant; otherwise the constraint system is declared infeasible.(3) A constraint of the form e i ≥ r-If r ≤ l i , we declare the constraint redundant; otherwise the constraint system is declared infeasible.Algorithm 5.2 describes the procedure for eliminating the universally quantified execution variable e i ∈ [l i ,u i ].The Fourier-Motzkin elimination technique discussed in [5] represents one implementation of Elim-Exist-Variable().In general, any polyhedral projection method suffices.In our work, we assume that the Fourier-Motzkin procedure is used to eliminate the existentially quantified (start-time) variables.A brief description of the Fourier-Motzkin procedure is available in the appendix.

Function Elim-Univ-Variable (A, b)
(1) Substitute e i = l i in each constraint that can be written in the form e i ≥ () (2) Substitute e i = u i in each constraint that can be written in the form e i ≤ () Algorithm 5.2.Eliminating universally quantified variable e i ∈ [l i ,u i ].
5.1.Proof of correctness.Algorithm 5.1 is basically a quantifier unrolling algorithm; it eliminates one quantifier at a time, while preserving the solution space; we provide an inductive proof sketch of its correctness.Observe that Algorithm 5.1 works correctly, when there is only one job, that is, the base case is trivial.Assume that Algorithm 5.1 works correctly, when there are at most (n − 1) jobs in the constraint system.Now consider the case in which the algorithm is presented with a constraint system on n jobs.We focus on the elimination of the nth execution time variable e n ; it is the first variable to be eliminated.
Let A • [ s e ] T ≤ b be the system that results after calling Elim-Univ-Variable(e n ), where s = [s 1 ,s 2 ,...,s n ] T and e = [e 1 ,e 2 ,...,e n−1 ] T .We need to show that We focus on those constraints which contain e n ; the constraints which do not contain e n occur identically in both systems.Consider a constraint of the form g 1 : Note that a solution to system A • [ s e ] T ≤ b (with the quantifier specification) must satisfy the constraint u n ≤ f ().This solution clearly satisfies g 1 since during execution the maximum value that e n may take is u n .Likewise, any solution to the system A • [ s e] T ≤ b must ensure that the constraint u n ≤ f () is satisfied; if such is not the case, then e n can take the value u n at run time and break the constraint g 1 .In essence, we are taking the intersection of the polyhedron A • [ s e] T ≤ b with the polyhedron e n ≤ u n , e n ≥ l n .Preservation of the solution space using Fourier-Motzkin elimination has been argued in [9,25].We have thus shown that Algorithm 5.1 eliminates e n and s n while preserving the solution space; after the elimination of these two variables, we are left with a constraint system on (n − 1) jobs.It follows by the inductive hypothesis that Algorithm 5.1 is correct.

Analysis.
Observe that the procedure Elim-Univ-Variable() does not increase the number of constraints.However, Elim-Exist-Variable() has the potential to increase the number of constraints quadratically, each time it is called.Assuming that the Fourier-Motzkin elimination algorithm is used, the elimination of k start-time variables, could Definition 5.2.Constraint orientation (right).A constraint l ∈ S i j is said to have a right orientation if it specifies increased separation between J i and J j (in case of difference constraints), or pushes both jobs to the right (in case of aggregate constraints).Definition 5.3.Constraint orientation (left).A constraint l ∈ S i j is said to have a left orientation if it specifies decreased separation between J i and J j (in case of difference constraints), or it pushes both jobs to the left (in case of sum constraints).
For instance, the constraint s 1 + e 1 + 4 ≤ s 2 specifies that job J 2 should start at least 4 units after J 1 finishes.Since it specifies increased separation, it has a right orientation.Likewise, the constraint s 1 + s 3 ≤ 12 requires that J 1 and J 3 move leftward and hence, has a left orientation.Using the flow graph terminology in [32], a forward edge in the constraint graph has a right orientation and a backward edge has a left orientation.
Every constraint l ∈ S i j , ∀i, j = 1,...,n has an orientation, on account of the total ordering on the job-set.Thus an aggregate constraint between job J 1 and J 5 (say) has the effect of either drawing them together or pushing them apart.This is not true, if there is no ordering on the job-set.The total ordering on the start time variables implies that all these variables have an interpretation on the same real axis [0, L].In the absence of the total order, each variable has to be interpreted on its own axis (see [15]).Definition 5.4.Comparable constraints: Let c 1 and c 2 denote two constraints of the constraint system A • [ s e] T ≤ b that express relationships between J i and J j .These constraints are said to be comparable if and only if they have the same orientation and type and additionally the coefficients of s i , s j , e i , and e j are identical in both constraints, For instance, s 1 + e 1 + 4 ≤ s 2 and s 1 + 8 ≤ s 2 are not comparable, since the coefficient of e 1 is 1 in the first constraint and 0 in the second constraint.
Note that only constraints between the same set of jobs are comparable, that is, a constraint l ∈ S 13 and a constraint l ∈ S 12 are not comparable, regardless of their orientation and type.
Constraint comparability is an equivalence relation partitioning the set of constraints between two jobs, S i j , into the sixteen categories as follows, characterized by the following features: (1) left oriented or right oriented (L or R), (2) sum or difference (S or D), (3) e i present or absent, (i 1 or i 0 ), (4) e j present or absent, ( j 1 or j 0 ).We use S LSi1 j0 i j to denote constraints defined between J i and J j that are left-oriented, sum, with e i present and e j absent; the other 15 equivalence classes are described similarly.Definition 5.5.Constraint domination.A constraint c 1 is said to dominate another constraint c 2 , if and only if they are comparable and c 1 ⇒ c 2 , that is, c 2 is satisfied, whenever c 1 is satisfied.
In some sense, the domination relationship attempts to identify constraints that are redundant.For instance, s 1 − s 2 ≤ −4 is clearly dominated by s 1 − s 2 ≤ −8, since if the latter constraint is satisfied, the former is trivially met.The interesting case is the comparison between constraints in which there exist execution time variables.Consider the two comparable constraints: Observe that c 2 still dominates c 1 ; the schedulability query is: ∃s 1 ∀e 1 ∈ [3,5]  T ≤ b? Since the query is true for all values of e 1 in the range [3,5], the constraint s 1 − s 2 ≤ −e 1 is subsumed by the constraint s 1 − s 2 ≤ −e 1 − 4; e 1 ∈ [3,5].This holds true for every pair of comparable constraints c 1 and c 2 , that is, either c 1 ⇒ c 2 or c 2 ⇒ c 1 .In other words, the domination relationship imposes a total order on each set of comparable constraints between two jobs.We use lexicographical ordering to break ties.It follows that in each equivalence class of the partition imposed by the comparability relationship, there exists a unique constraint that dominates all other constraints in that class.
Definition 5.6.The unique elements which dominate all the other constraints in their respective partitions are called the dominators of that partition.
Theorem 5.7.Let the constraint system contain two constraints c 1 and c 2 , such that c 1 dominates c 2 .Eliminating c 2 from the set of constraints, does not alter the partially clairvoyant schedulability of the system, that is, if the constraint system has a partially clairvoyant schedule with c 2 , then it has such a schedule without c 2 ; likewise, if it does not have a partially clairvoyant schedule, in the absence of c 2 , then it does not have one, in the presence of c 2 either.
In other words, we can eliminate c 2 from the constraint set and test for partially clairvoyant schedulability on the reduced set of constraints.In fact, it suffices to retain the 16 dominators between each pair of jobs, since all other constraints are redundant.
Proof.We provide a proof for the case in which both c 1 and c 2 belong to the set S LSi1 j1 i j .The other fifteen cases can be argued in similar fashion.
(1) Assume that the system containing both c 1 and c 2 has a partially clairvoyant schedule.We need to prove that the system will continue to have such a schedule after c 2 is eliminated.But this is obvious, since we are reducing the number of constraints; indeed any solution to the old system (with c 2 present) is also a solution to the new system (with c 2 eliminated).
(2) Consider the case in which the system containing both constraints does not have a partially clairvoyant schedule.We need to show that the removal of c 2 does not make the system schedulable.Without loss of generality, we assume that c 1 is (s i + e i ) + (s j + e j ) ≤ k 1 and c 2 is (s i + e i ) + (s j + e j ) ≤ k 2 , where k 1 ≤ k 2 , since c 1 dominates c 2 .Let us assume that the system has a partially clairvoyant schedule, when c 2 is removed.Now consider the n round 2-person game played by the start time and execution time players.At the end of n rounds, constraint c 1 must be met; accordingly, (s i + e i ) + (s j + e j ) ≤ k 1 , which means that (s i + e i ) + (s j + e j ) ≤ k 2 and hence the start time player could have won the game, even in the presence of c 2 , thereby contradicting the hypothesis that the system did not have a partially clairvoyant schedule, in the presence of both c 1 and c 2 .This leads us directly to the following theorem.
Theorem 5.8.There are at most 16 nonredundant constraints between any 2 jobs; hence the total number of nonredundant constraints is at most O(n 2 ).
end if Algorithm 5.1.A quantifier elimination algorithm for determining partially clairvoyant schedulability.