Competitive Algorithms for Fine-Grain Real-Time Scheduling

Transcription

1 Competitive Algorithms for Fine-Grain Real-Time Scheduling Michael A. Palis Department of Computer Science Rutgers University NJ Abstract Thispaper investigates the task scheduling problemfor real-time systems that provide rate of progress guarantees on task execution. A task system model, called task system, is introduced that allows rate of progress requirements to be specified in terms of two simple parameters: an execution rate r and a granularity g. The granularity parameter is a new metric that allows the specification of grain timing constraints on the task s execution and is a generalization of the stretch metric used an recent research on task scheduling. It is shown that the product as an important determiner of the existence of good online scheduling algorithms. Specifically, there is an upper bound on this product above which there are no good online algorithms but below which an online algorithm with logarithmic competitive ratio exists. This paper also demonstrates a fundamental difference between two contrasting strategies for admission control: greedy non-greedy. It is shown that greed does not pay : there is a scheduling algorithm with a non-greedy admission policy that provably outperforms the well-known Greedy EDF scheduling algorithm. 1 Introduction The growing need to support real-time interactive multimedia applications such videoconferencing, collaborative work, and remote entertainment, has made quality of service provisioning an important and challenging problem in the design of integrated-services networks and computer systems. To enable the system to provide guarantees, source applications specify their resource requirements and the system, in turn, reserves and schedules the use of resources in accordance with source specifications. Practical systems, however, have finite resources and hence a huge number of requests could easily bring the system to a state of overload that makes it impossible to satisfy the requirements of all requests. Thus, admission control is a necessary and integral component of such reservation-based systems. The task of admission control is to selectively admit requests such that the requirements of these requests, along with those of previously admitted requests, can be met by the system. In this paper we consider the problem of scheduling real-time tasks on a single-processor system in which a task s specification is expressed as a rate of progress requirement on the task s execution. One way to specifya task s rateof progress is by its stretch, which is the maximum slowdown that it can tolerate relative to the time it takes to run on an unloaded system. For example, a task which has an execution time of 100msec (on an unloaded system) and stretch 2 is allowed to run at a slower rate so longas it is completed no later than 200 msec after it arrives. More precisely, a task with arrival time a, execution time e and stretch s must complete execution no later than its deadline, a + se. A number of recent papers have addressed the task scheduling problem based on the stretch metric [3, 4, 5, 6, 8, 9, Muthukrishnan et al. [3, 4, presented offline and online scheduling algorithms that mimimize either the maximum stretch or the average stretch of the tasks in the system. and Palis [5, developed online preemptive scheduling algorithms with admission control for the stretch metric under both the hard model and firm real-time models. In the hard realtime model, the system guarantees that every admitted task is executed within its specified stretch and accrues a profit equal to the execution times of all admitted tasks. In the firm real-time model, the system is allowed to fail to meet the stretch requirements of certain admitted tasks, but does not gain a profit from such tasks. In Goldwasser considered a slightly different but related metric called slack and developed an online non-preemptive scheduling $ IEEE 129

2 -.- rithm. Finally, Garay et al. developed online preemptive algorithms for the slack metric for both the hard real-time and firm real-time models. Although the stretch metric is useful in certain applications web searches and database queries), it does not quite capture the more stringent rate of progress requirements inherent in many real-time applications, such as continuous media audio and video). While it is acceptable to slow down the processing of such applications as the system load increases, it is nonetheless crucial that the processing progresses at a relatively uniform rate throughout the lifetime of the application. Unfortunately, the stretch metric does not allow the specification of fine-grain timing constraints other than a single task deadline. As a result, the scheduling algorithms are prone to producing schedules in which a task s execution rate may vary widely between its arrival time and its deadline. In Yau and Lam presented a framework for adaptive rate-controlled scheduling that takes into account the rate of progress requirements of real-time applications that we alluded to above. In their framework, the system tasks to reserve processor time based on a rate (0 < 1) and a period p. The system guarantees that the task, if admitted, is executed for at least krp time units over the next kp time units after it arrives, for k =... For example, if the rate is 0.2 and the period is 100 msec, then the task is guaranteed to run for at least 20 ms over the first 100 msec after it arrives, for at least 40 msec over the first 200 msec, and so on. Yau and Lam developed an online preemptive scheduling algorithm for their model and presented an empirical evaluation of the algorithm on various applications. 1.1 Problem Statement In this paper we investigate the theoretical performance of online preemptive scheduling algorithms based on Yau and Lam s task model. Specifically, we consider the problem of scheduling a sequence of n independent tasks, =.., on a single processor system in which each task = is characterized by the following four parameters: an arrival time an execution time a rate 0 < 1; and a period pi. The arrival time is the time that the task first becomes runnable. The execution time is the amount of processor time the task needs to run without interruption on an unloaded system. The last two parameters specify the rate of progress requirement for executing the task. Specifically, upon its arrival at time task must be executed for at least time units during the time interval + for k =.. until it is completed has run a total of time units). We assume that Define as the granularity of task Note that 0 < 1 since Intuitively, the granularity is a measure of the smoothness of the task s execution profile: the finer the granularity the smaller is), the more uniform the task s rate of progress will be for any given time interval during its execution. Note that when = 1 for all tasks the resulting problem instance corresponds to the case when each task is characterized by a stretch equal to Thus, the granularity metric can be viewed as a generalization of the stretch metric. A sequence of tasks =...,T,} is called an task system if r 1 n} and g 1 n}. That is, in an task system every task has rate at most r and granularity at least g. We consider online preemptive scheduling algorithms for (r, task systems with admission control that satisfy the following property: Upon the arrival of a task T,the system immediately decides whether to admit or reject T. If it admits T then the system must execute T so that it satisfies its rate of progress requirement as described above. Thus, we assume a hard real-time model in which the system ensures that the requirements of all admitted tasks are met. We are interested in online scheduling algorithms that maximize the processor (or simply utilization), which is defined as the sum of the execution times of admitted tasks. We measure the performance of an online algorithm A in terms of its competitive ratio, which is the ratio of the utilization obtained by an optimal offline algorithm OPT to that obtained by algorithm A. More precisely, let and be the utilizations of A and OPT, respectively, for a sequence of tasks 7. We say that A has competitive ratio (or is c-competitive) if for every task sequence 1.2 Summary of Results In this paper we show that the task system model is useful in characterizing task systems which are difficult to schedule and those for which 130

3 cient scheduling algorithms exist. In particular, let = + 2. We show that: 0 For (r,g) task systems satisfying lg 1,there is an online scheduling algorithm, called NON- GREEDY EDF, that achieves a competitive ratio of Moreover, this algorithm is optimal: the competitive ratio achievable by any online algorithm for this class of task systems is 0 The rate bound lg 1is necessary: without this bound any online algorithm has a competitive ratio of Our results also demonstratea fundamental difference between two contrasting strategies for admission control: greedy vs. non-greedy. Many real-time scheduling algorithms implement admission control using a feasibility test to determine whether an incoming task, along with previously admitted tasks, has a schedule that meets all task deadlines. If so, the task is admitted and added to a run queue of admitted tasks, which are then scheduled for execution by a run-time scheduler. That is, the admission controller implicitly employs a greedy policy: it always admits a task if it can be feasibly scheduled with previously admitted tasks. The results of this paper and a previous paper show that a greedy admission control policy is provably bud. In particular, in we investigated GREEDY-EDF,an online algorithm for g)task systems that uses a greedy admission policy and a runtime scheduler based on the Earliest Deadline First (EDF) scheduling algorithm. In that paper we showed that GREEDY-EDF has competitive ratio Hence for rate-bounded ing g) task systems satisfy- < 1, GREEDY-EDF has competitive ratio In contrast, the NON-GREEDY E D F algorithm uses a non-greedy admissionpolicy. Instead of a feasibility test, NON-GREEDY EDF employs a throttle test to reject certain incoming tasks, even when these tasks can be feasibly scheduled, to allow future more profitable tasks to be admitted. At the same time, since the online algorithm has no knowledge of future tasks, it maintains a large enough pool of admitted tasks to ensure that the processor utilization is never too low. Our work is motivated in part by previous work of Awerbuch, Azar and (AAP) on online routing of virtual circuits in ATM networks. They considered the problem of routing a sequence of calls,where each call requires the establishment of a virtual circuit between two nodes in the network for a given time duration (the holding time) and at a specified bandwidth. They assume an idealized fluid flow model in which each admitted call must be guaranteed its requested bandwidth at every time step throughout its duration. They developed an online routing algorithm that achieves a competitive ratio of provided that each call has a requested bandwidth that is at most fraction of the link capacity, where L is the maximum number of hops allowed for a single circuit and is the maximum duration of any call. The AAP routing algorithm can be used to obtain a scheduling algorithm for maximally fine-grain task systems in which each admitted task runs continuously at a rate for every time step over a duration of length d. That is, each task has granularity The resulting algorithm achieves a competitive ratio of where is the maximum duration of any task, provided that the task rates are at most lg D). Our online algorithm generalizes this result for task systems of arbitrary granularity, from maximally fine-grain task systems to maximally coarse-grain ones corresponding to those of the stretch model described earlier. 1.3 Map The rest of the paper is organized as follows. The next section describes the online scheduling algorithm NON-GREEDY EDF. Section 3 proves the correctness of the online algorithm and analyzes its complexity. Section 4 proves the upper bound on the competitive ratio of the online algorithm for rate-bounded task systems. Section 5 proves the matching lower bound on the competitive ratio for rate-bounded task systems and a lower bound for task systems with unbounded rates. Finally, Section 6 ends the paper with some concluding remarks and a discussion of future work. 2 The NON-GREEDY EDF Scheduling Algorithm NON-GREEDY E D F consists of two components: (1) an EDF-based scheduler that schedules the execution of admitted tasks on the processor, and (2) an admission controller that admits or rejects tasks based on an admission test. Let.. be the task sequence to be processed, where = Thus, task has granularity Let g and = We assume that 131

4 the rates satisfy the condition: lg 1for 1 n. This restriction is necessary in order to achieve a competitive ratio of As proved later in Section 5, without this restriction the competitive ratio of any online algorithm is We first describe the scheduler. It is based on the Earliest Deadline First (EDF) scheduling algorithm (see, [7, Informally, each admitted task T = (a,e, is scheduled as a sequence of m = jobs such that: (a) for 1 the execution time and deadline of the i-th job are and respectively; and (b) the execution time and deadline of the m-th job are e- (m- and a + respectively. Item (b) above takes into account the fact that = l/g may not be an integer. The deadline d of the (entire) tasktis the deadline of its last job; d =a+ Given a set of admitted tasks, the scheduler executes the tasks according to an EDF schedule of the jobs comprising these tasks. Clearly, the rate of progress requirements of the admitted tasks are satisfied if the corresponding jobs are executed by their respective deadlines. The details of the scheduler are as follows. It maintains a run queue of tasks that have been admitted but not yet completed. It also maintains a timing variable which measures the amount of time that the processor has been running since it was last idle. It resets to zero when the processor becomes idle and the run queue is empty. That is, measures time relative to the beginning of the current busy interval during which the processor is continuously executing some task. Henceforth, when we refer to time (including task arrival times and deadlines), we shall mean time relative to the beginning of the current busy interval, which is time 0. Associated with each admitted task in the run queue are two variables: a reserved time and an intermediate deadline d > The scheduler is invoked at each rescheduling point, which is a time when one of following events occurs: For case the scheduler first checks if the currently running task T = has completed has run for a total of e time units). If so,t is removed from the queue. Otherwise, the scheduler updates scheduling variables to d = d + and = rp. (If e is not a multiple of then last job requires time units. In this case, is set to the remaining execution time and d is set to a+ The then selects the queue the task with the smallest d value and runs this task next. If the queue is empty, the processor becomes idle and the timer is reset to zero. For case the scheduler adds the new initializes its d and values to d = and = If the processor is idle at the time is admitted, then is immediately executed and the timer is started (signaling the beginning of a new busy interval). On the other hand, if the processor is currently running some task and this task has a value greater than d value, then the currently running task is preempted and returned to the queue and its value is reduced by the amount of time it has consumed since it was last run. The new task is then selected to run next. We now describe the admission controller. It is invoked every time a new task arrives and performs an admission test to determine whether to admit or reject the new task. Consider the arrival of task at time = If = 0, then the processor is idle and is immediately admitted and executed (thus starting a new busy On the other hand, if 0, the admission controller does the following. Let be the set of tasks in the current busy interval that have already been admitted before the arrival of Let = be a task in and let = + beti sdeadline. For each t 0, defineti srate contribution at time t as: if t < = 0 otherwise rate contribution at time t is defined as: The processor is busy and the currently running task has run for an amount of time equal to its reserved time; or A new task is admitted by the admission controller. The admission controller admits if and only if 132

5 Inequality 3 is a throttle test that determines whether it would be profitable to admit task It is instructive to understand the reasoning behind this test. For each task define the load of at time denoted as the minimum processor time that would need during the time interval in order to meet its rate of progress requirement, where is Ti sarrival time. Similarly, let = In the next section we show that: That is, the only tasks that pass the admission test of inequality 3 are those tasks satisfying: In the above inequality, the load is multiplied by a weight which is exponential in the fractional load at time due to already admitted tasks. If for all the weighted load does not exceed then is admitted and the algorithm obtains a profit. Inequality 4 can, in fact, be used as an admission test, and it can be shown that the resulting online algorithm achieves a competitive ratio of Unfortunately, this test is costly to perform because it requires computing the loads and for every time step On the other hand, as we show in the next section, the quantity - 1)dt of inequality 3 can be computed in time. Furthermore, the resulting algorithm also achieves competitive ratio (albeit, with a slightly larger constant of proportionality). 3 Complexity Analysis and Proof of Correctness For a given task sequence, NON-GREEDY EDF produces a schedule that consists of an alternating sequence of busy and idle intervals, where a busy (idle) interval corresponds to the case when the processor is (is not) running some task. Note that every task must have arrived during a busy interval. If the task arrived when the processor idle, then = 0 and the task would pass the admission test and be immediately executed, thus starting a new busy interval. Additionally, every admitted task is completed during the same busy interval when it arrived. Thus, no scheduling, task execution, or admission control activities occur during idle intervals and so it suffices to consider busy intervals when analyzing the complexity and correctness of the scheduling algorithm. Consider an arbitrary busy interval and let..., be the sequence of tasks that arrive during this busy interval. For each let be the set of tasks that have already been admitted before the arrival of An alternative (but equivalent) admission test can be obtained by observing that the function of equation 2 is piecewise linear and = 0 for all t In particular, consider the the half-open time interval [0, for some > 0. Call t a breakpoint of in if t t is either the arrival time or the deadline of some task in (Note that t = 0 is a breakpoint since it is the arrival time of the first task in Let 0 = < < be the breakpoints of in and let = Then the breakpoint intervals b, = < k, form a partition of Moreover, changes in value only at the breakpoints t,, 1 k. Specifically, for a t, < say that covers if where = + is Ti s deadline. Then, for every t b,, = where is the sum of the rates of all tasks that cover b,. Let = - t,. It follows that: Lemma 1 provides the following equivalent but more efficient method for performing the admission test. Given compute = and determine the breakpoints {t, 1 < < k} of in Let = For each breakpoint compute and Admit tasktj if and only if The number of breakpoints in [0, is at most 2 Thus, the can all be computed in time. As for the note that can be computed from by simply adding the rates of admitted tasks that arrive at time t, and subtracting the rates of those with deadlines equal to t,. Thus, computing the also takes time. Finally, the summation in inequality 5 can also be computed in time. Therefore, the admission test can be performed in time. Lemma together with the followingtechnical lemma (whose proof we omit because of space limitations), 133

6 will be used to prove the correctness of the scheduling algorithm. Lemma 2. Let and 1 k} be positive real numbers and 1 be nonnegative k real numbers. For every The last step follows from the fact that for every t, (t- Since by assumption 1, it follows that:. Consider an arbitrary busy interval and let =... be the sequence of tasks that arrive during this busy interval. To prove the correctness of the algorithm, it suffices to show that: Theorem 1. For each S, if task is admitted, then all previously admitted tasks, plus are schedulable, can be executed according to their rate of progress requirements. Proof. Let S be the set of tasks that have already been admitted before the arrival of Clearly, if is the first admitted task, then = and is schedulable. Inductively, assume that is not the first admitted task and is schedulable. We want to prove that if is admitted then is schedulable. For each task = U define the load of at time t as since = + 2. Let 0 = < < < be the breakpoints of in the interval and let = For each breakpoint interval, = 1 let = - t, and be the sum of the rates of all tasks in that cover b,. From equation 6, it is easy to see that for each task Therefore, Ti cowers That is, is the amount of processor time that would need during the interval t)in order to meet its rate of progress requirement. Similarly, we define the load of at time t as = ( 6,) Ti cowers Thus, from inequalities 8 and 9, we get: k Suppose to the contrary that is admitted but U is not schedulable. Then there exists a time such that But by lemmas 1 and 2, This implies that Thus, - 1)dt and hence: 134

7 By assumption, 1. Hence, - 1 = - since - for Noting that = +1,we get: - since g Let be the subset of tasks in S admitted by algorithm A. Since (t)= 0,it follows that for every Therefore, - 1) > and hence should have been rejected by the online which is a contradiction. 4 Competitive Analysis In this section we analyze the competitive performance of NON-GREEDY EDF. In particular, we prove the following: Theorem 2. For task systems satisfying r 1, where = + 2, NON-GREEDY EDF achieves a competitive ratio of Proof. Let be an task system such that r lg 1. For notational convenience, let A be the NON-GREEDY EDF algorithm and let OPT be an optimal offline algorithm. As described previously, A produces a schedule for that consists of disjoint busy intervals that partition into disjoint subsets.., where is the subset of tasks that arrive during the i-th busy interval. Since Hence, Since for each admitted task and = - = we get: dt it suffices to consider an arbitrary busy interval and the subset of tasks S = that arrive during the busy interval and prove that A achieves a competitive ratio of for the tasks in S. In the following, we in fact show that: 2 = (10) For each = S and for each 0, let = - 1. Consider the arrival of task S. If was rejected by A,then (t)= (t) for every t. On the other hand, if was admitted by A then: Let be the subset of tasks in S admitted by the optimal algorithm OPT. If = then = and the theorem is proved. Otherwise, there exists a task with the latest deadline admitted by OPT but rejected by A. (If there are several such tasks with the same latest deadline, choose the task with the largest index.) Since was rejected by A, then by the admission test of inequality 3 it should be the case that: Using inequality 11 this implies that 135

8 Adding to both sides of the above inequality and noting that + = the deadline of we Since the processor was continuously busy during the time interval Therefore, Now, all tasks admitted by OPT with deadlines must be completed by OPT no later than time Furthermore, by the definition of all tasks admitted by OPT with deadlines > must have also been admitted by A. Thus, + This, together with the above inequality, implies that: 5 Lower Bounds on the Competitive Ratio In this section we show that NON-GREEDY EDF is optimal in the sense that even for rate-bounded systems, those satisfying lg 1, any online algorithm has competitive ratio We also show that the rate bound is necessary because for task systems with 1, the best possible competitive ratio achievable by any online algorithm is ((1 We begin by proving the following result. Theorem 3. For task systems, any online scheduling algorithm has a competitive ratio of for any < 1. Proof. Let A be any online scheduling algorithm and let m = l/g and = Consider the task sequence which consists of k task subsets.., for some finite k. For each consists of s identical tasks each with execution time = rate = and period = Every task in has arrival time 0 but we assume that the adversary the to A in distinct phases. That is, the tasks in become known to A only at the start of phase a and phase + 1 does not begin until A has processed all the tasks in Let p 1 be a fixed constant. First we show that there is an adversarial strategy for that forces A to incur a competitive ratio of at least p. Then we show that the strategy holds for p = (lgm + thus proving the theorem. For each phase k 1, the adversary's strategy is as follows. Let 1 k, be the number of tasks in admitted by A and let = If the adversary stops the task sequence at the end of phase k, rejects all tasks from all previous phases i, 1 i < k, and admits just the s tasks in Thus, the adversary obtains a utilization = while A obtains a utilization = = Hence the competitive ratio is On the other hand, if > the adversary continues with the next phase + 1 by the tasks in We show that there is some phase k for which must necessarily be because otherwise there will not be a feasible schedule. Consider time t = For 1 k, = is the number of periods of a task in that ends at or before time t. Therefore, by time t A must run each admitted task in for at least = time units, provided that = or m. Summing over all tasks, A must run for at least = time units by time t in order the satisfy the rate of progress requirements of all admitted tasks in.. Now suppose that for every 1 k. Then it can be shown that > (k which implies that > + Clearly, there is no feasible schedule if > t, which happens when p (k+ Thus, if the adversary chooses p = (k+ then A can achieve a feasible schedule only if which implies that A's competitive ratio is p. Finally, the adversary chooses to satisfy the constraint that m for It is easy to verify that this constraint is satisfied when = lgm + 1. The theorem follows since for this value of = (lgm + For task systems with "large rates", those satisfying 1, a stronger lower bound of (( can be shown. Consequently, it is necessary to impose the rate bound of lg 1if one hopes to achieve a competitive ratio of Theorem 4. For task systems satisfying 136

9 1, any online scheduling algorithm has a competitive ratio of Proof Sketch. The case when = 1is easily proved by considering a sequence of two tasks and both with granularity g, such that has unit execution time and has execution time e = An online scheduler must admit (since it may be the only task) but cannot also admit On the other hand, an optimal algorithm would admit resulting in a competitive ratio of Hence, assume that < 1. Let m = and be any real number, 0 < < 1. Consider the task sequence = 0 i defined as follows: 0 has execution time = rate = and period = has execution time = m, rate = and period = and 0 For 2 i s, has execution time = + rate = and period = + where a 1 is an integer constant and is a real number satisfying < 1, - E )}. The proof hinges on the fact that for any integer a 1, an online scheduler A must admit.. for every k,0 k to obtain a competitive ratio < a- E. On the other hand, A cannot admit after it has already admitted..., because doing so would result in overload at time t = + To see this, we note that for 1 i s, = is the number of periods of task that ends at or before time t. That is, A must run for at least time units by time t in order to meet its rate of progress requirement, provided that In addition, since = 6s s t, A must run for at least one period, consuming at least 6 > 0 time units. Thus, by time t, A must run.. for at least = t > t. Thus, A cannot admit which implies The above argument holds provided that for 1 or equivalently, + C2: + m, and m for Clearly, implies C2. Hence, it suffices to show that if rlgm 1, holds for some integer a 1. It can - i be shown that a = satisfies these constraints. Therefore, we conclude that: for any 0< E < 1. 6 Concluding Remarks and Future Work We have introduced the g)task system model that allows rate ofprogress requirements of real-time tasks to be specified in terms of two simple parameters: an execution rate and a granularity We have shown that this model is useful in delineating the boundary between task systems which are difficult to schedule and those for which efficient scheduling algorithms exist. In particular, efficient online scheduling algorithms only exist for task systems satisfying the rate bound, We have also shown that there is a a fundamental difference between two contrasting strategies for admission control: greedy vs. non-greedy. In particular, a non-greedy admission policy provably outperforms a greedy policy for bounded task systems. The results of this paper, however, do come with a caveat. It assumes a task model in which a task can run continuously without interrruption on an unloaded system. This is different from Liu and land's periodic task model or sporadic task model in which a task consists of a succession of events, each with a distinct arrival time, and an event cannot be processed until it arrives. Other eventdriven task models include the rate-based execution (RBE) model of Jeffay and Goddard the multiframe task model of Mok the generalized multiframe task model of Baruah et. and the Reservations scheduling framework of Microsoft Research's operating system For eventdriven task systems, the processor may become idle even though there are admitted tasks that have not finished because the next events of these tasks have not yet occurred. Unfortunately, our analysis relies on the assumption that an admitted task is always runnable until it actually finishes, and hence is not applicable to these task systems. An interesting open problem is to find competitive online scheduling algorithms for event-driven systems based on the g) 137

10 task model introduced here. Finally, it would be interesting to extend the results to the firm real-time model and to multiprocessor systems. References Awerbuch, B., Y. Azar, and S. Plotkin, Throughout-Competitive On-Line Routing, Proc. 34th IEEE Symposium on Foundations of Computer Science, 32-40, Nov [2] Baruah, S., D. Chen, S. Gorinksy, and A. Mok, Generalized Multiframe Tasks, Intl. Journal of Tirne-Critical Computing Systems, 17, 22, [3] Becchetti, L., S. Leonardi and S. Muthukrishnan, Scheduling to Minimize Average Stretch without Migration,Proc. 11thAnnual ACM-SIAM Symp. on Discrete Algorithms, , [4] Bender, M., S. Chakrabarti and S. ishnan, Flow and Stretch for Scheduling Continuous task Streams, Proc. 9th Annual ACM-SIAM Symp. on Discrete Algorithms, 279, [5] Dasgupta, B. and M. A. Palis, Online Real-Time Preemptive Scheduling of Tasks with Deadlines on Multiple Machines, Proc. 3rd Intl. Workshop on Approximation Algorithms for Combinatorial Optimization Problems, Lecture Notes in Computer Science 1913, , Dasgupta, B. and M. A. Palis Online Real-Time Preemptive Scheduling of Tasks with Deadlines on Multiple Machines, Journal of Scheduling , [7] Dertouzos, M., Control Robotics: the Procedural Control of Physical Processors, Proc. IFIP Congress, , Garay, J., J. Naor, B. Yener, P. On-Line Admission Control and Packet Scheduling with Proc. IEEE INFOCOM 2002, 103, June Goldwasser, M., Patience is a The Effect of Slack on Competitivenessfor Admission Control, Proc. 10th ACM-SIAM Symposium on Discrete Algorithms, , Jan Jones, M., J. and A. An Overview of the Real-Time Architecture, Proc. 7th ACM SIGOPS European Workshop, , Sept Jones, M., D. ROSU, and ROSU, Reservations and Time Constraints: Predictable Scheduling of Independent Activities, Proc. 16th ACM Symposium on Operating Systems Principles, , Oct Liu, C. L. and W. Scheduling gorithms for Multiprogramming in a Hard Real Time Environment, JACM, 20, 46-61, Mok, A., Fundamental Design Problems of Distributed Systems for the Hard Real-Time Environment, Doctoral Dissertation, M.I.T., Mok, A. A Multiframe Model for Real-Time Tasks, IEEE Trans. on Software Engineering, , Oct Muthukrishnan, S., R. Rajaraman, A. Shaheen and J. E. Gehrke, Online Scheduling to Minimize Average Stretch, Proc. 40th Annual IEEE Symp. on Foundations of Computer Science, , Palis, M. A., On the Competitiveness of Online Real- Time Scheduling with Rate of Progress Guarantees, International Journal of Foundations of Computer Science, , Plotkin, S., Competitive Routing of Virtual Circuits in ATM Networks, IEEE Journal on Selected Areas in Communications, 1136, Aug Yau, D. K. Y. and S. S. Lam, Adaptive Rate- Controlled Scheduling for Multimedia Applications, Transactions on Networking, Jeffay, K. and S. Goddard, A Theory of Rate- Based Execution, Proc. 20th IEEE Real-Time Systems Symposium, ,