Analysis of Global EDF for Parallel TasksJing Li, Kunal Agrawal, Chenyang Lu, Christopher Gill

Department of Computer Science and EngineeringWashington University in St. Louis

St. Louis, MO, USA{li.jing, kunal, lu, and cdgill}@wustl.edu

Abstract—As multicore processors become ever more preva-lent, it is important for real-time programs to take advantage ofintra-task parallelism in order to support computation-in tensiveapplications with tight deadlines. We prove that aGlobal EarliestDeadline First (GEDF) scheduling policy provides a capacityaugmentation bound of4− 2

mand a resource augmentation bound

of 2− 1

mfor parallel tasks in the general directed acyclic graph

model. For the proposedcapacity augmentation boundof 4− 2

m

for implicit deadline tasks under GEDF, we prove that if a taskset has a total utilization of at mostm/(4− 2

m) and each task’s

critical path length is no more than 1/(4− 2

m) of its deadline, it

can be scheduled on a machine withm processors under GEDF.Our capacity augmentation bound therefore can be used as astraightforward schedulability test. For the standard resourceaugmentation boundof 2− 1

mfor arbitrary deadline tasks under

GEDF, we prove that if an ideal optimal scheduler can schedulea task set onm unit-speed processors, then GEDF can schedulethe same task set onm processors of speed2− 1

m. However, this

bound does not lead to a schedulabilty test since the ideal optimalscheduler is only hypothetical and is not known. Simulationsconfirm that the GEDF is not only safe under the capacityaugmentation bound for various randomly generated task sets,but also performs surprisingly well and usually outperforms anexisting scheduling technique that involves task decomposition.

Index Terms—real-time scheduling, parallel scheduling, globalEDF, resource augmentation bound, capacity augmentationbound

I. I NTRODUCTION

During the last decade, the performance increase of pro-cessor chips has come primarily from increasing numbers ofcores. This has led to extensive work on real-time schedul-ing techniques that can exploit multicore and multiprocessorsystems. Most prior work has concentrated oninter-taskparallelism, where each task runs sequentially (and thereforecan only run on a single core) and multiple cores are exploitedby increasing the number of tasks. This type of scheduling iscalled multiprocessor scheduling. When a model is limitedto inter-task parallelism, each individual task’s total executionrequirement must be smaller than its deadline since individualtasks cannot run any faster than on a single-core machine.In order to enable tasks with higher execution demands andtighter deadlines, such as those used in autonomous vehicles,video surveillance, computer vision, radar tracking and real-time hybrid testing [1], we must enable parallelism withintasks.

In this paper, we are interested in parallel scheduling, wherein addition to inter-task parallelism tasks sets containintra-task parallelism, which allows threads from one task running

in parallel more than single core. There has been some recentwork in this area. Many of these approaches are based on taskdecomposition [2]–[4], which first decomposes each paralleltask into a set of sequential subtasks with assigned interme-diate release times and deadlines, and then schedules thesesequential subtasks using a known multiprocessor schedulingalgorithm. Decomposition techniques require, in additiontotask-level worst case execution time and critical path length,also a thorough knowledge of the structure of tasks as wellas the individual worst case execution time of each subtaskprior to execution. Such knowledge is expensive to acquire andmay be inaccurate, pessimistic or even unavailable when tasksfrom different vendors are integrated on a common computingplatform. Moreover, decomposition introduces implementationcomplexities in real systems [5].

Therefore, we are interested in analyzing the performanceof a global EDF (GEDF) schedulerwithout any decomposi-tion. We consider a general task model, where each task isrepresented as adirected acyclic graph (DAG)where eachnode represents a sequence of instructions (thread) and eachedge represents a dependency between nodes. A node isreadyto be executed when all its predecessors have been executed.GEDF works as follows: at each time step, the scheduler firsttries to schedule as many ready nodes from all jobs with theearliest deadline as it can; then it schedules ready nodes fromthe jobs with the next earliest deadline, and so on, until eitherall processors are busy or no more nodes are ready.

Compared with other schedulers, GEDF has benefits, suchas automatic load balancing. Efficient and scalable imple-mentations of GEDF for sequencial tasks are available forLinux [6] and LITMUS [7], suggesting the potential existenceof an easy implementation for parallel tasks if decompositionis not required. Prior theory work analyzing GEDF for paralleltasks is either restricted to a single recurring task [8] orconsiders response time analysis for soft-real time tasks [9].In this work, we consider task sets withn tasks and analyzetheir schedulability under the GEDF scheduler in terms ofaugmentation bounds.

We distinguish between two types of augmentation bounds,both of which are called “resource augmentation” in previousliterature. By standard definition, a schedulerS provides aresource augmentation boundof b if the following conditionholds: if an ideal scheduler can schedule a task set onmunit-speed processors, thenS can schedule that task set onmprocessors of speedb. Note that theideal scheduler (optimal

schedule) is only a hypothetical scheduler, meaning that ifa feasible schedule ever exists for a task set then this idealscheduler can guarantee to schedule it. Unfortunately, Fisher etal. [10] proved that optimal online multiprocessor schedulingof sporadic task systems is impossible. Since there may be noway to tell whether the ideal scheduler can schedule a giventask set on unit-speed processors, a resource augmentationbound may not provide a schedulability test.

Therefore, we distinguish resource augmentation from acapacity augmentation boundwhich can serve as an easyschedulability test. If on unit-speed processors, a task set hastotal utilization of at mostm and the critical path length ofeach task is smaller than its deadline, then schedulerS withcapacity augmentation bound ofb can schedule this task seton m processors of speedb. Capacity augmentation boundshave the advantage that they directly lead to schedulabilitytests, since one can easily check the bounds on utilization andcritical path length for any task set.

The contributions presented in this paper are as follows:

• For a system withm identical processors, we prove acapacity augmentation bound of4− 2

m(which approaches

to 4 asm approaches to infinity) for sporadic task setswith implicit deadlines— the relative deadline of eachtask is equal to its period. Another way to understandthis bound is: if a task set has total utilization at mostm/(4− 2

m) and the critical path length of each task is at

most1/(4− 2m) of its deadline, then it can be scheduled

using GEDF on unit-speed processors.• For a system withm identical processors, we prove a

resource augmentation bound of2− 1m

(which approachesto 2 asm approaches to infinity) for sporadic task setswith arbitrary deadlines.

• We also show that GEDF’s capacity bound for paralleltask sets (even with implicit deadlines) is greater than2 − 1

m. In particular, we show example task sets with

utilizationm where the critical path length of each task isno more than its deadline, while GEDF misses a deadlineon m processors with speed less than3+

√5

2 ≈ 2.618.• We conduct simulation experiments to show that the

capacity augmentation bound is safe for task sets withdifferent DAG structures (as mentioned above, checkingthe resource augmentation bound is difficult since wecannot compute the optimal schedule). Results show thatGEDF performs surprisingly well. All simulated randomtask sets meet their deadlines with processor speed of2. We also compare GEDF with a scheduling techniquethat decomposes parallel tasks and then schedules decom-posed subtasks using GEDF [4]. We find that for mosttask sets, GEDF is better without decomposition. Onlyamong task sets, which are intentionally designed to beharder for GEDF to schedule, does the decompositiontechnique occasionally perform better than GEDF withoutdecomposition.

Section II reviews related work. Section III describes theDAG task model with intra-task parallelism. Proofs for a

capacity augmentation bound of4 − 2m

and a resource aug-mentation bound of2 − 1

mare presented in Sections IV

and V respectively. Section VI shows experimental results andSection VII gives concluding remarks.

II. RELATED WORK

Scheduling parallel tasks without deadlines has been ad-dressed by parallel-computing researchers [11]–[14].Soft real-time schedulinghas been studied for various optimizationcriteria, such as cache misses [15], [16], makespan [17] andtotal work done by tasks that meet deadlines [18]. Most priorwork on hard real-time schedulingatop multiprocessors hasconcentrated on sequential tasks [19]. In this context, manysufficient schedulability tests for GEDF and other global fixedpriority scheduling algorithms have been proposed [20]–[28].

Earlier work considering intra-task parallelism makes strongassumptions on task models [29] [30] [31]. For more realisticparallel tasks,synchronous tasks, Kato et al. [32] proposed agang scheduling approach. The synchronous model, a specialcase of the DAG model, represents tasks with a sequence ofmultithreaded segments with synchronization points betweenthem (such as those generated by parallel-for loops).

Most other approaches for scheduling synchronous tasksinvolve decomposing parallel tasks into independent sequen-tial subtasks, which are then scheduled using known multi-processor scheduling techniques, such as [24], [33]. For arestricted set of synchronous tasks, Lakshmanan et al. [2]prove a capacity augmentation bound of 3.42 using deadlinemonotonic scheduling for decomposed tasks. For more generalsynchronous tasks, Saifullah et al. [3] proved a capacity aug-mentation bound of 4 for GEDF and 5 for deadline monotonicscheduling. This decomposition approach was recently ex-tended to general DAGs [4] to achieve a capacity augmentationbound of 4 under GEDF on decomposed tasks (note that inthat work GEDF is used to schedule sequential decomposedtasks, not parallel tasks directly). This is the best augmentationbound known for task sets with multiple DAGs.

More recently, there has been some work on schedulinggeneral DAGs without decomposition. Nogueira et al. [34]explored the use of work-stealing for real-time scheduling.The paper is mostly experimental and focused on soft real-time preformance. The bounds for hard real-time schedulingonly guarantee that tasks meet deadlines if their utilization issmaller than 1. This restriction limits its application to manycomputation-intensive real-time applications, whose utilizationexceeds the capacity of a single core. For example, evenfor large m, like 101, a task with utilizationm/100 is notguaranteed to be schedulable using the such schedulers. An-derson et al. [9] analyzed the response time of GEDF withoutdecomposition for soft real-time tasks. Baruah et al. [8] provedwhen the task set is asingle DAG taskwith arbitrary deadlines,GEDF provides a resource augmentation bound of 2. In thispaper, instead of just a single task, we consider multipleDAG tasks with different execution times, release times anddeadlines. For the resource augmentation bound of2− 1

mfor

multiple DAGs under GEDF proved in our paper, Bonifaci

et al. [35] also show the same resource augmentation bound2 − 1

m. Our work was done independently of that work, and

they also do not consider capacity augmentation.

III. TASK MODEL

This section presents a model for DAG tasks. We considera system withm identical unit-speed processors. The taskset τ consists ofn tasksτ = {τ1, τ2, ..., τn}. Each taskτiis represented by a directed acyclic graph (DAG), and has aperiodPi and deadlineDi. We represent thej-th subtask oftheith task as nodeW j

i . A directed edge from nodeW ji toW k

i

means thatW ki can only be executed afterW j

i has finishedexecuting. A node isready to be executed as soon as all ofits predecessors have been executed. Each node has its ownworst case execution timeCj

i . Multiple source nodes and sinknodes are allowed in the DAG, and the DAG is not requiredto be fully connected. Figure 1 shows an example of a taskconsisting of 5 subtasks in the DAG structure.

For each taskτi in task setτ , let Ci =∑

j Cji be the total

worst case execution time on a single processor, also calledthe work of the task. LetLi be the critical path length (i.e.the worst case execution time of the task on infinite numberof processors). In Figure 1, the critical path (i.e. the longestpath) starts from nodeW 1

1 , goes throughW 31 and ends at node

W 41 , so the critical path length of DAGW1 is 1 + 3+ 2 = 6.

The work and the critical path length of any job generated bytask τi are the same as those of taskτi.

Fig. 1: Example task with work Ci = 8 and critical path lengthLi = 6.

We also define the notion ofremaining workandremainingcritical path lengthof a partially executed job. The remainingwork is the total work minus the work that has already beendone. The remaining critical path length is the length of thelongest path in the unexecuted portion of the DAG (includingpartially executed nodes). For example, in Figure 1, ifW 1

1 andW 2

1 are completely executed, andW 31 is partially executed

such that 1 (out of 3) units of work has been done for it, thenthe remaining critical path length is2 + 2 = 4.

Nodes do not have individual release offsets and deadlineswhen scheduled by the GEDF scheduler; they share the sameabsolute deadline of their jobs. Therefore, to analyze theGEDF scheduler, we do not require any knowledge of theDAG structure beyond the total worst case execution timeCi,deadlineDi, periodPi and critical path lengthLi. We alsodefine the utilization of a taskτi asui =

Ci

Pi

.

On unit speed processors, a task set is not schedulable (byany scheduler) unless the following conditions hold:

• The critical path length of each task is less than itsdeadline.

Li ≤ Di (1)

• The total utilization is smaller than the number of cores.∑

i

ui ≤ m (2)

In addition, we denoteJk,a as thea-th job instance of taskk in system execution. For example, thei-th node ofJk,a isrepresented asW i

k,a. We denoterk,a anddk,a as the absoluterelease time and absolute deadline of jobJk,a respectively.Relative deadlineDk is equal todk,a − rk,a. Since in thispaper we address sporadic tasks, the absolute release time hasthe following properties:

rk,a+1 ≥ dk,a

rk,a+1 − rk,a ≥ dk,a − rk,a = Dk

IV. CAPACITY AUGMENTATION BOUND OF4 −

2

m

In this section, we propose a capacity augmentation boundof 4 − 2

mfor implicit deadline tasks, which yields an easy

schedulability test. In particular, we show that GEDF cansuccessfully schedule a task set, if the task set satisfiesthe following conditions: (1) its total utilization is at mostm/(4− 2

m) and (2) the critical path length of each task is at

most 1/(4 − 2m) of its period (and deadline). Note that this

is equivalent to say that if a task set meets conditions fromInequalities 1 and 2 of processors of unit speed, then it can bescheduled onm processors of speed4− 2

m(which approaches

to 4 asm approaches to infinity).The gist of the proof is the following: at a job’s release

time, we can bound the remaining work from other tasks underGEDF with speed up4− 2

m. Bounded remaining work leads

to bounded interference from other tasks, and hence GEDFcan successfully schedule all of them.

Notation

We first define a notion of interference. Consider a jobJk,a,which is thea-th instance of taskτk. Under GEDF scheduling,only jobs that have absolute deadlines earlier than the absolutedeadline ofJk,a can interfere withJk,a. We say that a job isunfinished if the job has been released but has not completedyet. Due to implicit deadlines (Di = Pi), at most one job ofeach task can be unfinished at any time.

There are two sources of interference for jobJk,a. (1)Carry-in work is the work from jobs that were releasedbeforeJk,a, did not finish beforeJk,a was released, and havedeadlines beforeJk,a deadline. LetRk,a

i be the carry-in workdue to taski and letRk,a =

∑

iRk,ai be the total carry-in from

the entire task set onto the jobJk,a. (2) Other than carry-inwork, the jobs that were released after (or at the same time as)Jk,a was released can also interfere with it if their deadlinesare either before or at the same time asJk,a. Let nk,a

i be thenumber of taski’s jobs, which are released after the releasetime of Jk,a but have deadlines no later than the deadline of

Jk,a (that is, the number of jobs from taski that entirely fallin between the release time and deadline ofJk,a, i.e. the timeinterval [rk,a, dk,a].) For example, in right part of Figure 2,one entire jobJ1,3 falls within time interval[r3,1, d3,1] of jobJ3,1. So,n3,1

1 = 1. By definition andDi = Pi, every taskihas the property that

nk,ai Di ≤ Dk (3)

Therefore, the total amount of work,Ak,a that can interferewith Jk,a (including Jk,a’s work) and must be finished (toprevent any deadline misses) before the deadline ofJk,a isthe sum of the carry-in work and the work that was releasedat or afterJk,a’s release.

Ak,a = Rk,a +∑

i

uink,ai Di. (4)

Note that the work of the jobJk,a itself is also included inthis formula. That is, in this formulation, each job interfereswith itself.

Proof of the Theorem

Consider a GEDF schedule withm processors each of speedb. Each time step can be divided intob sub-steps such that eachprocessor can do one unit of work in each sub-step. We say asub-step iscompleteif all processors are working during thatsub-step, otherwise, we say it isincomplete.

First, a couple of straight-forward lemmas.

Lemma 1. On every incomplete sub-step, the remainingcritical path length of each unfinished job reduces by 1.

Lemma 2. In any t contiguous time steps (bt sub-steps) withunfinished jobs, if there aret∗ incomplete sub-steps, then thetotal work done during this time,Ft is at least

F t ≥ bmt− (m− 1)t∗.

Proof: The total number of complete sub-steps duringtsteps isbt− t∗, and the total work during these complete stepsis m(bt− t∗). On an incomplete sub-step, at least one unit ofwork is done. Therefore, the total work done in incompletesub-steps is at leastt∗. Adding the two gives us the bound.

We now prove a sufficient condition for the schedulabilityof a particular job.

Lemma 3. If interferenceAk,a on a jobJk,a is bounded byAk,a ≤ bmDk − (m− 1)Dk,

then jobJk,a can meet its deadline onm identical processorswith speed ofb.

Proof: Note that there areDk time steps (thereforebDk

sub-steps) between the release time and deadline of this job.There are two cases:

Case 1:The total number of incomplete sub-steps betweenthe release time and deadline ofJk,a is more thanDk, andtherefore, also more thanLk. In this case,Jk,a’s critical pathlength reduces on all of these sub-steps. After at mostLk

incomplete steps, the critical path is 0 and the job has finishedexecuting. Therefore, it can not miss the deadline.

Case 2:The total number of incomplete sub-steps betweenthe release and deadline ofJk,a is smaller thanDk. Therefore,

the total amount of work done during this time is more thanbmDk − (m − 1)Dk by the condition in Lemma 2. Sincethe total interference (includingJk,a’s work) is at most thisquantity, the job cannot miss its deadline.

Fig. 2: Example of tasks execution traceWe now define additional notation in order to prove that if

the carry-in work for a job is bounded, then GEDF guaranteesa capacity augmentation bound ofb. Let αk,a

i be the numberof time steps between the absolute release time ofJk,a andthe absolute deadline of the carry-in job of taski. Hence, forJk,a and its carry-in jobJj,b of taskj

αk,aj = dj,b − rk,a (5)

To make the notation clearer, we give an example in Figure2. There are 3 sporadic tasks with implicit deadlines: the(execution time, deadline, period) for task 1, 2 and 3 are (2,3,3), (7, 7, 7) and (6, 6, 6) respectively. For simplicity, assumethey are sequential tasks. Since tasks are sporadic,r1,2 > d1,1.α3,11 is the number of time steps between the release time of

job J3,1 and the deadline of the carry-in jobJ1,2 from task1.In this example,α3,1

1 = 2. Similarly,α3,12 = 3. Also,n3,1

1 = 1.For either periodic or sporadic tasks, taski has the property

αk,ai + nk,a

i Di ≤ Dk (6)sinceαk,a

i is the remaining length of the carry-in job andnk,ai

is the number of jobs of taski entirely falling in the period(relative deadline) of jobJk,a. As in Figure 2,α3,1

1 +n3,11 D1 =

2 + 1 ∗ 3 = 5 < 6 = D3.

Lemma 4. If the processors’ speed isb ≥ 4− 2m

and the totalcarry-in workRk,a from every taski satisfies the condition

Rk,a ≤∑

i

uiαk,ai +m ·max

i(αk,a

i ),

then jobJk,a always meets its deadline under global EDF.Proof: The total amount of interfering work (including

Jk,a’s work) isAk,a = Rk,a+∑

i uink,ai Di. Hence, according

to the condition in Lemma 4, the total amount of workAk,a = Rk,a +

∑

i

uink,ai Di

≤∑

i

uiαk,ai +mmax

i(αk,a

i ) +∑

i

uink,ai Di

≤∑

i

ui(αk,ai + nk,a

i Di) +mmaxi

(αk,ai )

Using eq.(6) to substituteDk into the formula, then

Ak,a ≤∑

i

uiDk +mDk

Since the total task set utilization does not exceed thenumber of processorsm, by eq.(2), we replace

∑

i ui withm. And sinceb ≥ 4− 2

mandm ≥ 1, we get

Ak,a ≤ 2mDk ≤ (3m− 1)Dk

≤ (4− 2

m)mDk − (m− 1)Dk

≤ bmDk − (m− 1)Dk

Finally, according to Lemma 3, since the interference satis-fies the bound, jobJk,a can meet its deadline.

We now complete the proof by showing that the carry-inwork is bounded as required by Lemma 4 for every job.

Lemma 5. If the processor’s speedb ≥ 4 − 2m

, then, foreither periodic or sporadic task sets with implicit deadlines,the total carry-in workRk,a for every jobJk,a in the task setis bounded by

Rk,a ≤∑

i

uiαk,ai +mmax

i(αk,a

i )

Proof: We prove this theorem by induction from absolutetime 0 to the release time of jobJk,a.

Base Case:For the very first job of all the tasks released inthe system (denotedJl,1), no carry-in jobs are released beforethis job. Therefore, the condition trivially holds and the jobcan meet its deadline by Lemma 4.

Rl,1 = 0 ≤∑

i

uiαl,1i +mmax

i(αl,1

i )

Inductive Step: Assume that for every job with an earlierrelease time thanJk,a, the condition holds. Therefore, accord-ing to Lemma 4, every earlier released job meets its deadline.Now we prove that the condition also holds for jobJk,a.

For jobJk,a, if there is no carry-in work from jobs releasedearlier thanJk,a, so thatRk,a = 0, the property trivially holds.Otherwise, there is at least one unfinished job (a job withcarry-in work) at the release time ofJk,a.

We now defineJj,b as the job with the earliest releasetime among all the unfinished jobs at the time thatJk,a wasreleased. For example, at release timer3,1 of J3,1 in Figure2, bothJ1,2 andJ2,1 are unfinished, butJ2,1 has the earliestrelease time. By the inductive assumption, the carry-in workRj,b at the release time of jobJj,b is bounded by

Rj,b ≤∑

i

uiαj,bi +mmax

i(αj,b

i ) (7)

Let t be the number of time steps between the release timerj,b of Jj,b and the release timerk,a of Jk,a.

t = rk,a − rj,bNote thatJj,b has not finished at timerk,a, but by assumptionit can meet its deadline. Therefore its absolute deadlinedj,bis later than the release timerk,a. So, by eq.(5)

t+ αk,aj = rk,a − rj,b + αk,a

j = dj,b − rj,b = Dj (8)

In Figure 2,t+α3,11 = r3,1−r2,1+α3,1

1 = d2,1−r2,1 = D2.For each taskτi, let nt

i be the number of jobs that arereleased after the release timerj,b of Jj,b before the releasetime rk,a of Jk,a. The last such job may have a deadline afterthe release time ofrk,a, but its relase time is beforerk,a. Inother words,nt

i is the number of jobs of taskτi, which fall

entirely into the time interval[rj,b, rk,a + Di]. By definitionof αk,a

i , to job Jk,a, the deadline of the unfinished job of taski is rk,a + αk,a

i . Therefore, for everyτi,αj,bi + nt

iDi ≤ rk,a + αk,ai − rj,b = t+ αk,a

i (9)As in the example in Figure 2, one entire job of task 1 fallswithin [r2,1, r3,1+D1], makingnt

1 = 1 andd1,2 = r3,1+α3,11 .

Also, sinced1,1 ≤ r1,2, α2,11 + nt

1D1 = α2,11 +D1 ≤ d1,2 −

r2,1 = r3,1 + α3,11 − r2,1 = t+ α3,1

1 ≤ t+D1.Compare betweent andαk,a

j . When t ≤ 12Dj, by eq.(8),

αk,aj = Dj − t ≥ 1

2Dj ≥ t. There are two cases:

Case 1:t ≤ 12Dj and henceαk,a

j ≥ t:Since by definitionJj,b is the earliest carry-in job, other

carry-in jobs toJk,a are released after the release time ofJj,band therefore are not carry-in jobs toJj,b. In other words, thecarry-in jobs toJj,b must have been finished before the releasetime of Jk,a, which means that the carry-in workRj,b is notpart of the carry-in workRk,a. So the carry-in workRk,a isthe sum of those released later thanJj,b

Rk,a =∑

i

uintiDi ≤

∑

i

ui(t+ αk,ai ) (from eq.(9))

By assumption of case 1,t ≤ αk,aj ≤ maxi

(

αk,ai

)

. Hence,

replace∑

i ui with m using eq.(2), we can prove that

Rk,a ≤∑

i

uiαk,ai +mmax

i

(

αk,ai

)

Case 2:t > 12Dj :

Since Jj,b has not finished executing at the release timeof Jk,a, the total number of incomplete sub-steps during thettime steps(rj,b, rk,a] is less thanLj. Therefore, the total workdone during this time is at leastF t where

F t = bmt− (m− 1)Lj (from Lemma 2)

≥ bmt− (m− 1)Dj (from eq.(1))

The total amount of work from jobs that are released intime interval (rj,b, rk,a] (i.e, entire jobs that fall in betweenthe release time of jobJj,b and the release time of jobJk,aplus its deadline) is

∑

i uintiDi, by the definition ofnt

i. Thecarry-in workRk,a at the release time of jobJk,a is the sumof the carry-in workRj,b and newly released work

∑

i uintiDi

minus the finished work during time intervalt, which is

Rk,a = Rj,b +∑

i

uintiDi − F t

≤ Rj,b +∑

i

uintiDi − (bmt− (m− 1)Dj)

By our assumption in eq.(7), we can replaceRj,b, reorganizethe formula and get

Rk,a ≤∑

i

uiαj,bi +mmax

i

(

αj,bi

)

+∑

uintiDi − bmt+ (m− 1)Dj

≤∑

i

ui

(

αj,bi + nt

iDi

)

+mmaxi

(

αj,bi

)

−bmt+ (m− 1)Dj

According to eq.(9), we can replaceαj,bi + nt

iDi with t +αk,ai , reorganize the formula and get

Rk,a ≤∑

i

ui

(

t+ αk,ai

)

+mmaxi

(αj,bi )

−bmt+ (m− 1)Dj

≤(

∑

i

ui

(

t+ αk,ai

)

−mt

)

+mmaxi

(αj,bi ) + (m− 1)Dj − (b− 1)mt

Using eq.(2) to replacem with∑

i ui in the first item, usingeq.(6) to getmaxi (α

j,bi ) ≤ Dj and to replacemaxi(α

j,bi ) with

Dj in the second item, and sincet > 12Dj ,

Rk,a

≤∑

i

uiαk,ai +mDj + (m− 1)Dj − (b − 2)mt−mt

≤∑

i

uiαk,ai +mDj −mt+ 2(m− 1)t− (b − 2)mt

≤∑

i

uiαk,ai +m(Dj − t) + 0 (sinceb ≥ 4− 2

m)

≤∑

i

uiαk,ai +mαk,a

j (from eq.(8))

Finally, sinceαk,aj ≤ maxi

(

αk,ai

)

, we can prove that

Rk,a ≤∑

i

uiαk,ai +mmax

i

(

αk,ai

)

Therefore, by induction, if the processor speedb ≥ 4− 2m

,for everyJk,a in task set

Rk,a ≤∑

i

uiαk,ai +mmax

i

(

αk,ai

)

From Lemmas 4 and 5, we can easily derive the followingcapacity augmentation bound theorem.

Theorem 1. If, on unit speed processors, the utilization of asporadic task set is at mostm, and the critical path length ofeach job is at most its deadline, then the task set can meet alltheir implicit deadlines onm processors of speed4− 2

m.

Theorem 1 proves the speed-up factor of GEDF and it canalso be restated as follows:

Corollary 6. If a sporadic task setτ with implicit deadlinessatisfies the condition that its total utilization is no morethan1/(4− 2

m) of the total system utilizationm and for every task

τi ∈ τ , the critical path lengthLi is smaller than1/(4− 2m)

of its periodDi, then GEDF can successfully schedule tasksetτ .

V. RESOURCEAUGMENTATION BOUND OF2 −

1

m

In this section, we prove the resource augmentation boundof 2− 1

mfor GEDF scheduling of arbitrary deadline tasks.

For sake of discussion, we convert the DAG representingof task into an equivalent DAG where each sub-node does1

m

unit of work. An example of this transformation of task1 inFigure 1 is shown in jobW1 in Figure 3 (see the upper job). Anode with workw is split into a chain ofmw sub-nodes withwork 1

m. For example, since in Figure 3m = 2, nodeW 1

1 withworst case execution time of1 is split into 2 sub-nodesW 1,1

1

andW 1,21 with length 1

2 . The original incoming edges comeinto the first node of the chain, while the outgoing edges leavethe last node of the chain. This transformation does not change

any other characteristic of the DAG, and the scheduling doesnot depend on this step — the transformation is done only forclarity of the proof.

First, some definitions. Since the GEDF scheduler runs onprocessors of speed2 − 1

m, each step under GEDF can be

divided into(2m−1) sub-steps of length1m

. In each sub-step,each processor can do1

munit of work (i.e. execute one sub-

node). In a GEDF scheduler, on an incomplete step, all readynodes are executed (Observation 7). As in Section IV, wesay that a sub-step iscompleteif all processors are busy, andincompleteotherwise. For each sub-stept, we defineFI(t)as the set of sub-nodes that havefinishedexecuting under anideal scheduler after sub-stept, RI(t) as the set of sub-nodesthat areready(all their predecessors have been executed) to beexecuted by the ideal scheduler before sub-stept, andDI(t)as the set of sub-nodes completed by the ideal scheduler insub-stept. Note thatDI(t) = RI(t) ∩ FI(t). We similarlydefineFG(t), RG(t), andDG(t) for GEDF scheduler.

Observation 7. The GEDF scheduler completes all the readynodes in an incomplete sub-step. That is,

DG(t) = RG(t), if t is incomplete sub-step, (10)

Note for the ideal scheduler, each original step consists ofmsub-steps, while for GEDF with speed2− 1

meach step consists

of 2m−1 sub-steps. For example, in Figure 3 for stept1, thereare two sub-stepst1(1) and t1(2) under ideal scheduler, whileunder GEDF there is an additionalt1(3) (since2m− 1 = 3).

Theorem 2. If an ideal scheduler can schedule a task setτ (periodic or sporadic tasks with arbitrary deadlines) on aunit-speed system withm identical processors, then globalEDF can scheduleτ on m processors of speed2− 1

m.

Proof: In a GEDF scheduler, on an incomplete sub-step,all ready sub-nodes are executed (Observation 7). Therefore,after an incomplete sub-step, GEDF must have finished all thereleased sub-nodes and hence must have done at least as muchwork as the ideal scheduler. Thus, for brevity of our proof, weleave out any time interval when all processors under GEDFare idling, since at this time GEDF has finished all availablework and at this time the Theorem is obviously true. We definetime 0 as the first instant when not all processors are idlingunder GEDF and timet as any time such that for every sub-steps during time interval[0, t] at least one processor underGEDF is working. Therefore for every incomplete sub-stepGEDF will finish at least1 sub-node (i.e.1

munit of work).

We also define sub-step0 as the last sub-step before time0and hence by definition,

FG(0) ⊇ FI(0) and |FG(0)| ≥ |FI(0)| (11)For each timet ≥ 0, we now prove the following: If the

ideal unit-speed system can successfully schedule all taskswith deadlines in the time interval[0, t], then on speed2− 1

m

processors, so can GEDF. Note again that during the interval[0, t] an ideal scheduler and GEDF havetm and2tm− t sub-steps respectively.

Case 1: In [0, t], GEDF has at mosttm incomplete sub-steps.

Fig. 3: Example of tasks execution: (left) under unit-speedideal scheduler; (right) under 2-speed GEDF

Since there are at least(2tm− t)− tm = tm− t completesteps, the system can complete|FG(t)| − |FG(0)| ≥ m(tm−t) + (tm) = tm2 work, since each complete sub-step canfinish executingm sub-nodes and each incomplete sub-stepcan finish executing at least1 sub-node. We defineI(t) as theset of all sub-nodes from jobs with absolute deadlines no laterthant. Since the ideal scheduler can schedule this task set, weknow that |I(t)| − |FI(0)| ≤ mt ∗m = tm2, since the idealscheduler can only finish at mostm sub-nodes in each sub-stepand during[0, t] there aremt sub-steps for the ideal scheduler.Hence, we have|FG(t)| − |FG(0)| ≥ |I(t)| − |FI(0)|. Byeq.(11), we get|FG(t)| ≥ |I(t)|. Note that jobs inI(t) haveearlier deadlines than the other jobs, so under GEDF, no otherjobs can interfere with them. The GEDF scheduler will neverexecute other sub-nodes unless there are no ready sub-nodesfrom I(t). Since |FG(t)| ≥ |I(t)|, i.e. the number of sub-nodes finished by GEDF is at least the amount inI(t), thisimplies that GEDF must have finished all sub-nodes inI(t).Therefore, GEDF can meet all deadlines since it has finishedall work that needed to be done by timet.

Case 2: In [0, t], the GEDF system has more thantmincomplete sub-steps.

For each integers we definef(s) as the first time instantsuch that the number of incomplete sub-steps in interval[0, f(s)] is exactlys. Note that the sub-stepf(s) is alwaysincomplete, since otherwise it wouldn’t be the first suchinstant. We show, via induction, thatFI(s) ⊆ FG(f(s)). Inother words, afterf(s) sub-steps, GEDF has completed all thenodes that the ideal scheduler has completed afters sub-steps.

Base Case:For s = 0, f(s) = 0. By eq.(11), the claim isvacuously true.

Inductive Step: Suppose that fors−1 the claimFI(s−1) ⊆FG(f(s− 1)) is true. Now, we prove thatFI(s) ⊆ FG(f(s)).

In (s− 1, s], the ideal system has exactly 1 sub-step. So,FI(s) = FI(s− 1) ∪ DI(s) ⊆ FI(s− 1) ∪RI(s) (12)SinceFI(s − 1) ⊆ FG(f(s − 1)), all the sub-nodes that

are ready before sub-steps for the ideal scheduler, will eitherhave already been executed or are also ready for the GEDFscheduler one sub-step after sub-stepf(s− 1); that is,FI(s−1)∪RI(s) ⊆ FG(f(s−1))∪RG (f(s−1)+1) (13)For GEDF, from sub-stepf(s−1)+1 to f(s), all the ready

sub-nodes with earliest deadlines will be executed and thennew sub-nodes will be released into the ready set. Hence,

FG(f(s− 1)) ∪RG(f(s− 1) + 1)

⊆ FG(f(s− 1) + 1) ∪RG(f(s− 1) + 2) (14)

⊆ ... ⊆ FG(f(s)− 1) ∪RG(f(s))

Since sub-stepf(s) for GEDF is always incomplete,

FG(f(s))

= FG(f(s)− 1) ∪ DG(f(s))

= FG(f(s)− 1) ∪RG(f(s)) (from eq.(10))

⊇ FG(f(s− 1)) ∪RG(f(s− 1) + 1) (from eq.(14))

⊇ FI(s− 1) ∪RI(s) (from eq.(13))

⊇ FI(s) (from eq.(12))By time t, there aremt sub-steps for the ideal scheduler,

so GEDF must have finished all the nodes executed by theideal scheduler at sub-stepf(mt). Since there are exactlymtincomplete sub-steps in[0, f(mt)] and since the number ofincomplete sub-steps by timet is at leastmt, the timef(mt)is no later than timet. Since the ideal system does not missany deadline by timet, GEDF also meets all deadlines.

An Example Providing Intuition of the Proof

We provide an example in Figure 3 to illustrate the proof ofCase2 and compare the execution trace of an ideal scheduler(this scheduler is only considered “ideal” in the sense thatitmakes all the deadlines) and GEDF. In addition to task1 fromFigure 1, task 2 consists of two nodes connected to anothernode, all with execution time of 1 (each split into 2 sub-nodesin the figure). All tasks are released by timet0. The systemhas 2 cores, so GEDF has resource augmentation bound of 1.5.On the left side is the execution trace for the ideal scheduleron unit-speed cores, while the right side shows the executiontrace under GEDF on speed 2 cores. One step is divided into2 and 3 sub-steps, representing the speedup of 1 and 1.5 forthe ideal scheduler and GEDF respectively.

Since the critical path length of task 1 is equal to itsdeadline, intuitively it should be executed immediately eventhough it has the latest deadline. That is exactly what theideal scheduler does. However, GEDF (which does not takecritical path length into consideration) will prioritize task 2

first. If GEDF is only on a unit-speed system, task 1 will missdeadline. However, when GEDF gets speed-1.5 processors, alljobs are finished in time. To illustrate Case 2 of the abovetheorem, considers = 2. Sincet2(3) is the second incompletesub-step by GEDF,f(s) = 2(3). All the nodes finished by theideal scheduler after second sub-step (shown at left in darkgrey) have also been finished under GEDF by stept2(3) (shownat right in dark grey).

Capacity Augmentation Bound is greater than(3 +√5)/2

While the above proof guarantees a bound, since the idealscheduler is not known, given a task set, we cannot tell if itis feasible on speed-1 processors. Therefore, we cannot tell ifit is schedulable by GEDF on processors with speed2− 1

m.

One standard way to prove resource augmentation boundsis to use lower bounds on the ideal scheduler, such asInequalities 1 and 2. As previously stated, we call the re-source augmentation bound proven using these lower boundsa capacity augmentation boundin order to distinguish itfrom the augmentation bound described above. To prove acapacity augmentation bound ofb under GEDF, one mustprove that if Inequalities 1 and 2 hold for a task set onmunit-speed processors, then GEDF can schedule that task setonm processors of speedb. Hence, the capacity augmentationbound is also an easy schedulability test.

First, we demonstrate a counter-example to show proving acapacity augmentation bound of 2 for GEDF is impossible.

Fig. 4: Structure of the task set that demonstrates GEDF doesnot provide a capacity augmentation bound less than(3+

√

5)/2

In particular, we provide a task set that satisfies inequal-ities 1 and 2, but cannot be scheduled onm processors ofspeed 2 by GEDF in Figure 4. In this example, as shown inFigure 5,m = 6. The task set has two tasks. All values aremeasured on a unit-speed system, shown in Figure 4. Task 1has 13 nodes with total execution time of 440 and period of 88,so its utilization is 5. Task 2 is a single node, with executiontime and implicit deadline both 60 and hence utilization of 1.Note the total utilization (6) is exactly equal tom, satisfyinginequality 2. The critical path length of each task is equal toits deadline, satisfying inequality 1.

The execution trace of the task set on a 2-speed 6-coreprocessor under GEDF is shown in Figure 5. The first taskis released at time 0 and is immediately executed by GEDF.Since the system under GEDF is at speed 2,W 1,1

1 finishes

Fig. 5: Execution of the task set under GEDF at speed 2

executing at time 28. GEDF then executes 6 out of the 12parallel nodes from task 1. At time 29, task 2 is released.However, its deadline isr2 +D2 = 29 + 60 = 89, later thandeadline 88 of task 1. Nodes from task 1 are not preemptedby task 2 and continue to execute until all of them finish theirwork at time 60. Task 1 successfully meets its deadline. TheGEDF scheduler finally gets to execute task 2 and finishes it attime 90, so task 2 just fails to meet its deadline of 89. Note thatthis is not a counter-example for the resource augmentationbound shown in Theorem 2, since no scheduler can schedulethis task set on unit-speed system either.

Second, we demonstrate that one can construct task sets thatrequire capacity augmentation of at least3+

√5

2 to be schedu-lable by GEDF. We generate task sets with two tasks whosestructure depends onm, speedup factorb and a parallelismfactorn, and show that for large enoughm andn, the capacityaugmentation required is at leastb ≥ 3+

√5

2 . As in the lowerpart of Figure 4, task 1 is structured as a single node withwork x followed by nm nodes with worky. Its critical pathlength isx + y and so is its deadline. The utilization of task1 is set to bem− 1, hence

m− 1 =x+ nmy

x+ y(15)

Task 2 is structured as a single node with work and deadlineequal tox + y − x

b(hence utilization1). Therefore, the total

task utlization ism and Inequalities 1 and 2 are met. As thelower part of Figure 5 shows, Task 2 is released at timex

b+1.

We want to generate a counter example, so want task2 tobarely miss the deadline by 1 sub-step. In order for this tooccur, we must have

(x+ y − x

b) + 2 =

ny

b+

1

b(x + y − x

b). (16)

Reorganizing and combining eq.(15) and eq.(16), we get(m−2)b2 = ((3bn−b−n−b2n+1)m+(b2−2bn−1))y (17)In the above equation, for large enoughm andn, we have

(3bn− b− n− b2n+ 1) > 0, or

1 < b <3

2− 1

2n+

1

2

√

5− 2

n+

1

n2(18)

So, there exists a counter-example for any speedupb whichsatisfies the above conditions. Therefore, the capacity augmen-tation required by GEDF is at least3+

√5

2 . The example above

with speedup of 2 comes from such a construction. Anotherexample with speedup 2.5 can be obtained whenx = 36050,y = 5900, m = 120 andn = 7.

VI. EVALUATION

In this section, we describe our experimental evaluationthe performance of GEDF and the robustness of our capacityaugmentation bound.1 We randomly generate task sets thatfully load machines, and then simulate their execution on ma-chines of increasing speed. The capacity augmentation boundfor GEDF predicts that all task sets should be schedulableby the time the processor speed is increased to4 − 2

m. In

our simulation experiments, all task sets became schedulablebefore the speed reached 2.

We also compared GEDF with the only other known methodthat provides capacity bounds for scheduling multiple DAGs(with a DAG’s utilization potentially more than 1) on multi-cores [4]. In this method, which we callDECOMP, tasks aredecomposed into sequential subtasks and then scheduled usingGEDF.2 We find that GEDF without decomposition performsbetter than DECOMP for most task sets.

A. Task Sets and Experimental SetupWe generate two types of DAG tasks for evaluation. For

each method, we first fix the number of nodesn in the DAGand then add edges.

(1) Erdos-Renyi methodG(n, p) [36]: Each valid edgeis added with probabilityp, wherep is a parameter. Note thatthis method does not necessarily generate a connected DAG.Although the bound also does not require the DAG of a taskto be fully connected, connecting them can make it harder toschedule. Hence, we modified it slightly in the last step, toadd the fewest edges needed to make the DAG connected.

(2) Special synchronous taskL(n,m): As shown inFigure 4, task 1, synchronous tasks, in which highly parallelsegments follow sequential segments make scheduling difficultfor GEDF since they can cause deadline misses for other tasks.Therefore, we generate task sets with alternating sequentialand highly parallel segments. Tasks inL(n,m) (m is thenumber of processors) are generated in the following way.While the total number of nodes in the DAG is smaller thann, we add another sequential segment by adding a node, thengenerate the next parallel layer randomly. For each parallellayer, we uniformly generate a numbert between 1 and⌊ n

m⌋,

and set the number of nodes in the segment to bet ∗m.Given a task structure generated by either of the above

methods, worst case execution times for individual nodes inthe DAG are picked randomly between[50, 500] The criticalpath lengthLi for each task is then calculated. We then assigna period (equal to its deadline) to each task. Note that avalid deadline is at least the critical path length. Two typesof periods were assigned to tasks

1Note that, due to the lack of a schedulability test, it is difficult to test theresource augmentation bound of2−

1

mexperimentally.

2For DECOMP, end-to-end deadline (instead of decomposed subtask’sdeadline) miss ratios were reported.

(1) Harmonic Period: In this method, all tasks have periodsthat are integral powers of 2. We first compute the smallestvaluea such that2a is larger than a task’s critical path lengthLi. We then randomly assign the period either2a, 2a+1 or2a+2 to generate tasks with varying utilization. All tasks arethen released at the same time and simulated for the hyper-period of the tasks.

(2) Arbitrary Period: An arbitrary period is assigned inthe form (Li +

Ci

0.5m) ∗ (1 + 0.25 ∗ gamma(2, 1)), wheregamma(2, 1) is the Gamma distribution [37] withk = 2and θ = 1. The formula is designed such that, for smallm,tasks tend to have smaller utilization. This allows us to havea reasonable number of tasks in a task set for any value ofm.Task sets are created by adding tasks to them until the totalutilization reaches99% of m. These task sets were simulatedfor 20 times the longest period in a task set.

Several parameters were varied to test the system:G(n, p)vs L(n,m) DAGs, different p for G(n, p), Harmonic vsArbitrary Periods, Numbers of Coresm (4, 8, 16, 32, 64).For each setting, we generated a1000 task sets. We firstsimulated the task sets for each setting on processors of speed1, and increased the speed in steps of0.2. For each setting, wemeasured thefailure rate — the number of task sets whereany task missed its deadline.

B. Experiment Results1) Erdos-Renyi Method:For this method, we generate two

types of task sets: (1)Fixed p task sets: In this setting, alltask sets have the samep. We varied the values ofp from 0.01to 0.9. (2) Random p task sets: We also generated task setswhere each task has a different, randomly picked, value ofp.

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 210

−4

10−3

10−2

10−1

100

Speed up factor

Lo

gar

ith

mic

sca

le o

f fa

ilure

rat

io

DECOMP, p = 0.02GEDF, p = 0.02DECOMP, p = 0.1GEDF, p = 0.1DECOMP, p = 0.5GEDF, p = 0.5DECOMP, p = 0.9GEDF, p = 0.9

Fig. 6: Comparison asp changes (m = 64, harmonic period)

Figure 6 shows the failure rate for fixed-p task sets aswe varied p and kept m constant at 64. GEDF withoutdecomposition outperforms DECOMP for all settings ofp.It appears that GEDF has the hardest time whenp ≤ 0.1,where tasks are more sequential. But even then, all tasks areschedulable with speed1.8. At p > 0.1, GEDF never requiresspeed more than1.4, while DECOMP often requires a speedof 2 to schedule all task sets. Trends are similar for othervalues ofm.

10 20 30 40 50 601

1.2

1.4

1.6

1.8

2

2.2

m (number of cores)

Min

imu

m s

ched

ula

ble

sp

eed

up

fac

tor

DECOMP, p=0.02GEDF, p=0.02DECOMP, p=0.5GEDF, p=0.5

Fig. 7: Minimum schedulable speed up asm changes (harmonicperiod)

In addition to varyingp, we also varied the number of coresm. In Figure 7, among all different combinations we show theminimum schedulable speed up asm increases underp = 0.02andp = 0.5. Results for otherp andm are similar. This showsthat GEDF without decomposition generally needs smallerspeed up to schedule the same task sets. The increase ofm inthis experiment setting makes task sets harder to schedule formany cases, but largerm is not always worse.

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 20

0.001

0.01

0.1

1

Speed up factor

Lo

gar

ith

mic

sca

le o

f fa

ilure

rat

io

DECOMP, m = 4GEDF, m = 4DECOMP, m = 16GEDF, m = 16DECOMP, m = 64GEDF, m = 64

Fig. 8: Comparison asm changes (p = 0.02, harmonic period)

For the rest of the figures, we only show results withm = 4,16 and64, since the trends form = 8 and32 are similar.

Figure 8 shows the failure ratio of the fixed-p task setsas we keptp constant at0.02 and variedm. Again, GEDFoutperforms DECOMP for all settings. Whenm = 4, GEDFcan schedule all task sets at speed 1.4. The increase ofmdoes not influence DECOMP much, while it becomes slightlyharder for GEDF to schedule a few (out of 1000) task sets.

In addition to harmonic periods, we also run experimentsfor arbitrary periods for all different types of task sets. As thecomparison between Figure 9 and 8 suggest, the trends forarbitrary and harmonic periods are similar. Though it appearsthat tasks with arbitrary periods are easier to schedule using,especially for GEDF. This is at least partially explained bythe observation that, with harmonic periods, many tasks have

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 20

0.001

0.01

0.1

1

Speed up factor

Lo

gar

ith

mic

sca

le o

f fa

ilure

rat

io

DECOMP, m = 4GEDF, m = 4DECOMP, m = 16GEDF, m = 16DECOMP, m = 64GEDF, m = 64

Fig. 9: Comparison asm changes (p = 0.02, arbitrary period)

the same deadline, making it difficult for GEDF to distinguishbetween them. This trends holds for other types of task sets.So for brevity, we only show the experimental results forharmonic periods for the other experiments.

Figure 10 shows the failure ratio for GEDF and DECOMPfor task sets wherep is not fixed, but is randomly generated foreach task, as we varym. Again, GEDF outperforms DECOMP.Note, however, that it appears that GEDF appears to have aharder time here than in the fixedp experiment.

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 210

−4

10−3

10−2

10−1

100

Speed up factor

Lo

gar

ith

mic

sca

le o

f fa

ilure

rat

io

DECOMP, m = 4GEDF, m = 4DECOMP, m = 16GEDF, m = 16DECOMP, m = 64GEDF, m = 64

Fig. 10: Comparison asm changes(randomp, harmonic period)

2) Synchronous Method:Figure 11 shows the comparisonbetween GEDF and DECOMP with varyingm for syn-chronous task sets. In this case, the failure ratio for GEDFis higher than for task sets generated with the Erdos-RenyiMethod. We can also see that sometimes DECOMP outper-forms GEDF in terms of failure ratio and required speedup. This indicates that synchronous tasks with highly parallelsegments are indeed more difficult for GEDF to schedule.However, even in this case, we never require a speedup of morethan2. Even though Figure 4 demonstrates that there exist tasksets that require speedup of more than2, such pathological tasksets never appeared in our randomly generated sample.

Results indicate that GEDF performs better than predictedby the capacity augmentation bound. For most task sets, GEDFis better than DECOMP. Only among task sets intentionally

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 210

−4

10−3

10−2

10−1

100

Speed up factor

Lo

gar

ith

mic

sca

le o

f fa

ilure

rat

io

DECOMP, m = 4GEDF, m = 4DECOMP, m = 16GEDF, m = 16DECOMP, m = 64GEDF, m = 64

Fig. 11: Comparison asm changes (L(n,m) tasks, harmonicperiod)designed to be harder for GEDF to schedule, DECOMPperforms slightly better.

VII. C ONCLUSIONS

In this paper, we have presented the best bounds known forparallel tasks represented as DAGs under GEDF. In particular,we proved that GEDF provides a resource augmentation boundof 2 − 1/m for sporadic task sets with arbitrary deadlinesand a capacity augmentation bound of4− 2/m with implicitdeadlines. The capacity augmentation bound also serves as asimple schedulability test, namely, a task set is schedulableon m processors if (1)m is at least4 − 2

mtimes its total

utilization, and (2) the implicit deadline of each task is atleast4− 2

mtimes its critical path length. We also present simulation

results indicating this bound is safe; in fact, we never saw arequired capacity augmentation of more than 2 on randomlygenerated task sets in our simulations. Possible directionsof future work: First, we would like to extend the capacityaugmentation bounds to constrained and arbitrary deadlines; Inaddition, while we prove that a capacity augmentation boundof more than3+

√5

2 is needed, there is still a gap between thislower bound and the upper bound of(4 − 2/m) for capacityaugmentation, which we would like to close.

ACKNOWLEDGMENT

This research was supported in part by NSF grant CCF-1136073 (CPS)

REFERENCES

[1] A. Maghareh, S. J. Dyke, A. Prakash, G. Bunting, and P. Lindsay,“Evaluating modeling choices in the implementation of real-time hybridsimulation,” in EMI/PMC 2012.

[2] K. Lakshmanan, S. Kato, and R. R. Rajkumar, “Scheduling parallel real-time tasks on multi-core processors,” inRTSS ’10.

[3] A. Saifullah, K. Agrawal, C. Lu, and C. Gill, “Multi-corereal-timescheduling for generalized parallel task models,” inRTSS ’11.

[4] A. Saifullah, D. Ferry, K. Agrawal, C. Lu, and C. Gill, “Real-timescheduling of parallel tasks under a general dag model,” WashingtonUniversity in St Louis, USA, Tech. Rep. WUCSE-2012-14, 2012.

[5] D. Ferry, J. Li, M. Mahadevan, K. Agrawal, C. Gill, and C. Lu, “Areal-time scheduling service for parallel tasks,” inRTSS ’13.

[6] J. Lelli, D. Faggioli, T. Cucinotta, and S. Superiore, “An efficient andscalable implementation of global edf in linux,” inOSPERT ’11.

[7] B. B. Brandenburg and J. H. Anderson, “On the implementation ofglobal real-time schedulers,” inRTSS ’09.

[8] S. Baruah, V. Bonifaciy, A. Marchetti-Spaccamelaz, L. Stougiex, andA. Wiese, “A generalized parallel task model for recurrent real-timeprocesses,” inRTSS ’12.

[9] C. Liu and J. Anderson, “Supporting soft real-time parallel applicationson multicore processors,” inRTCSA ’12.

[10] N. Fisher, J. Goossens, and S. Baruah, “Optimal online multiprocessorscheduling of sporadic real-time tasks is impossible,”Real-Time Syst.,vol. 45, no. 1-2, pp. 26–71, 2010.

[11] C. D. Polychronopoulos and D. J. Kuck, “Guided self-scheduling: Apractical scheduling scheme for parallel supercomputers,” IEEE Trans-actions on Computers, vol. C-36, no. 12, pp. 1425–1439, 1987.

[12] M. Drozdowski, “Real-time scheduling of linear speedup parallel tasks,”Inf. Process. Lett., vol. 57, no. 1, pp. 35–40, 1996.

[13] X. Deng, N. Gu, T. Brecht, and K. Lu, “Preemptive scheduling of paralleljobs on multiprocessors,” inSODA ’96.

[14] K. Agrawal, C. E. Leiserson, Y. He, and W. J. Hsu, “Adaptive work-stealing with parallelism feedback,”ACM Trans. Comput. Syst., vol. 26,September 2008.

[15] J. M. Calandrino and J. H. Anderson, “On the design and implementationof a cache-aware multicore real-time scheduler,” inECRTS ’09.

[16] J. H. Anderson and J. M. Calandrino, “Parallel real-time task schedulingon multicore platforms,” inRTSS ’06.

[17] Q. Wang and K. H. Cheng, “A heuristic of scheduling parallel tasks andits analysis,”SIAM J. Comput., vol. 21, no. 2, 1992.

[18] O.-H. Kwon and K.-Y. Chwa, “Scheduling parallel tasks with individualdeadlines,”Theor. Comput. Sci., vol. 215, no. 1-2, pp. 209–223, 1999.

[19] R. I. Davis and A. Burns, “A survey of hard real-time scheduling formultiprocessor systems,”ACM Comp. Surv., vol. 43, pp. 35:1–44, 2011.

[20] B. Andersson, S. Baruah, and J. Jonsson, “Static-priority scheduling onmultiprocessors,” inRTSS ’01, dec. 2001, pp. 193–202.

[21] A. Srinivasan and S. Baruah, “Deadline-based scheduling of peri-odic task systems on multiprocessors,”Information Processing Letters,vol. 84, no. 2, pp. 93 – 98, 2002.

[22] J. Goossens, S. Funk, and S. Baruah, “Priority-driven scheduling ofperiodic task systems on multiprocessors,”Real-Time Systems, vol. 25,no. 2, pp. 187–205, 2003.

[23] M. Bertogna, M. Cirinei, and G. Lipari, “Schedulability analysis ofglobal scheduling algorithms on multiprocessor platforms,” Parallel andDistributed Systems, vol. 20, no. 4, pp. 553 –566, april 2009.

[24] S. Baruah and T. Baker, “Schedulability analysis of global edf,” Real-Time Systems, vol. 38, no. 3, pp. 223–235, 2008.

[25] T. Baker and S. Baruah, “Sustainable multiprocessor scheduling ofsporadic task systems,” inECRTS ’09, july 2009, pp. 141 –150.

[26] J. Lee and K. G. Shin, “Controlling preemption for better schedulabilityin multi-core systems,” inRTSS ’12, Dec. 2012.

[27] S. Baruah, “Optimal utilization bounds for the fixed-priority schedulingof periodic task systems on identical multiprocessors,”Computers, IEEETransactions on, vol. 53, no. 6, pp. 781–784, june 2004.

[28] M. Bertogna and S. Baruah, “Tests for global edf schedulability analy-sis,” J. Syst. Archit., vol. 57, no. 5, pp. 487–497, 2011.

[29] W. Y. Lee and H. Lee, “Optimal scheduling for real-time parallel tasks,”IEICE Trans. Inf. Syst., vol. E89-D, no. 6, pp. 1962–1966, 2006.

[30] S. Collette, L. Cucu, and J. Goossens, “Integrating jobparallelism inreal-time scheduling theory,”Inf. Process. Lett., vol. 106, no. 5, pp.180–187, 2008.

[31] G. Manimaran, C. S. R. Murthy, and K. Ramamritham, “A newap-proach for scheduling of parallelizable tasks in real-timemultiprocessorsystems,”Real-Time Syst., vol. 15, no. 1, pp. 39–60, 1998.

[32] S. Kato and Y. Ishikawa, “Gang EDF scheduling of parallel tasksystems,” inRTSS ’09.

[33] N. Fisher, S. Baruah, and T. P. Baker, “The partitioned scheduling ofsporadic tasks according to static-priorities,” inECRTS ’06.

[34] L. Nogueira and L. M. Pinho, “Server-based scheduling of parallel real-time tasks,” inInternational Conference on Embedded Software, 2012.

[35] V. Bonifaci, A. Marchetti-Spaccamela, S. Stiller, andA. Wiese, “Feasi-bility analysis in the sporadic dag task model,” inECRTS ’13.

[36] D. Cordeiro, G. Mouni, S. Perarnau, D. Trystram, J.-M. Vincent, andF. Wagner, “Random graph generation for scheduling simulations,” inSIMUTools ’10.

[37] “Gamma distribution,” http://en.wikipedia.org/wiki/Gammadistribution.