a utilization bound for aperiodic tasks and priority

A Utilization Bound for Aperiodic Tasksand Priority Driven Scheduling

Tarek F. Abdelzaher, Member, IEEE, Vivek Sharma, and Chenyang Lu, Member, IEEE

Abstract—Real-time scheduling theory offers constant-time schedulability tests for periodic and sporadic tasks based on utilization

bounds. Unfortunately, the periodicity or the minimal interarrival-time assumptions underlying these bounds make them inapplicable to

a vast range of aperiodic workloads such as those seen by network routers, Web servers, and event-driven systems. This paper

makes several important contributions toward real-time scheduling theory and schedulability analysis. We derive the first known bound

for schedulability of aperiodic tasks. The bound is based on a utilization-like metric we call synthetic utilization, which allows

implementing constant-time schedulability tests at admission control time. We prove that the synthetic utilization bound for deadline-

monotonic scheduling of aperiodic tasks is 1

1þffiffiffiffiffiffi1=2

p . We also show that no other time-independent scheduling policy can have a higher

schedulability bound. Similarly, we show that EDF has a bound of 1 and that no dynamic-priority policy has a higher bound. We assess

the performance of the derived bound and conclude that it is very efficient in hit-ratio maximization.

Index Terms—Real-time scheduling, schedulability analysis, utilization bounds, aperiodic tasks.

�

1 INTRODUCTION

Afundamental problem in real-time scheduling is that ofcomputing the schedulability of a task set. For periodic

and sporadic tasks, sufficient schedulability conditions exist

that relate schedulability to aggregate utilization. The best-

known result in this area is the original utilization bound

derived by Liu and Layland [18] for periodic tasks. To date,

no such bound exists for aperiodic tasks. In this paper, we

prove for the first time that aperiodic tasks with arbitrary

arrival times, computation times, and deadlines are

schedulable by a time-independent policy if their aggregate

synthetic utilization1 does not exceed 1


p . (We also

trivially show that, for dynamic-priority scheduling, the

bound is 1.)Our work is motivated by the timing requirements of

high-performance real-time services such as online trading.High performance servers may need to handle tens ofthousands of requests per second. If the service is real-time,it must ensure that all requests are served within theirrespective deadlines. While mainstream Web services dohave real-time applications, the primary market of thedevelopers of such systems remains predominantly best-effort. Vendors whose primary market is best effort

applications are generally reluctant to embed polynomialtime real-time schedulability analysis tests in their pro-ducts. A constant-time test that promises significant addedvalue in terms of timeliness guarantees is much moreappealing. Such a test is more likely to be widely deployedin mainstream applications in practice, which is the primarymotivation for the approach taken in this paper. Hence, wederive an efficient online test that determines the schedul-ability of incoming tasks based on simple inspection of thecurrent value of a utilization-like metric. Consequently, aconstant-time admission control can be applied to ensurethat the deadlines of all admitted tasks are met andmaximize the admitted task ratio while making no assump-tions regarding the task arrival pattern.

For portability considerations, we are more interested inderiving schedulability conditions under static schedulingpolicies in which task invocation priorities do not dependon absolute time. Dynamic priority policies such as EDF,while addressed in this paper, are not implemented oncertain standard server operating systems, thereby limitingthe applicability of their results.

Deriving a schedulable bound for aperiodic tasks is aconceptual shift that calls for extending some basic notionsin rate-monotonic analysis to apply to the addressedproblem. More specifically, we use the notion of syntheticutilization2—a time varying quantity that depends oncurrent arrivals and deadlines. It reduces to Liu andLayland’s definition of utilization factor when analyzing(a critical instant of) periodic tasks. We show that the actualmeasured processor utilization of admitted tasks is lower-bounded by its synthetic utilization at all times. Syntheticutilization is used for admission control.

We also define a generalized notion of fixed-priorityscheduling that applies to aperiodic tasks, where each task

334 IEEE TRANSACTIONS ON COMPUTERS, VOL. 53, NO. 3, MARCH 2004

. T.F. Abdelzaher and V. Sharma are with the Department of ComputerScience, 151 Engineers Way, University of Virginia, Charlottesville, VA22904. E-mail: {zaher, viveks}@cs.virginia.edu.

. C. Lu is with the Department of Computer Science, WashingtonUniversity, St. Louis, MO 63130. E-mail: [email protected].

Manuscript received 12 July 2001; revised 27 Feb. 2003; accepted 13 Aug.2003.For information on obtaining reprints of this article, please send e-mail to:[email protected], and reference IEEECS Log Number 114523.

1. Synthetic utilization is defined in Section 3.

2. Also known as instantaneous utilization.

0018-9340/04/$20.00 � 2004 IEEE Published by the IEEE Computer Society

has only one invocation. Specifically, we consider a

category of scheduling policies we call time-independent,

in which individual invocation priorities are independent of

invocation arrival times. These policies are especially

suitable for abstracting differentiated services scheduling

algorithms. Using these notions, we make two main

contributions to real-time scheduling theory:

. We prove that deadline-monotonic scheduling is theoptimal time-independent scheduling policy foraperiodic tasks in the sense of maximizing theutilization bound. Observe that optimality is definedhere in the same sense used when calling rate-monotonic scheduling an optimal fixed-priorityscheduling policy for periodic tasks. It implies thatno other scheduling policy in its class can have ahigher schedulability bound. An admission control-ler based on this bound, however, may reject sometasks unnecessarily.

. We prove that the bound for schedulability of

aperiodic tasks under deadline-monotonic sche-

duling is 1


p (i.e., 58.6 percent). The bound

is lower than the Liu and Layland bound for

periodic tasks. This is because, by relaxing the task

periodicity requirement, we consider a larger set of

possible task arrival patterns. The minimum utili-

zation of an unschedulable pattern in that larger

set is smaller than the minimum utilization in the

subset of task arrival patterns that are periodic (the

Liu and Layland bound).

Schedulable utilization bounds are, by construction, pessi-

mistic. Exceeding the bound does not necessarily entail

deadline misses. We merely provide a sufficient schedul-

ability condition that has the merit of being computationally

efficient. What we show, however, is that our bound is tight

in that there exists an unschedulable pattern of aperiodic

task arrivals whose synthetic utilization is infinitesimally

above 1


p .

What is more important, as shown in the evaluation

section, is that, for a large range of workloads, the actual

measured processor utilization can be near saturation even

when synthetic utilization does not exceed the bound. This

is due to the way synthetic-utilization is defined. Hence,

admission control tests based on synthetic utilization do not

underutilize the processor.The remainder of this paper is organized as follows:

Section 2 introduces a new task model we call the acyclic

model. We show that any set of aperiodic tasks can be

represented by an equivalent set of acyclic tasks. The

utilization bound for time-independent scheduling of

acyclic tasks is described in Section 3. For completeness,

Section 4 derives the corresponding bound for fully

dynamic-priority scheduling. Section 5 evaluates the practi-

cality of the derived bound. Section 6 describes related

work. Finally, Section 7 presents the conclusions of the

paper and avenues for future work.

2 THE ACYCLIC TASK MODEL

To simplify the derivation of the utilization bound foraperiodic tasks, in this paper, we first define a morestructured task model we call the acyclic model. We thenshow that the utilization bound derived for this model isidentical to that for aperiodic tasks. Hence, while ourderivation can be based on the former model, the resultsapply to the latter.

An acyclic task is composed of a chain of successive taskinvocations. Each task invocation Ti has an arrival time Ai,an execution time Ci � 0, and a relative deadline Di > 0(hence, the absolute deadline di of the invocation isdi ¼ Ai þDi). Unlike the case with periodic and sporadictasks, different invocations of the same acyclic task haveindependent execution times and deadlines. The deadlineof each task invocation is the arrival time of the nextinvocation of the same task. Fig. 1 shows an example ofthree acyclic tasks. The horizontal timelines represent theprogression of individual tasks. The vertical bars delimitsuccessive invocations of the same task. Each bar marksboth the deadline of the previous invocation and the arrivaltime of the next. The shaded rectangles represent invocationexecution times. In this figure, the tasks are scheduled as ifeach had its own processor. Note that some task invocationshave a zero execution time, which is allowed in the acyclictask model.

It is easy to see that any set of aperiodic task invocationscan be transfered to an equivalent set of acyclic taskinvocations as follows:

. Partition all aperiodic task invocations into se-quences (of one or more invocations each) such that,for any two consecutive invocations Ti and Tj in thesame sequence, the absolute deadline di of the firstinvocation is no later than the arrival time Aj of thenext (i.e., di � Aj). Let the number of such sequencesbe n.

. For every two consecutive invocations Ti and Tj inthe same sequence (where Ti precedes Tj), if di < Aj,insert a third “dummy” invocation Tk between Ti

and Tj with arrival time Ak ¼ di, deadline dk ¼ Aj,and execution time Ck ¼ 0. Note that the addedinvocation does not alter schedulability and does notchange utilization. When this process is completed,each of the n invocation sequences thus formedsatisfies the definition of an acyclic task.

The above transformation suggests that, since, for eachaperiodic arrival pattern, there exists an equivalent acyclicarrival pattern of the same utilization and schedulability

ABDELZAHER ET AL.: A UTILIZATION BOUND FOR APERIODIC TASKS AND PRIORITY DRIVEN SCHEDULING 335

Fig. 1. An example acyclic task set.

status (and, trivially, vice versa), a bound derived foracyclic tasks will apply to aperiodic tasks as well. Hence, itsuffices to derive a utilization bound for acyclic tasks. Thisbound will depend on the number of acyclic tasks n (whichis why it is easier to express it for an acyclic task modelrather than directly for an aperiodic model). Since, in highperformance servers, a large number of requests are servedconcurrently, the number of acyclic tasks n is typically verylarge. Therefore, for all practical purposes, we are mostinterested in the asymptotic value of the bound as n ! 1.This asymptotic value can be used by an admissioncontroller facing aperiodic tasks without the need totranslate the incoming invocation pattern into an equivalentset of acyclic tasks.

3 THE GENERALIZED BOUND FOR ACYCLIC TASKS

Consider the simple model of scheduling independentacyclic tasks on a uniprocessor. We begin by introducingthe concept of synthetic utilization, which is central to thederivation of our schedulability bound. At any given timeinstant, t, let V ðtÞ be the set of all task invocations that havearrived but whose deadlines have not expired, i.e.,V ðtÞ ¼ fTijAi � t < Ai þDig. Let nðtÞ be the number ofthese invocations at time t. In the acyclic task model, nðtÞremains constant over time, nðtÞ ¼ n (although someinvocations may have zero execution times). Fig. 2demonstrates the set V ðtÞ (shown in black) at a randomlychosen time instant, t0, for the three acyclic tasks of Fig. 1.The intervals of busy and idle CPU time are shown at thebottom of the figure.

Let a schedule gap be a period of idle CPU time. Observethat all task invocations that arrive before any such gaphave no effect on the schedule after the gap. Hence, it isuseful to define the subset SðtÞ � V ðtÞ which includes onlythose task invocations in V ðtÞ that arrive after the beginningof the last schedule gap. We call them current invocations.For example, at time t0 in Fig. 2, the set of currentinvocations, Sðt0Þ, would include only those of task 2 andtask 3. It would exclude the shaded invocation of task 1since that invocation arrives before a schedule gap thatprecedes t0. Observe that the definition of the set of currentinvocations SðtÞ does not depend on the actual completiontime of different invocations. Invocation completion timesare scheduling-policy-dependent. In contrast, we define

SðtÞ in a manner that is independent of the particularscheduling policy used. Note also that, by definition, SðtÞ isempty during a schedule gap. Synthetic utilization, UðtÞ, isdefined as the utilization contributed by the current taskinvocations at time t, given by the expression:

UðtÞ ¼X

Ti2SðtÞCi=Di: ð1Þ

A simple counter can keep track of synthetic utilization atruntime. The counter would be reset to zero at thebeginning of each schedule gap. It would be incrementedby Ci=Di upon the admission of a new task invocation Ti,and decremented by Ci=Di when the deadline of a currentinvocation Ti is reached. The set of current invocations isemptied when a schedule gap is encountered. A pseudo-code for the utilization-based admission controller is shownin Fig. 3. The initialization() procedure is executed at thebeginning. The request_handler(Ci;Di) and gap_handler()

are executed upon the arrival of a new task invocation andthe beginning of a new schedule gap respectively. Finally,event (i) is called by the operating system timer.3

We shall prove that, using an optimal time-independentscheduling policy, all task invocations will meet theirdeadlines if 8t : UðtÞ � UBðnÞ, where UBðnÞ ¼ 1

2 þ 12n for

n < 3 and

UBðnÞ ¼ 1

1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi12 ð1� 1

n�1Þq

for n � 3. (At n ¼ 3, the two expressions are equivalent.)When the number of current invocations, n, increases, thebound approaches 1


p .

It is important to notice that the aforementionedexpression of synthetic utilization reduces to the expressionof utilization used in prior schedulability bound literaturewhen tasks are periodic. The periodic task analysis isinvariably conducted for a critical instant of the task set [18](which contains no schedule gaps). During that interval,


3. In practice, it is more efficient to execute pending events only when anew invocation arrives, hence avoiding the need for fine-grained timers.

Fig. 2. V ðt0Þ: Task invocations at t0.

Fig. 3. The admission controller.

exactly one invocation is current from every task in theperiodic task set. Hence, SðtÞ is constant and includes asingle invocation of each task in the set, i.e., syntheticutilization is reduced to the standard expression of theutilization factor as defined by Liu and Layland [18]. Due tothis equivalence, the value of the utilization bound derivedin this paper can be meaningfully compared to the boundby Liu and Layland and its extensions for the differentperiodic task models.

3.1 Synthetic versus Measured Utilization

In the case of aperiodic tasks, synthetic utilization, UðtÞ, isnot necessarily equal to the measured utilization of aprocessor, defined as the fraction of time it is not idle. Thetwo are different because the expression for UðtÞ takes intoconsideration invocation deadlines, whereas measuredutilization does not. Consider the case where admissioncontrol or some other mechanism such as QoS adaptationprevents synthetic utilization UðtÞ from exceeding a ceilingthat is less than 1. This is the case, for example, with theadmission controller in Fig. 3.

Under the above condition, it is easy to show that thesynthetic utilization, UðtÞ, of admitted tasks, averaged overany time interval, is less than the measured utilization of theprocessor averaged over the same time interval. To see why,observe that the actual instantaneous utilization of theprocessor is either zero, within a schedule gap, or 1, whensome task is running. In contrast, the synthetic utilization,UðtÞ, is zero within a schedule gap (since SðtÞ is empty), butis upper-bounded by a value less than 1 when a task isrunning. Hence, it is always less than the measuredutilization (unless both are zero). This is true of bothinstantaneous values and averages over an arbitrary timewindow. The property is very important because it meansthat satisfying the schedulability bound on the syntheticutilization UðtÞ does not necessarily imply underutilizingthe processor. In fact, in the evaluation section, we showthat the processor can operate near full capacity while theschedulability bound on UðtÞ is observed by admissioncontrol. In the rest of this paper, when we refer to utilizationwe mean synthetic utilization unless explicitly statedotherwise.

3.2 Time-Independent Scheduling

Traditionally, scheduling policies are classified into fixed-priority and dynamic-priority depending on whether or notdifferent invocations of the same task have the samepriority. Associating fixed priority levels with acyclic tasksis meaningless because different task invocations can havearbitrarily different deadlines and execution times. Instead,we consider a broader category of scheduling policies,which we call time-independent. A scheduling policy istime-independent if the priority assigned to a task invoca-tion does not depend on its absolute arrival time. Such apolicy 1) classifies individual task invocations into a finitenumber of classes, 2) associates a fixed priority with eachclass (i.e., independently of invocation arrival times), and3) preemptively schedules tasks of different priorities inpriority order while scheduling tasks of the same priority ina FIFO order. Hence, we formally define time-independentscheduling as follows:

Definition. A scheduling policy is time-independent if thereexists a function fð�; tÞ ! P such that:

1. fð�; tÞ ! P maps an infinite set of task invocations �whose arrival times are given by vector t into a finiteset of priority values P .

2. fð�; tÞ ! P satisfies fð�; tÞ ¼ fð�; t0Þ, for any t and t0.3. The processor’s ready queue is sorted by values P such

that the ready task with the smallest value is resumednext. Tasks with the same value of P are queued inFIFO order.

Note that EDF, for example, is not time-independent by theabove definition since property 1 may be violated. To seewhy, consider an infinite set of independent task invoca-tions � , each of which 1) arrives before the previous onefinishes and 2) has a shorter absolute deadline. In this case,the priority of the ith arrival must be higher that that of theði� 1Þth arrival to ensure proper preemption in accordancewith EDF. Since this relation applies to every pair ofsuccessive arrivals, the number of priorities needed must beequal to the number of arrivals. An infinite set of suchinvocations therefore cannot be mapped into a finite set ofpriorities, which violates property 1. Moreover, shouldthese invocations have arrived in a different order, theirrelative priorities could have been different under EDF,depending on the resulting order of their absolute dead-lines. Hence, property 2 may be violated as well.

In contrast, FIFO is time-independent. In the context of theabove definition, FIFO can be thought of as a priority-drivenpolicy in which all tasks are assigned the same priority,regardless of the time at which they arrive. Hence, there existsa priority assignment which satisfies properties 1 and 2. Inthis assignment, the same priority tasks are scheduled FIFO,satisfying property 3. By definition, the existence of onepriority assignment which satisfies the three properties issufficient to render the policy time-independent. A minorpoint of clarification is that the definition states that only thepriority assignment should be independent of invocationarrival times. The total order of scheduled invocations is not.In particular, the order of same priority invocations dependson their arrival times since same priority invocations whicharrive earlier are scheduled first.

When P is small, a time-independent scheduling policycan be easily implemented on current operating systemsthat support a fixed (finite) number of priority levels. This,for example, is akin to diff-serv architectures which classifyall network traffic into a finite number of classes and givesome classes priority over others.

One time-independent classification of tasks would be bytheir relative deadlines, Di. For example, an online tradingserver can serve its “gold” customers within a delay boundof 1 second, serve its “silver” customers within a delaybound of 5 seconds, while offering noncustomers a best-effort service. We call a scheduling policy that assignshigher priority to invocations with shorter relative dead-lines a deadline monotonic scheduling policy. We shall provethat this policy achieves the highest schedulable bound.

3.3 The Sense of Optimality

In this paper, we call a scheduling policy optimal in aclass if it maximizes the schedulable utilization bound


among all policies in that class. For example, in the caseof periodic tasks, no fixed-priority scheduling policy has ahigher bound than rate-monotonic scheduling. Hence,rate-monotonic scheduling is the optimal fixed-prioritypolicy. In the same sense, EDF is the optimal dynamicpriority policy. In the following, we show that deadline-monotonic scheduling maximizes the bound among alltime-independent policies of aperiodic tasks. Observe thatwe are interested in the schedulability of a particulararrival pattern (i.e., a rigid task set).

3.4 The Optimal Utilization Bound

In this section, we first derive the utilization bound forschedulability of acyclic tasks under the deadline mono-tonic scheduling policy. We then show that no time-independent policy can achieve a higher bound. Let acritically schedulable task pattern be one in which some taskinvocation has zero slack. The derivation of the utilizationbound for deadline-monotonic scheduling undergoes thefollowing steps:

1. Consider the set S of all possible critically-schedul-able task invocation patterns.

2. Find, for each pattern � 2 S, the maximum utiliza-tion U�

max ¼ maxt UðtÞ that occurs prior to the dead-line of a critically schedulable invocation. Bydefinition of U�

max, there exists at least one point(prior to the deadline of a critically schedulableinvocation) in the pattern where the utilizationUðtÞ ¼ U�

max.3. Compute the minimum such utilization Umin ¼

min�2SfU�maxg across all patterns. Thus, in every

critically schedulable pattern, there exists at leastone point (prior to the deadline of a critically-schedulable invocation) where the utilizationUðtÞ ¼ U�

max � Umin.

Umin is therefore the utilization bound. Since each unsche-dulable independent task set (on a uniprocessor) can bemade critically schedulable by reducing the execution timeof the invocations that miss their deadlines, there alwaysexists a critically schedulable set of lower utilization. Hence,any unschedulable invocation pattern will necessarilyexceed our derived bound at some point prior to eachdeadline miss. In a system where the bound is neverexceeded, it must be that all invocations meet theirdeadlines. The key to a succinct derivation of the utilizationbound is to avoid explicit enumeration of all possible taskpatterns in set S defined in Step 1. Let the worst-case criticallyschedulable task invocation pattern (or worst-case pattern, forshort) be defined as one whose utilization never exceedsUmin. We begin by finding a subset of the set of all possiblepatterns S proven to contain a worst-case pattern (one withthe minimum utilization Umin). In particular, we prove thatthe worst-case critically schedulable task arrival pattern hasthe following two properties: 1) The lowest priority taskinvocation is critically schedulable and 2) the syntheticutilization, UðtÞ, remains constant, say U� , in the busyinterval prior to the deadline of the lowest priorityinvocation (where by busy interval we mean one ofcontinuous CPU consumption). Hence, U�

max ¼ U� , where

U� is the constant utilization in the aforementionedinterval.4

Subject to the above properties, we then find an analyticexpression for utilization U� as a function of the parametersof a general invocation pattern �. Finally, we minimize U�

with respect to pattern parameters to obtain the utilizationbound. Below, we present the proof in more detail.

Theorem 1. A set of n acyclic tasks is schedulable using the

deadline-monotonic scheduling policy if 8t : UðtÞ � UBðnÞ,UBðnÞ ¼ 1

2 þ 12n for n < 3 and UBðnÞ ¼ 1

1þffiffiffiffiffiffiffiffiffiffiffiffiffi12ð1� 1

n�1Þp for

n � 3.

Proof. Let us consider a critically schedulable acyclic taskinvocation pattern. By definition, some task invocation inthis pattern must have zero slack. Let us call this taskinvocation Tm. Consider the interval of time Am � t <

Am þDm during which Tm is current. At any time t

within that interval,

UðtÞ ¼ Cm=Dm þXTi>Tm

Ci=Di þXTi<Tm

Ci=Di;

where Cm=Dm is the utilization of task invocation Tm,PTi>Tm

Ci=Di is the utilization of higher priority taskinvocations that are current at time t, and

PTi<Tm

Ci=Di

is the utilization of lower priority task invocations thatare current at time t. Since lower priority invocations donot affect the schedulability of Tm, UðtÞ is minimizedwhen

PTi<Tm

Ci=Di ¼ 0. In other words, one can alwaysreduce the utilization of a critically schedulable taskpattern (in which task invocation Tm has zero slack) byremoving all task invocations of priority lower than Tm.Thus, to arrive at a minimum utilization bound, Tm mustbe the lowest-priority task invocation of all those that arecurrent in the interval Am � t < Am þDm. We call thisProperty 1. In the following, we shall denote the lowest-priority task invocation by Tn, i.e., set m ¼ n.

Let B be the end of the last schedule gap (i.e., period

of processor idle time) that precedes the arrival of the

critically schedulable task invocation, Tn in some taskinvocation set �. Let U�

max ¼ maxB�t�AnþDnUðtÞ. Next, we

show that the bound Umin ¼ min� U�max occurs for an

invocation set � in which the utilization UðtÞ is constant

in the interval B � t < An þDn. This interval is shown in

Fig. 4.Let �� be a pattern with the lowest maximum

utilization among all critically-schedulable patterns, i.e.,U��

max ¼ Umin. By contradiction, assume that U�� ðtÞ is notconstant in the interval B � t < An þDn. In this case, weshow that we can find another critically schedulable


4. Since U� is also a function of deadlines, it can be less than one in thebusy interval.

Fig. 4. The busy period.

invocation pattern with a lower maximum utilization. Todo so, choose thi such that

U�� ðthiÞ ¼ maxB�t<AnþDn

U�� ðtÞ:

Choose tlo such that U�� ðtloÞ < U�� ðthiÞ. SinceU�� ðtloÞ < U�� ðthiÞ, it must be that there exists atleast one acyclic task in the pattern such that itscurrent invocation at t ¼ thi, say Thi, has a largerutilization than its current invocation at t ¼ tlo, sayTlo, i.e., Chi=Dhi > Clo=Dlo. Consider invocations Thi andTlo of this task. Let us say that invocation TA delaysinvocation TB if a reduction in the completion time of theformer increases the slack of the latter and/or vice versa.The following cases arise depending on whether Thi andTlo delay the lowest priority invocation, Tn (which haszero slack):

. Case 1. Thi does not delay Tn: In this case, reducethe execution time of Thi by an arbitrarily smallamount �. This will decrease the utilization at thiwithout affecting the slack of Tn.

. Case 2. Thi delays Tn; Tlo delays Tn: Reduce theexecution time of Thi by an arbitrarily smallamount � and add � to the execution time of Tlo.The transformation does not decrease the totaltime that Tn is delayed. However, it has a lowerutilization at time thi.

. Case 3. Thi delays Tn; Tlo does not delay Tn: SinceThi delays Tn, it must be of higher priority. In thecase of deadline monotonic scheduling, thisimplies that Dhi < Dn. Hence, reduce Chi by anarbitrarily small amount � and add � to Cn. Thisdecreases UðthiÞ by at least �=Dhi � �=Dn, where�=Dhi > �=Dn because Dhi < Dn.

In each transformation above, the slack of Tn is un-changed. The result is a critically schedulable task set oflower maximum utilization. This is a contradiction withthe statement that �� has the lowest maximum utilizationamong all patterns (i.e., that U�� ðthiÞ ¼ Umin). Hence, theassumption (that UðtÞ is not constant) is wrong. Thisproves that Umin occurs when UðtÞ is constant in theinterval B � t < An þDn. We call this Property 2. Let uscall this constant value, U� , where � refers to the taskpattern for which this utilization is computed.

We now proceed with minimizing the utilization U�

with respect to the attributes of all task invocations in �that preempt Tn. Consider the busy period shown inFig. 4 (i.e., period of continuous CPU execution) thatprecedes the deadline of the critically schedulable taskinvocation Tn. Let L ¼ An �B be the offset of the arrivaltime of task invocation Tn relative to the start of the busyperiod. The minimization of U� with respect to theparameters of the task invocations which execute in thisbusy period undergoes the following steps:

Step 1, minimizing U� w.r.t. L. For each acyclic taski, 1 � i � n, consider the invocation Ti that arrives lastwithin the busy period B � t < An þDn. Let theutilization of this invocation be Ui ¼ Ci=Di. Since Ti

is the last invocation, its deadline, by definition, is noearlier than An þDn. Let the sum of execution times of

all invocations in ½B;An þDn� that precede Ti in acyclictask i be CPi

. Since, by Property 2, the utilization isconstant in the interval B � t < An þDn, it must be thatX

1�i�n

CPi¼X1�i�n

ðAi �An þ LÞCi=Di:

Since the length of the interval is Dn þ L, the sum of the

execution times within that interval must amount to

Dn þ L, i.e.:

Cn þXni¼1

ðAi �An þ LÞ Ci

DiþXn�1

i¼1

ðCi � viÞ ¼ Dn þ L; ð2Þ

where vi (which stands for overflow) is the amount of

computation time of task invocation Ti that occurs after

the deadline of task invocation Tn. Let v ¼P

1�i�n�1 vi.

Equation (2) can be rewritten as:

Cn ¼ Dn þ Lð1� U�Þ �Xn�1

i¼1

ðAi �AnÞCi

Di�Xn�1

i¼1

Ci þ v: ð3Þ

From (3), Cn (and, hence, the utilization) is minimum

when L ¼ 0. This implies that, in the worst-case

invocation pattern, Tn arrives at the end of an idle

period, i.e., B ¼ An (see Fig. 4). We call this Property 3.

Substituting for Cn in U� ¼P

1�i�n Ci=Di, then setting

L ¼ 0, the minimum utilization is given by:

U� ¼Xn�1

i¼1

Ci

Diþ 1� 1

Dn

Xn�1

i¼1

ðAi �AnÞCi

Di�Xn�1

i¼1

Ci

Dnþ v

Dn: ð4Þ

Step 2, minimizing U� w.r.t. Ci. Consider the busyperiod B � t < An þDn, where L ¼ 0 (i.e., B ¼ An). ByProperty 1, during this period, Tn is the lowest priorityinvocation. Let us minimize U� with respect to thecomputation times of task invocations fT1; . . . ; Tn�1g,where Tk is the last invocation of the acyclic task k in thisbusy period. Let the latest completion time of aninvocation in this set be Elast. Let Sk be the start time ofsome invocation Tk. We consider only invocations, Tk,with nonzero execution times since zero-execution-timeinvocations do not alter utilization. To minimize U� withrespect to the computation times of these task invoca-tions, we shall inspect the derivative dU�=dAk. Threecases arise:

1. Tk arrives while a task invocation of higher priority is

running: In this case, Tk is blocked upon arrival.

Advancing the arrival time Ak by an arbitrarily

small amount does not change its start time (and,

therefore, does not change the start or finish time

of any other task invocation). Consequently, v

remains constant and dv=dAk ¼ 0. Thus, from (4),

dU�=dAk ¼ � 1Dn

ðCk

DkÞ. This quantity is negative,

indicating that U� can be decreased by increasing

the arrival time Ak.2. Tk arrives while a task invocation of lower priority is

running: In this case, Tk preempts the executingtask invocation upon arrival. Advancing thearrival time Ak by an arbitrarily small amount


reorders execution fragments of the two invoca-tions without changing their combined comple-tion time. Consequently, v remains constant, anddv=dAk ¼ 0. Thus, from (4), dU�=dAk ¼ � 1

DnðCk

DkÞ.

This quantity is negative indicating that U� can bedecreased by increasing the arrival time Ak.

3. Tk arrives while no task invocation is running: Inother words, it arrives at or after the completiontime of the previously running task invocation.Let us define a contiguous period as a period ofcontiguous CPU execution of invocationsT1; . . . ; Tn�1. The execution of these invocationsforms one or more such contiguous periods. Twocases arise:

a. Tk is not in the contiguous period that ends at

Elast: Advancing Ak will not change v. Thus,

dv=dAk ¼ 0, and dU�=dAk ¼ � 1Dn

ðCk

DkÞ. This

quantity is negative, indicating that U� can be

decreased by increasing the arrival time Ak.b. Tk is in the contiguous period that ends at

Elast. Three cases arise: i) Elast > Dn: In thiscase, v > 0. Since no other task invocationswere running when Tk arrived, advancing thearrival time of Tk will shift the last contiguousperiod and increase v by the same amount. Itfollows that dv=dAk ¼ 1. Thus, from (4),dU�=dAk ¼ 1

Dnð1� Ck

DkÞ. This quantity is posi-

tive, indicating that U� can be decreased bydecreasing Ak. ii) Elast < Dn: In this case,v ¼ 0. dU�=dAk ¼ � 1

DnðCk

DkÞ. This quantity is

negative, indicating that U� can be decreasedby increasing the arrival time Ak. iii)Elast ¼ Dn: From i) and ii) above, it can beseen that

limElast!DþndU�=dAk 6¼ limElast!D�

ndU�=dAk:

Thus, the derivative dU�=dAk is not defined atElast ¼ Dn. From the signs of the derivative ini) and ii), it can be seen that U� has aminimum at Elast ¼ Dn.

From the above, U� can be decreased in all cases exceptcase 3.b.iii, where a minimum occurs. Since the abovecases exhaust all possibilities and 3.b.iii is the onlyminimum, it must be a global minimum. In this case,each task invocation Tk arrives while no task invocationis running (by definition of case 3) and contributes to acontiguous period that ends at Elast (by definition ofsubcase b, where Elast ¼ Dn (by definition of subcase iii).In other words, each task invocation arrives exactly at thecompletion time of the previous task invocation (for theperiod to be contiguous) with the completion of the lastinvocation being Dn. For simplicity, let us renumberinvocations T1; . . . ; Tn�1 in order of their arrival times. Itfollows that U� is minimized when Ci ¼ Aiþ1 �Ai, 1 �i � n� 2 and Cn�1 ¼ Dn �An�1 as depicted in Fig. 5.

Let T ¼ A1 �An. Since v ¼ 0 at the global minimum,from (3), Cn ¼ Dn �

P1�i�n�1fCi þ ðAi �AnÞCi=Dig,

where Ai �An ¼ T þP

1�j�i�1 Cj. Substituting forAi �An, we get the expression:

Cn ¼ T 1�Xn�1

i¼1

Ci

Di

!�Xn�1

i¼2

Ci

Di

Xi�1

j¼1

Cj

!: ð5Þ

Substituting in the expression U� ¼P

i Ci=Di, we get:

U� ¼ T

Dnþ 1� T

Dn

� �Xn�1

i¼1

Ci

Di�Xn�1

i¼2

Ci

Di

Xi�1

j¼1

Cj

Dn

!: ð6Þ

Step 3, minimizing U� w.r.t. Di: The utilizationin (6) decreases when D1; . . . ; Dn�1 increase. SinceTn is the lowest priority invocation, the deadlinemonotonic scheduling policy upper-bounds thesedeadlines by Dn. Hence, in a worst-case pattern,D1 ¼ D2 ¼ . . . ¼ Dn�1 ¼ Dn. Equation (6) can be signifi-cantly simplified in this case. The resulting utilization isgiven by:

U� ¼ 1�TPn�1

i¼1 Ci þPn�1

i¼2 ðCi

Pi�1j¼1 CjÞ

ðT þPn�1

i¼1 CiÞ2: ð7Þ

The corresponding computation time of Tn is given by:

Cn ¼ T �TPn�1

i¼1 Ci þPn�1

i¼2 ðCi

Pi�1j¼1 CjÞ

ðT þPn�1

i¼1 CiÞ: ð8Þ

Step 4, minimizing U� w.r.t. T : Since arrivaltimes of invocations T1; . . . ; Tn�1 are spaced by theirrespective computation times, as found in Step 2,to obtain the condition for minimum utilization, itis enough to minimize U� with respect to T subjectto the constraint Cn > 0. To do so, we first setdU�=dT ¼ 0. Setting the derivative of (7) to zero,we get T ¼

P1�i�n�1 C

2i =P

1�i�n�1 Ci. Substituting thisvalue in (7) and simplifying, we get:

U� ¼ 1

2þ 1=2

1þ ðPn�1

i¼1 CiÞ2=Pn�1

i¼1 C2i

: ð9Þ

The quantity

ðP

1�i�n�1 CiÞ2P1�i�n�1 C

2i

in thedenominator in (9) isupperboundedbyn� 1,which

corresponds to the case where the computation times are

equal, i.e., when Ci ¼ C, 1 � i � n� 1. Consequently, the


Fig. 5. The contiguous period.

lower bound on the utilization of a critically schedulable

acyclic task set is U� ¼ 12 þ 1

2n . From (8), we see that,

under these conditions, Cn ¼ Cð1� n�12 Þ. Thus, for Cn to

be positive, n < 3. Consequently:

U� ¼ 1

2þ 1

2n; n < 3: ð10Þ

When n � 3, the aforementioned bound does not satisfy

the constraint Cn > 0. Instead, Fig. 6 illustrates the

minimum utilization condition. The figure plots the

relation between T and U� given by (7), illustrating the

point of minimum utilization as well as the constraint

Cn > 0. Since Cn increases monotonically with T , it is

obvious from Fig. 6 that the point of minimum utilization

subject to the constraint Cn > 0 is obtained at the value of

T that makes Cn ¼ 0. Setting Cn ¼ 0 in (8), we get

T ¼ffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiPn�1

i¼2 ðCi

Pi�1j¼1 CjÞ

q. Substituting in (7), we even-

tually get:

U� ¼ 1

1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi12 1�

Pn�1

i¼1C2i

ðPn�1

i¼1CiÞ2

� �s : ð11Þ

As before, the minimum utilization is obtained when

computation times are equal, in which case:

U� ¼ 1

1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi12 ð1� 1

n�1Þq ; n � 3: ð12Þ

From (10) and (12), the theorem is proven. tu

The presented bound is tight in the sense that the

utilization of an actual critically schedulable task pattern

can be arbitrarily close to the bound. In the following, we

describe a critically schedulable task pattern whose utiliza-

tion approaches infinitesimally the computed bound for a

large n. Let Tn have an infinitesimally small execution time.

In this example, Tn is blocked throughout the entire interval

between its arrival time and deadline by invocations of n�1 acyclic tasks. Each task consists of two invocations of

equal utilization. The first of these arrives together with Tn,say at t ¼ 0. The second has an arrival time

ðj� 1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiðn� 1Þðn� 2Þ

p2

ÞC;

a computation time C, and a relative deadline

D ¼ ðn� 1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiðn� 1Þðn� 2Þ

p2

ÞC:

This implies that the first invocation in task j has acomputation time

j� 1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiðn� 1Þðn� 2Þ=2

pn� 1þ

ffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiðn� 1Þðn� 2Þ=2

p C

and a relative deadline

j� 1þffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiðn� 1Þðn� 2Þ

p2

!C:

This worst case task pattern is shown in Fig. 7. Using simplealgebra, it is easy to see that the utilization of this pattern isequal to the bound and that Tn has zero slack. Hence, thebound is tight.

Theorem 2. Deadline monotonic scheduling is an optimal time-independent scheduling policy in the sense of maximizing theutilization bound.

Proof. Let Ux be the utilization bound of scheduling policyX. Let Udm be the utilization bound for deadlinemonotonic scheduling, derived above. Consider someutilization value U , where U > Udm. We shall first showthat Ux < U .

To show that U is above the schedulability bound ofpolicy X, it is enough to demonstrate a single task set ofmaximum utilization U that is unschedulable bypolicy X. Let us begin by constructing a task invocationpattern (whose maximum utilization is U) that isunschedulable by deadline monotonic. This shouldalways be possible since U > Udm. Let the task invocationthat misses its deadline in this pattern be called TA. Dueto Property 1, without loss of generality, let TA be thelowest priority invocation under deadline monotonicscheduling. Unless policy X is equivalent to deadlinemonotonic scheduling, let there be some task invocationTB 6¼ TA such that TB is the lowest priority task


Fig. 6. The minimum utilization condition.

Fig. 7. The worst-case task pattern.

invocation under policyX. Since invocation priorities areindependent of invocation arrival times, without loss ofgenerality, let TB be an invocation that arrives togetherwith TA. Let us schedule this task set by policy X. Thecompletion of the busy period will remain the same.However, the last invocation to finish is now TB insteadof TA. Since TB has a higher priority than TA usingdeadline monotonic scheduling, it must be that it has ashorter deadline. Hence, task invocation TB will beunschedulable under policy X. Consequently, it must bethat Ux < U . Taking the limit, limU!Udm

, it follows thatUx � Udm for any scheduling policy X. tu

Corollary 1. The optimal utilization bound of time-independentscheduling of aperiodic tasks is 1


p .

This corollary follows directly from Theorem 1 andTheorem 2, combined with the fact that the asymptoticutilization bound for aperiodic tasks is equal to that ofacyclic tasks as shown in Section 2.

Corollary 2. A set of periodic tasks (with periods larger thandeadlines) is schedulable by the deadline monotonic schedulingpolicy if UðtÞ � 1


p .

While we do not intend this paper to be an analysis ofperiodic tasks, we notice that the optimal utilization boundderived for aperiodic tasks under deadline-monotonicscheduling also applies to deadline-monotonic schedulingof periodic tasks with deadlines less than periods.5 This istrue for the following two reasons:

. Periodicity is a constraint on the set of possibleinvocation arrival patterns. This constraint reducesthe number of arrival patterns that are permitted,but does not offer any new ways a task set canbecome unschedulable. Thus, the schedulable utili-zation bound for periodic tasks cannot be lower thanthat for aperiodic tasks.

. For each unschedulable arrival pattern of aperiodictask invocations that make up a busy interval, onecan construct an identical pattern of periodic taskinvocations with the same execution times anddeadlines and whose periods are sufficiently largesuch that only one invocation of each task appears inthe busy interval. Since the two patterns areindistinguishable in terms of both utilization andschedulability status, the schedulable utilizationbound for periodic tasks cannot be higher than thatfor aperiodic tasks.

Putting the above two observations together, we concludethat the utilization bound for deadline monotonic schedul-ing of aperiodic tasks is equal to that of periodic tasks inwhich deadlines are less than periods.

4 DYNAMIC PRIORITY SCHEDULING

For completeness, in this section, we consider dynamic-priority scheduling. It is easy to show that EDF is the optimaldynamic priority scheduling algorithm for aperiodic tasks

and that the optimal utilization bound for dynamic priorityscheduling is 1. To see that, consider a hypotheticalprocessor capable of generalized processor sharing. Theprocessor assigns each task Ti (of execution time Ci anddeadline Di) a processor share equal to Ci=Di. All currenttasks execute concurrently. Each task will terminate exactlyat its deadline. The maximum schedulable utilization of thisprocessor is trivially U ¼ 1. One can imagine that such aprocessor, in effect, schedules current tasks in a round-robinfashion, assigning each an infinitesimally small time slicethat is proportional to its share, Ci=Di. We shall show thatthis round-robin schedule can be converted into an EDFschedule without causing any task to miss its deadline.

Let us scan the round-robin schedule from its beginningto its end. At every time t, let us choose among all currenttasks the one with the earliest deadline, say Tj, andconsolidate its round-robin slices scheduled in the interval½Aj; t�. Consolidation is effected by shifting these slicestoward the task’s arrival time, displacing slices of tasks thathave not been consolidated. Since we are merely switchingthe order of execution of task slices within an interval thatends at t, no slice is displaced beyond t. Since task Tj wascurrent at time t, it must be that t � Aj þDj (the absolutedeadline of Tj). Thus, no slice is displaced beyond Tj’sdeadline. However, since Tj is the task with the shortestdeadlineamongall current tasks at time t, no slice isdisplacedbeyond its task’s deadline. The resulting schedule after thescan is EDF. Thus, EDF has the same utilization bound asgeneralizedprocessor sharing. Inotherwords, itwill causenoaperiodic deadline misses as long utilization is less than 1.This result is similar to the case of sporadic tasks.

5 EXPERIMENTAL EVALUATION

Perhaps the most important result of this paper is not that autilization bound exists for aperiodic tasks but that it ishighly efficient in maximizing the number of admittedtasks. In fact, as we show in this section, the measuredutilization can approach 100 percent in a highly loadedsystem even when the synthetic utilization is kept below thebound. To appreciate this somewhat unintuitive observa-tion, consider the schedule shown in Fig. 8.

The above schedule depicts four acyclic tasks, eachcomposed of multiple invocations delimited by vertical barsin the figure (note that some invocations have a zeroexecution time). The contribution of each invocation tosynthetic utilization is shown in the figure. At the bottom, atimeline is shown demonstrating the idle and busy intervalsof the processor. It is easily seen from that timeline that themeasured utilization approaches 100 percent. However, theaggregate synthetic utilization in this example neverexceeds 75 percent. For example, at time t0, only invocationsof tasks 3 and 4 contribute to synthetic utilization, totaling75 percent. In particular, the current invocation of task 1 isnot counted toward synthetic utilization at t0 because itsarrival precedes a schedule gap. The luxury of being able touse schedule gaps for resetting synthetic utilization is notavailable in offline analysis of periodic tasks. Hence, theencouraging results presented in this section regarding theperformance of our utilization-based admission control areunique to aperiodic task scheduling. No corresponding


5. We would like to acknowledge Professor Lui Sha for pointing thisobservation out to us.

result is possible in utilization-based schedulability analysisof periodic tasks.

5.1 Measured Utilization of Conforming Task Sets

Let a conforming set of aperiodic tasks be one in which thesynthetic utilization never exceeds the bound, i.e., is below58.6 percent. This property is enforced by an admissioncontroller which rejects all invocations that would cause thebound to be violated. (Since tasks are aperiodic, theword taskand invocation are used interchangeably.)Howpessimistic issuch an admission control policy in terms of the number oftasks admitted compared the number of tasks that couldhavemade their deadlines? To answer this question, we used asimulator which can generate aperiodic tasks with Poissonarrivals, exponentially distributed execution times, anduniformly distributed deadlines. The simulator implementsa deadline-monotonic scheduler and an optional admissioncontroller. An aperiodic task is discarded by the simulator assoon as its remaining computation time exceeds the remain-ing time until its deadline.

When admission control is used, an incoming arrival islet into the system only if it does not cause the syntheticutilization bound to be exceeded. This eliminates deadlinemisses at the expense of rejecting a fraction of arrivals. It isassumed that the computation time and deadline of thearrived tasks are known upon arrival. For example, in aWeb server, the name of the requested URL can be used tolook up the length of the requested page and, hence,estimate the service time of the request. The admissioncontroller resets the synthetic utilization to zero once theprocessor becomes idle.

Fig. 9 shows the measured CPU utilization and thepercentage of tasks that make their deadlines (called successratio) with and without admission control. The horizontalaxis shows the generated incoming loadwhich is varied from50 percent to 140 percent of total CPU capacity. This load isdefined as the sum of computation times of all arrived tasksover the time interval during which they arrived.

Each point on each curve in the figure is the average of10 experiments, each carried out for a sufficiently long time(33; 000 task arrivals). Hence, the utilization and success

ratio at each point are averaged over more than 3 milliontask arrivals, which gives a sufficiently tight confidenceinterval in the results. We opted for multiple experimentsper point (instead of a single long experiment) to guardagainst bias for a particular random number generator seed.The seed was varied across different experiments, and eachexperiment was repeated using the same seed with andwithout admission control to provide a common-groundcomparison of the two cases.

Note that, without admission control, the complement ofthe success ratio shown in Fig. 9 represents the fraction oftasks which miss their deadlines. With admission control,on the other hand, no deadline misses were observed. Thecomplement of the success ratio in this case represents thefraction of rejected tasks. An interesting metric for evaluat-ing admission control schemes is efficiency. We defineefficiency as the number of tasks admitted using theadmission control scheme divided by the number of tasksthat meet their deadlines under the same scheduling policyif no admission control is used.6 An overly pessimisticadmission control heuristic will reject more tasks thanneeded, causing the efficiency to decrease. Fig. 10 shows(from the data in Fig. 9) the efficiency of our utilization-based admission control and deadline-monotonic schedul-ing of aperiodic tasks versus input load when the utilizationbound is 58.6 percent, as derived in Section 3.4. It can beseen that the efficiency is 100 percent at low load. Theefficiency dips slightly, reaching a minimum when theincoming load would fully utilize the processor, thenimproves when the processor is overloaded. Surprisingly,at no time does the efficiency dip below 95 percent, which isa very encouraging result. The trends in Fig. 9 and Fig. 10are explained below.

At low loads, as expected, admission control does notalter utilization. All tasks are let into the system and allmeet their deadlines whether admission control is used ornot. Hence, efficiency is 100 percent. As the load increases,deadlines are missed in the absence of admission control. Incomparison, the presence of admission control causes a


Fig. 8. Synthetic utilization.

6. Note that this is different from comparing to an optimal admissioncontrol policy.

Fig. 9. The measured utilization.

slightly larger fraction of tasks to be rejected. Hence,efficiency decreases. Presumably, task rejection is moretolerable than deadline misses, making the slight decreasein efficiency acceptable. The trend continues until theprocessor is fully loaded, i.e., until the incoming load is100 percent of capacity.

Interestingly, beyond this point, as the processor getsoverloaded, admission control becomes progressively moreefficient. In fact, for loads above 113 percent efficiencyexceeds 100 percent. Thus, admission control rejects fewertasks than the number that would miss their deadlinesotherwise. This behavior occurs despite the fact that, in theabsence of admission control, tasks which miss theirdeadlines are not allowed to continue. The explanation ofthis behavior is twofold. First, in the absence of admissioncontrol (which performs the utilization-based schedulabilitytest) it is impossible to know a priori whether or not anexecuting task will meet its deadline. An initially schedul-able task can always get preempted by a higher priority onewhich arrives later, causing the deadline of the former to bemissed. Some portion of CPU capacity is thus unavoidablywasted on tasks that end up discarded causing anadmission-control-based scheme to be more efficient. Toverify this conjecture, Fig. 11 compares the utilization due totasks which meet their deadlines only (called effectiveutilization) in the cases with and without admission control.Indeed, the effective utilization with admission controlexceeds that without admission control when the loadincreases above 123 percent.

However, since Fig. 10 indicates that admission controlbecomes more efficient at loads above 113 percent (i.e., atloads even smaller than 123 percent), a second factor mustbe affecting efficiency. This factor is that, when theprocessor is overloaded, admission control favors lightertasks (which would have a higher probability of beingadmitted). This bias tends to increase throughput in asimilar manner as a shortest-job-first policy does and,hence, increases success ratio for the same utilization. Thisconjecture was verified by plotting the ratio of the averageadmitted task size (where task size is defined as Ci=Di) tothe average incoming task size for those experiments shown

in Fig. 9 in which admission control was used. The result isshown in Fig. 12. As expected, this ratio declines as the loadincreases, i.e., admission control favors smaller tasks. Withthe increase in the number of arrivals, admission control isincreasingly more successful at finding smaller tasks.Hence, the effect becomes more pronounced.

The net result is that not only does utilization-basedadmission control eliminate deadline misses, but it alsoincreases the number of successful tasks.While the particularnumbers presented in the figures above would changedepending on the load generation process, the qualitativetrends and the factors affecting themhold true in general andindicate very good performance of utilization-based admis-sion control of aperiodic tasks, even under fixed priorityscheduling. Results for EDF will obviously be better. In thefollowing, we conduct a more detailed simulation studyevaluating both deadline monotonic and EDF bounds andcomparing the performance to other policies.

The primary variables for the simulations are theinterarrival distribution and the computation time distribu-tion. The average processor utilization is the ratio of the


Fig. 10. Efficiency of admission control. Fig. 11. Effective utilization.

Fig. 12. Overload and bias for smaller tasks.

arrival rate to service rate. Relative deadlines are chosenrandomly from a discrete uniform distribution in which themaximum deadline is 9 times the minimum deadline. Thesimulation was carried out for a duration of 100 times theaverage deadline value.

5.2 Comparison with Perfect Admission Control

Perfect admission control is defined as an admission controlscheme inwhichwealways admit a task if andonly if it canbescheduled. Such a control policy can be implemented asfollows: Whenever a task arrives, the delay for the newlyarrived task is calculated by summing up the computationtimes of the current higher priority tasks. If the delay plus thecomputation time requirement of the new task is less than thetask’s deadline, the new task is schedulable. The algorithmthen checks that the tasks behind the new task in the priorityqueue remain schedulable as well. If so, the new task isadmitted. The perfect admission control algorithm can beimplemented in linear time. It serves as a good benchmark tocompare to our admission control approach. Perfect admis-sion control would provide the maximum achievableperformance if we disregard the implementation overhead.

Figs. 13 and 14 compare the aperiodic bound-basedadmission control against the perfect admission control forexponential interarrival and computation times. The sche-duling policy used is Deadline Monotonic and EDF, respec-tively. One could conclude that utilization-basedadmission control compares well with perfect admissioncontrol. We lose no more than 5 percent of schedulabilitycompared to the perfect (globally optimal) algorithm.From Fig. 14, observe that, unlike the case with periodictasks, admission control based on the EDF bound is notglobally optimal. This is because some schedulable arrivalpatterns may cause synthetic utilization to temporarilyexceed unity.

An important consideration concerns the implementa-tion overhead of the admission control scheme. Table 1shows the time taken by simulations (in secs) carried out fora length of 10,000,000 time units. The load was 100 percentand the average granularities (defined as the ratio ofaverage computation time to average deadline of the tasks)were as shown in the table. When the average granularity of

the workload is small, the queue sizes are long and theperfect admission control scheme takes a long time as thealgorithm is linear in the number of tasks. For theutilization-based approach, the impact of the increase inthe number of tasks is not as severe. The increase in theduration of the simulation in both cases is due to theincrease in the total number of tasks that arrive. Theincrease is higher for perfect admission control because ofits higher complexity, lending credibility to the claim thatthe synthetic utilization-based approach is desirable. Thebetter performance of the synthetic utilization-based ap-proach also suggests its suitability to networks and highperformance Web servers where the delays are primarily inthe queue and the granularities are very small; precisely thecase in which the advantage of the approach is observed.

5.3 Granularity of Tasks

Granularity of tasks refers to the size of a task (itscomputation requirement) as compared to its deadline. Inthis experiment, granularity is formally defined as the ratioof average computation time to average deadline of theworkload.

It is interesting to study the real utilization of a resourcein the presence of our admission control heuristic as thegranularity of tasks is varied. Figs. 15 and 16 show the effectof increasing granularity for Deadline Monotonic and EDF,respectively. One can see that our admission control schemeperforms better at smaller task granularities. This isbecause, at smaller granularities, it is less likely to admitindividual tasks with high synthetic utilization that makemany other tasks inadmissible. This result is encouragingsince our target is high-performance servers that canprocess thousands of requests concurrently (i.e., whereindividual task granularity is very small).


Fig. 13. Perfect admission control (DM). Fig. 14. Perfect admission (EDF).

TABLE 1Duration of Simulations (in Seconds)

5.4 Aperiodic and Periodic Tasks

Since periodic tasks can be broken down into aperiodictasks, the aperiodic utilization bound is applicable to thecase of mixed workloads with periodic and aperiodic tasks.In this section, we consider periodic tasks whose deadline isequal to their period. Observe that, since at most one suchinvocation can be present at any given time from eachperiodic task, the synthetic utilization attributed to periodictasks is upper bounded by

Pi2periodic Ci=Di, which is their

utilization factor. Hence, it is possible to simply “allocate”that much synthetic utilization to periodic tasks andsubtract it from the utilization bound for aperiodics. Letus call the difference Udiff . Observe that the aboveallocation ensures that periodic tasks always meet theirdeadlines.

The admission controller keeps track of the syntheticutilization of aperiodic tasks alone. As before, the syntheticutilization counter is reset to zero when the processor is idle(i.e., is not running any periodic or aperiodic tasks). If thecounter ever reaches Udiff , no further aperiodic tasks can beadmitted. This ensures that aperiodic tasks never infringeon the capacity allocation made for periodic ones. Schedul-ing is done as for the aperiodic case. No separate strategy isrequired for periodic tasks.

Figs. 17 and 18 show the real utilization at the resourcewhen different percentages of the workload are composedof periodic tasks. The distribution used for interarrival andcomputation times is exponential. The input utilization ofperiodic tasks is varied from 0 to the maximum possibleutilization in steps of 10 percent. The aperiodic workload isthe same. In the case of deadline monotonic scheduling,Fig. 17 shows that, initially, real utilization remains high asaperiodic tasks are replaced by periodic tasks. However, asthe percentage of periodic tasks increases to values close tothe utilization bound, fewer aperiodic tasks can get throughand the real utilization approaches the reservation made toperiodic tasks. Eventually the entire 58.6 percent (the valueof the bound) is allocated to periodic tasks. No aperiodictasks are allowed. The real utilization, in this case, is equalto the synthetic utilization bound. In the case of EDFscheduling, Fig. 18 shows that the utilization remains closeto 100 percent, which is the value of the EDF bound. Weconclude that, for workloads with a moderate fraction ofperiodic tasks, both time-independent and dynamic-prior-ity bounds perform well in terms of keeping the processorutilized. If the number of periodic tasks is large, EDF isrecommended.


Fig. 15. Task granularity (DM).

Fig. 16. Task granularity (EDF).

Fig. 17. Mixed workload (DM).

Fig. 18. Mixed workload (EDF).

5.5 Comparison with Real-Time Queuing Theory

Real-Time Queuing Theory was proposed in [15] toincorporate real-time constraints in queuing system analy-sis. In [16], admission control techniques were proposed touse results from real-time queuing theory to control latenessof tasks. The theory enables one to provide probabilisticguarantees on the lateness of tasks. These techniques sharesimilar concerns as that of synthetic utilization-basedadmission control and are suitable for aperiodic systems.Some typical results comparing the two approaches arepresented below.

The admission control scheme based on real-time queuingtheory is mentioned here in brief for convenience. Details onthe scheme can be found in [16]. As of now, approaches basedon Real-Time Queuing Theory have been proposed only forthe EDF scheduling policy. Hence, the experiments to followshall compare the bound for EDF only.

The admission controller ensures that Nqueue �Threshold

Mean Computation Time where, Nqueue is the number of tasks inthe queue. According to Real-Time Queuing Theory, thereis a high probability of all tasks making their deadlines ifthe total computation time of the tasks in the system (alsoreferred to as the total workload) is less than a threshold. In[16], ways are proposed to choose the threshold such thatthe probability of deadline misses is low. The probability isa function of the threshold. Assuming that the deadlinedistribution of the task set is known, the optimal thresholdis known to be close to the mean deadline [16]. In ourexperiments, the mean deadline was 10,000ms. However,the mean deadline is a rough estimate in practice in the caseof aperiodic tasks since it depends on which tasks willarrive. It is suggested that thresholds slightly lower than themean deadline should lead to low probability of deadlinemisses of tasks admitted.

Fig. 19 shows the useful utilization for the utilization-based approach and the real-time queuing theory-basedapproach for different threshold values. Useful utilization isdefined as the real processor utilization due to the tasks thatmeet their deadlines. For the utilization-based approach, alltasks that are admitted meet their deadlines; however, forthe queuing theory-based approach, some tasks can fail tomeet their deadlines. Hence, the metric of importance is the

utilization of tasks which meet their deadlines or the usefulutilization. Fig. 20 shows the percentage of admitted tasks.As expected, the performance of real-time queuing theory isdependent on the threshold and, for thresholds lower thanthe mean deadline (in this workload, the mean deadline is10,000), the useful utilization is close to 100 percent.

It can be observed that, for the thresholds for which real-time queuing theory-based admission control does well, thepercentage of admitted tasks is close to that for syntheticutilization-based admission control. However, for loadsaround 100 percent, real-time queuing theory has beenobserved to perform better than synthetic utilizationconsistently. This is to be expected as the queuing theory-based approach calculates the optimal threshold and missprobabilities using workload parameters and, hence, isbetter informed than the synthetic utilization-based ap-proach. It is also a probabilistic framework that does notprovide deterministic guarantees and is therefore morepermissive in its admission control. The utilization-basedapproach is competitive with real-time queuing theory,despite the fact that it must deterministically guaranteedeadlines and that it does not assume any knowledge ofworkload parameters.

6 RELATED WORK

The study of utilization bounds for schedulability of real-time tasks has been an active research topic in real-timecomputing since the publication of the first such bound byLiu and Layland [18] in 1973. Utilization bounds are themost efficient form of schedulability analysis in terms ofcomputational complexity. Unfortunately, to date, thisvaluable tool was confined only to task models withperiodicity constraints. The development of bounds derivedfor aperiodic tasks will enable applying this efficientanalysis to a myriad of new applications in which work-loads are random and do not have periodic behavior onshort scales.

The basic utilization bound [18] states that a set ofn independent periodic tasks on a uniprocessor will meettheir deadlines if utilization is kept below nð21=n � 1Þ, whichconverges to 69 percent as n increases. The bound presents


Fig. 19. Useful system utilization. Fig. 20. Percentage of admitted tasks.

a sufficient (but not necessary) schedulability condition. Thelogic of the original derivation of this result has been fine-tuned in [6]. In [11], it is shown that, if the values of taskperiods form K harmonic chains, where K < n, then thebound can be increased to Kð21=K � 1Þ. In [4], the bound isfurther improved by considering more information aboutthe task set such as the actual values of task periods. In [26],a design-time technique is described for computing theruntime bound when only periods (but not the executiontimes) are known a priori. The exact task execution timesare plugged-in when the tasks arrive. In [9], task admissi-bility is improved using a polynomial-time admissioncontrol algorithm instead of the utilization bound. Theexact characterization of the ability of rate-monotonicscheduling to meet deadlines of periodic tasks is presentedin [13]. This characterization derives both sufficient andnecessary conditions for schedulability of periodic tasks. Afault tolerance extension was presented in [25], whoseauthors consider the overhead of failure recovery from asingle fault. The authors prove that each task is recoverableunder rate-monotonic scheduling (i.e., the backup replicawill complete by the original deadline) if the utilization ofthe original task set is less than 0:5. This is less pessimisticthan the trivial bound of 0:69=2 (which trivially allows forany task to execute twice). A utilization bound for amodified rate-monotonic algorithm which allows deferreddeadlines is considered in [28].

The basic utilization-based schedulability test has alsobeen extended to the multiframe periodic task model inwhich successive invocations of a task alternate amongmultiple frames with different execution times [22]. Im-provements of the basic multiframe schedulability test areproposed in [8].

Utilization bounds for multiprocessors have receivedrecent attention. In [38], the authors consider different taskpartitioning heuristics among processors and evaluate theirimpacts on schedulable utilization. The authors of [24]derive the worst-case achievable utilization of a criticallyschedulable task set using rate-monotonic scheduling on apartitioned multiprocessor. The authors of [19] derive amultiprocessor utilization bound for EDF scheduling. Theirbound is shown to be 0:5ðnþ 1Þ, where n is the number ofprocessors. A less pessimistic (but more computationallyinvolved) schedulability test is proposed in [12].

The above research efforts generally share in commonthe assumption that the task set is known a priori and thattasks are periodic (or have a minimum interarrival time).The concept of dynamic real-time systems [31], pioneered bythe Spring kernel project [32], [33], introduced a paradigmshift in task model assumptions. It focused on applicationswhere runtime workload parameters (such as the task setand its characteristics) are unknown until admission controltime. The new model resulted in innovative planning-basedscheduling algorithms that provide online schedulabilityanalysis and online guarantees for dynamically arrivingtasks [34], [40], [39], [30], [27], [23], [10]. Unfortunately, inthis task model, utilization bounds could no longer be usedsince task arrivals were, in general, aperiodic.

Aperiodic tasks were handled in previous literature inone of two ways. The first approach requires creation of a

high-priority periodic server task for servicing aperiodicrequests. Examples include the sporadic server [29], thedeferrable server [36], and their variations [17]. Theapproach bounds the total load imposed on the system byaperiodic tasks allowing critical periodic tasks to meet theirdeadlines. It usually assumes that aperiodic tasks are softand attempts to improve their responsiveness rather thatguarantee their deadlines. The second approach typicallyrelies on algorithms for joint scheduling of both hardperiodic and aperiodic tasks. It uses a polynomial accep-tance test upon the arrival of each aperiodic task todetermine whether or not it can meet its deadline. Examplesinclude aperiodic response-time minimization [14], slackmaximization [5], slack stealing [37], the reservation-based(RB) algorithm [3], and the guarantee routines introducedmost notably in the Spring kernel [33].

Real-Time Queuing Theory ([15]) is an approach whichwas designed to handle aperiodic task systems by in-corporating deadline constraints in standard queuingmodels. In [16], admission control strategies were discussedto control the lateness of tasks in aperiodic systems. As wehave seen, although real-time queuing theory is an effectivestrategy, it requires knowledge of mean deadlines and otherworkload parameters to calculate the blocking threshold.

The utilization bound described in this paper is the firstconstant-time test that enables us to efficiently determinethe schedulability of aperiodic workloads. A preliminaryversion of the results presented here appeared in aconference publication [1]. Future research in aperiodictask scheduling may include extensions of the basic boundthat use more information about the task set (e.g., knowl-edge of specific values of deadlines, specific constraints ontask arrival patterns, specific bounds on individual execu-tion times), consider multiple resources, blocking, etc., orexplore multiprocessor scheduling.

From the perspective of QoS enforcement, feedback-based mechanisms can be used to maintain the utilizationwithin schedulable limits (e.g., using admission control). Ina separate effort [20], [2], the authors developed a feedbackcontrol architecture for maintaining the utilization belowthe bound using control-theoretical techniques. The use offeedback control theory to enforce QoS constraints seems tobe gaining popularity as a particularly robust approach inthe presence of uncertainty. For example, [35] develops amechanism for feedback control of operating system queuesto maintain smooth performance of pipelined applications.In [7], an algorithm is described for feedback control ofLotus Notes servers. A similar approach is applied in [21] toa Web proxy cache. Utilization bounds can serve as load setpoints in server performance control loops to guaranteemeeting individual request deadlines.

7 CONCLUSIONS

In this paper, we derived, for the first time, the optimalutilization bound for the schedulability of aperiodic tasksunder time-independent scheduling and under dynamicscheduling policies. The bound results in an Oð1Þ admissiontest of incoming tasks, which is faster than the polynomialtests proposed in earlier literature. We also showed thatdeadline monotonic scheduling is an optimal policy in the


sense of maximizing the schedulable utilization bound. Thisresult may be the first step toward an aperiodic deadlinemonotonic scheduling theory—an analog of rate monotonicscheduling theory for the case aperiodic tasks. Such a theorymay prove to be of significant importance to many real-timeapplications such as real-time database transactions, onlinetrading servers, and guaranteed-delay packet schedulingalgorithms. In such applications, aperiodic arrivals havedeadline requirements and their schedulability must bemaintained. More importantly, by making a distinctionbetween synthetic and measured utilization, we haveshown that the bound can be enforced on the formerwithout considerably affecting the latter. Hence, unlike thecase with periodic tasks, aperiodic utilization-based admis-sion control does not underutilize the processor.

While we limited this paper to the first fundamentalresult, our investigation is by no means complete. Exten-sions of the theory are needed to the case of dependenttasks, multiple resource requirements, precedence andexclusion constraints, nonpreemptive execution, and othertask dependencies in a multiresource environment. Finally,to make the results more usable, it is important toinvestigate methods for aggregate utilization control thatwould maintain the utilization below the schedulabilitybound. Statistical properties of the task arrival process canbe combined with mathematical analysis of feedbackcontrol loops to derive probabilistic guarantees on meetingtask deadlines. This avenue is currently being pursued bythe authors.

ACKNOWLEDGMENTS

The authors would like to thank Shelby Funk, Deji Chen,Sanjoy Baruah, and Al Mok for their insightful commentson earlier manuscripts of this paper which revealed flaws inthe original derivation and suggested several improve-ments. Special thanks goes to Lui Sha for commenting onthe manuscript and suggesting the addition of Corollary 2.The work reported in this paper was supported in part bythe US National Science Foundation under grants CCR-0093144, CCR-0208769, and ANIR-0105873, and underMURI grant N00014-01-1-0576.

REFERENCES

[1] T. Abdelzaher and C. Lu, “Schedulability Analysis and UtilizationBounds for Highly Scalable Real-Time Services,” Proc. IEEE Real-Time Technology and Applications Symp., June 2001.

[2] T.F. Abdelzaher, K.G. Shin, and N. Bhatti, “Performance Guaran-tees for Web Server End-Systems: A Control-Theoretical Ap-proach,” IEEE Trans. Parallel and Distributed Systems, 2001.

[3] Y.-C. Chang and K.G. Shin, “A Reservation-Based Algorithm forScheduling Both Periodic and Aperiodic Real-Time Tasks,” IEEETrans. Computers, vol. 44, no. 12, pp. 1405-1419, Dec. 1995.

[4] D. Chen, A.K. Mok, and T.-W. Kuo, “Utilization Bound Re-Visited,” Proc. Sixth Int’l Conf. Real-Time Computing Systems andApplications, pp. 295-302, Dec. 1999.

[5] R. Davis and A. Burns, “Optimal Priority Assignment forAperiodic Tasks with Firm Deadlines in Fixed Priority Pre-Emptive Systems,” Information Processing Letters, vol. 53, no. 5,pp. 249-254, Mar. 1995.

[6] R. Devillers and J. Goossens, “Liu and Layland’s SchedulabilityTest Revisited,” Information Processing Letters, vol. 73, no. 5,pp. 157-161, Mar. 2000.

[7] N. Gandhi, S. Parekh, J. Hellerstein, and D. Tilbury, “FeedbackControl of a Lotus Notes Server: Modeling and Control Design,”Proc. Am. Control Conf., 2001.

[8] C.-C. Han, “A Better Polynomial-Time Schedulability Test forReal-Time Multiframe Tasks,” Proc. 19th IEEE Real-Time SystemsSymp., pp. 104-113, Dec. 1998.

[9] C.-C. Han and H.-Y. Tyan, “A Better Polynomial-Time Schedul-ability Test for Real-Time Fixed-Priority Scheduling Algorithms,”Proc. 18th IEEE Real-Time Systems Symp., pp. 36-45, Dec. 1997.

[10] G. Koren and D. Shasha, “D-Over: An Optimal On-LineScheduling Algorithm for Overloaded Real-Time Systems,” Proc.IEEE Real-Time Systems Symp., pp. 290-299, Dec. 1992.

[11] T.W. Kuo and A.K. Mok, “Load Adjustment in Adaptive Real-Time Systems,” Proc. IEEE Real-Time Systems Symp., Dec. 1991.

[12] S. Lauzac, R. Melhem, and D. Mosse, “An Efficient RMSAdmission Control and Its Application to Multiprocessor Sche-duling,” Proc. First Merged Int’l Parallel Processing Symp. and Symp.Parallel and Distributed Processing, Mar. 1998.

[13] J. Lehoczky, L. Sha, and Y. Ding, “The Rate Monotonic SchedulingAlgorithm: Exact Characterization and Average Case Behavior,”Proc. Real-Time Systems Symp., Dec. 1989.

[14] J. Lehoczky and S.R. Thuel, “An Optimal Algorithm for Schedul-ing Soft-Aperiodic Tasks in Fixed-Priority Preemptive Systems,”Proc. Real-Time Systems Symp., pp. 110-123, Dec. 1992.

[15] J.P. Lehoczky, “Real-Time Queueing Theory,” Proc. 17th IEEEReal-Time Systems Symp. (RSS ’96), pp. 186-195, Dec. 1996.

[16] J.P. Lehoczky, “Using Real-Time Queueing Theory to ControlLateness in Real-Time Systems,” Proc. 1997 ACM SIGMETRICSInt’l Conf. Measurement and Modeling of Computer Systems,Performance Evaluation Rev., vol. 25, no. 1, pp. 158-168, June 1997.

[17] T.-H. Lin and W. Tarng, “Scheduling Periodic and AperiodicTasks in Hard Real-Time Computing Systems,” PerformanceEvaluation Rev., vol. 19, no. 1, May 1991.

[18] C.L. Liu and J.W. Layland, “Scheduling Algorithms for Multi-programming in a Hard-Real-Time Environment,” J. ACM, vol. 20,no. 1, pp. 46-61, 1973.

[19] J.M. Lopez, M. Garcia, J.L. Diaz, and D.F. Garcia, “Worst-CaseUtilization Bound for EDF Scheduling on Real-Time Multi-processor Systems,” Proc. 12th Euromicro Conf. Real-Time Systems,pp. 25-33, June 2000.

[20] C. Lu, T. Abdelzaher, J. Stankovic, and S. Son, “A FeedbackControl Approach for Guaranteeing Relative Delays in WebServers,” Proc. IEEE Real-Time Technology and Applications Symp.,June 2001.

[21] Y. Lu, A. Saxena, and T.F. Abdelzaher, “Differentiated CachingServices; a Control-Theoretical Approach,” Proc. Int’l Conf.Distributed Computing System, Apr. 2001.

[22] A.K. Mok and D. Chen, “A Multiframe Model for Real-TimeTasks,” IEEE Trans. Software Eng., vol. 23, no. 10, pp. 635-645, Oct.1997.

[23] M.D. Natale and J.A. Stankovic, “Dynamic End-to-End Guaran-tees in Distributed Real-Time Systems,” Proc. Real-Time SystemsSymp., pp. 216-227, Dec. 1994.

[24] D.-I. Oh and T.P.B. TP, “Utilization Bounds for n-Processor RateMonotone Scheduling with Static Processor Assignment,” Real-Time Systems, vol. 15, no. 2, 1998.

[25] M. Pandya and M. Malek, “Minimum Achievable Utilization forFault-Tolerant Processing of Periodic Tasks,” IEEE Trans. Compu-ters, vol. 47, no. 10, pp. 1102-1112, Oct. 1998.

[26] D.-W. Park, S. Natarajan, and A. Kanevsky, “Fixed-PriorityScheduling of Real-Time Systems Using Utilization Bounds,”J. Systems and Software, vol. 33, no. 1, pp. 57-63, Apr. 1996.

[27] K. Ramamritham, J.A. Stankovic, and W. Zhao, “DistributedScheduling of Computing Tasks with Deadlines and ResourceRequirements,” IEEE Trans. Computers, vol. 38, no. 8, pp. 1110-1123, Aug. 1989.

[28] W.K. Shih, J. Liu, and C.L. Liu, “Modified Rate-MonotonicAlgorithm for Scheduling Periodic Jobs with Deferred Deadlines,”IEEE Trans. Software Eng., vol. 19, no. 12, pp. 1171-1179, Dec. 1993.

[29] B. Sprunt, L. Sha, and J. Lehoczky, “Aperiodic Task Scheduling forHard-Real-Time Systems,” Real-Time Systems, vol. 1, no. 1, pp. 27-60, June 1989.

[30] J. Stankovic, “Decentralized Decision Making for Task Realloca-tion in a Hard Real-Time System,” IEEE Trans. Computers, vol. 38,no. 3, pp. 341-355, Mar. 1989.

[31] J. Stankovic and K. Ramamritham, Hard Real-Time Systems. IEEEPress, 1988.


[32] J.A. Stankovic and K. Ramamritham, “The Design of the SpringKernel,” Proc. Real-Time Systems Symp., pp. 146-157, Dec. 1987.

[33] J.A. Stankovic and K. Ramamritham, “The Spring Kernel: A NewParadigm for Real-Time Systems,” IEEE Software, pp. 62-72, May1991.

[34] J.A. Stankovic, K. Ramamritham, and S. Cheng, “Evaluation of aFlexible Task Scheduling Algorithm for Distributed Hard Real-Time Systems,” IEEE Trans. Computers, vol. 34, no. 12, pp. 1130-1143, Dec. 1985.

[35] D.C. Steere, A. Goel, J. Gruenberg, D. McNamee, C. Pu, and J.Walpole, “A Feedback-Driven Proportion Allocator for Real-RateScheduling,” Operating Systems Design and Implementation, 1999.

[36] J.K. Strosnider, J.P. Lehoczky, and L. Sha, “The Deferrable ServerAlgorithm for Enhanced Aperiodic Responsiveness in Hard Real-Time Environments,” IEEE Trans. Computers, vol. 44, no. 1, pp. 73-91, Jan. 1995.

[37] S.R. Thuel and J.P. Lehoczky, “Algorithms for Scheduling HardAperiodic Tasks in Fixed-Priority Systems Using Slack Stealing,”Proc. Real-Time Systems Symp., pp. 22-33, Dec. 1994.

[38] O. Yingfeng and S.H. Son, “Allocating Fixed-Priority PeriodicTasks on Multiprocessor Systems,” Real-Time Systems, vol. 9, no. 3,pp. 207-239, Nov. 1995.

[39] W. Zhao, K. Ramamritham, and J. Stankovic, “PreemptiveScheduling under Time and Resource Constraints,” IEEE Trans.Computers, vol. 36, no. 8, pp. 949-960, Aug. 1987.

[40] W. Zhao, K. Ramamritham, and J. Stankovic, “Scheduling Taskswith Resource Requirements in Hard Real-Time Systems,” IEEETrans. Software Eng., vol. 13, no. 5, pp. 564-577, May 1987.

Tarek F. Abdelzaher received the BSc and MScdegrees in electrical and computer engineeringfrom Ain Shams University, Cairo, Egypt, in1990 and 1994, respectively. He received thePhD degree from the University of Michigan in1999. Since 1999, he has been an assistantprofessor at the University of Virginia, where hefounded the Quality of Service (QoS) Labora-tory. He has authored/coauthored more than 60refereed publications. He was a guest editor for

the Journal of Computer Communications and the Journal of Real-TimeSystems and is coeditor of IEEE Distributed Systems Online. He hasserved on numerous program committees, and held several steeringpositions including poster chair of ICDCS 2003, work-in-progress chairof RTSS 2003, and program chair of RTAS 2004. He is a patent holderon Adaptive Web Systems, a member of the IEEE and IEEE ComputerSociety, and a US National Science Foundation Career award recepient.His research interests include QoS provisioning, real-time computing,operating systems, computer networking, and sensor networks. He isparticularly interested in developing and experimentally validating newfoundations for performance guarantees in highly dynamic unpredictablesoftware systems, ranging from open high-performance Internetapplications to low-power sensor networks and embedded systems.

Vivek Sharma received the BSc and MScdegrees in computer science from the IndianInstitute of Technology Bombay and the Uni-versity of Virginia, Charlottesville in 2001 and2003, respectively. He was a research assistantto Professor Tarek Abdelzaher at the Universityof Virginia and worked on schedulability analysisfor aperiodic tasks and QoS provisioning in high-performance web servers.

Chenyang Lu received the BS degree from theUniversity of Science and Technology of China,Hefei, China, in 1995, the MS degree from theChinese Academy of Sciences, Beijing, China,in 1997, and the PhD degree from the Universityof Virginia, Charlottesville, in 2001, all incomputer science. He is an assistant professorin the Department of Computer Science andEngineering at Washington University in St.Louis, Missouri. He is author and coauthor of

more than 25 refereed publications. His current research interestsinclude distributed real-time systems and middleware, wireless sensornetworks, QoS control, Internet servers, and network storage. He is amember of the IEEE and the IEEE Computer Society

. For more information on this or any computing topic, please visitour Digital Library at www.computer.org/publications/dlib.


a utilization bound for aperiodic tasks and priority

Documents