Real-Time Scheduling on Uni- and Multiprocessorsbased on Priority Promotions∗

Risat Mahmud Pathan

Chalmers University of TechnologySE-412 96, Göteborg, Swedenrisat@chalmers.se

AbstractThis paper addresses the problem of real-time

scheduling of a set of sporadic tasks on uni- and multipro-cessor platform based on priority promotion. A new pre-emptive scheduling algorithm, called Fixed-Priority withPriority Promotion (FPP), is proposed. In FPP schedul-ing, tasks are executed similar to traditional fixed-priority(FP) scheduling but the priority of some tasks are pro-moted at fixed time interval (called, promotion point)relative to the release time of each job. A policy called In-crease Priority at Deadline Difference (IPDD) to computethe promotion points and promoted priorities for each taskis proposed. FPP scheduling prioritizes jobs accordingto Earliest-Deadline-First (EDF) priority when all tasks’priorities follow IPDD policy.

It is known that managing (i.e., inserting and remov-ing) jobs in the ready queue of traditional EDF scheduleris more complex than that of FP scheduler. To avoid such

problem in FPP scheduling, a simple data structure andefficient operations to manage jobs in the ready queue areproposed. In addition, techniques for implementing pri-ority promotions with and without using hardware timerare proposed.

Finally, an effective scheme to reduce average num-ber of priority promotion is proposed: if a task set is notschedulable using traditional FP scheduling, then pro-motion points are assigned only to those tasks that needthem to meet the deadlines; otherwise, tasks are assignedtraditional fixed priorities without any priority promotion.Empirical investigation shows the effectiveness of the pro-posed scheme in reducing overhead on uniprocessor andin accepting larger number of task sets in comparison tothat of using state-of-the-art global schedulability testsfor multiprocessors.

2012 ACM Subject Classification Real-time systems, Process management, Scheduling, Embedded and cyber-physical systemsKeywords and phrases Real-Time Systems, Priority Promotion, Schedulability Analysis, Schedulability Condi-tionDigital Object Identifier 10.4230/LITES.xxx.yyy.pReceived Date of submission. Accepted Date of acceptance. Published Date of publishing.

Editor LITES section area editor

1 Introduction1

The thirst to utilize increasingly more processing capacity of underlying hardware platform while meeting2

the deadlines of hard real-time sporadic tasks has resulted in the design of numerous scheduling algorithms.3

The preemptive dynamic-priority-based EDF scheduling is an optimal algorithm for uniprocessor: if there4

is an algorithm that can schedule a task set such that all the deadlines are met, then the task set is also5

schedulable using EDF scheduling [17]. In contrast, fixed-priority scheduling does not provide such a6

guarantee, even under the (optimal for uniprocessor) Deadline-Monotonic (DM) priority assignment [23].7

For uniprocessor, although EDF can better utilize the processing capacity, many practical systems8

implement FP scheduling due to its efficient run-time support and low overhead in managing the ready9

∗ This research has been funded by the MECCA project under the ERC grant ERC-2013-AdG 340328-MECCA and by theARTEMIS Joint Undertaking under grant agreement no. 621429.

© Risat Mahmud Pathan;licensed under Creative Commons License CC-BY

Leibniz Transactions on Embedded Systems, Vol. XXX, Issue YYY, pp. 1–26Leibniz Transactions on Embedded SystemsSchloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany

2 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

queue. For multiprocessors, there is no evidence whether global fixed-priority (G-FP) scheduling dominates10

or is dominated by the global earliest-deadline first (G-EDF) scheduling: some task set may only be deemed11

schedulable using the state-of-the-art G-EDF test while others only using G-FP test [15]. The question this12

paper addresses is: can we combine the schedulability and implementation benefits of both FP and13

EDF?14

In many real-time systems, e.g., avionics, spacecraft and automotive, it is important to efficiently use15

the processing resources due to size, weight and power constraints. Reducing overhead of task scheduling16

in such systems can cut cost for mass production of, for example, cars, trucks or aircraft. A theoretically17

“good” scheduling algorithm may not be used in practice if overhead of implementation (e.g., managing18

tasks in the ready queue) is large. This paper proposes an unifying approach to integrate the schedulability19

and implementation benefits of both FP and EDF scheduling.20

A new preemptive scheduling algorithm, called Fixed Priority with Priority Promotion (FPP), is21

proposed in this paper. Under FPP scheduling, each task has a fixed priority that may undergo priority22

promotion at fixed time interval (called, promotion points) relative to the release time of each job. For23

example, consider task τi that has (initial) fixed priority p with two promotion points δ1 and δ2 at which24

the priority of the task is promoted to priority levels p1 and p2 such that δ1 < δ2 and p2 < p1 < p (lower25

priority value implies higher fixed priority). If a job of task τi is released at time ri, the priority of this job26

is p at time ri and promoted to priority levels p1 and p2 at time (ri + δ1) and (ri + δ2), respectively. After27

a task’s priority is promoted, its priority remains at this promoted priority until either (i) the task completes28

execution, or (ii) another promotion point is reached at which the task’s priority is again promoted. As29

will be evident later, two or more jobs may have the same fixed priorities due to priority promotion.30

The FPP scheduler has a special tie-breaking policy in such case: a newly released job cannot preempt31

a currently-executing job if both of these jobs have the same priority. Other than priority promotion,32

FPP scheduling is same as traditional FP scheduling on uniprocessor and multiprocessors1 platform while33

applicable to implicit-, constrained- or arbitrary-deadline sporadic tasks.34

The FPP scheduler consists of a dispatcher and a ready-queue manager. The dispatcher at each time35

instant dispatches the highest-priority ready job if a processor is idle. If all the processors are busy, then36

a newly released job with higher priority can preempt a currently-executing relatively lower priority job.37

Active jobs that cannot be executed wait in the ready queue. The ready-queue manager inserts and removes38

jobs to and from the ready queue. The ready-queue manager also takes care of priority promotion of the39

jobs that are currently awaiting execution in the ready queue.40

The effectiveness of FPP scheduling in meeting the deadlines of the tasks depends on the promotion41

points and promoted priorities of each task. A simple policy called Increase Priority at Deadline Difference42

(IPDD) to compute (offline) the promotion points and promoted priorities for each task is proposed. When43

all the tasks are assigned priorities based on IPDD policy, it will be shown that the FPP scheduling44

essentially prioritizes jobs of the tasks according to EDF priority. Executing jobs of the tasks in EDF order45

but using priority-promotion-based FPP scheduler is one of the major contributions in this paper.46

Since jobs can be prioritized in EDF order, the management of jobs in the ready queue of FPP scheduler47

would suffer from the same overhead problems (as discussed by Buttazzo [12]) if it is implemented48

similar to that of traditional EDF scheduler. On the other hand, the ready queue management and run-time49

support for traditional FP scheduling is much simpler, which is the main reason for its popularity in many50

commercial real-time kernels. This paper proposes a simple data structure and constant-time, i.e., O(1)51

operations for implementing the ready queue. The ready queue management using the proposed scheme52

has similar benefits as that of traditional FP scheduler, which is another major contribution of this paper.53

The only source of additional overhead for managing the jobs in the ready queue of FPP scheduler54

1 In this paper, the term “FPP scheduling” in general applies to scheduling on uniprocessor and multiprocessors. Formultiprocessors, FPP scheduling means global FP scheduling with priority promotion.

R. M. Pathan 3

in comparison to that of FP scheduler is the cost of priority promotion. To reduce such overhead due to55

priority promotion, a joint priority assignment and schedulability test, called FPP_Test, is proposed for56

FPP scheduling. The FPP_Test assigns traditional fixed priorities (with no promotion point) to some57

tasks while assigns priorities to other tasks (with promotion points) using IPDD policy. Such priority58

assignment is effective for task set that is neither schedulable using pure FP scheduling nor using pure59

EDF scheduling. The FPP_Test thus combines the schedulability benefits of both fixed and dynamic (i.e.,60

IPDD) priorities in addition to having the similar implementation benefits of traditional FP scheduler.61

To measure the effectiveness of FPP scheduling in terms of reducing overhead for managing jobs in62

the ready queue in comparison to that of EDF scheduling, the execution of randomly generated task sets is63

simulated using both FPP and EDF scheduling. The ready queues are simulated using the proposed data64

structure (presented in Subsection 4.2.1) for FPP scheduler and using a priority queue implemented as65

a binary min-heap (as is used in [9]) for EDF scheduler. The simulation result shows that ready queue66

management of FPP scheduler suffers significantly less overhead in comparison to that of EDF scheduler.67

The FPP_Test is applicable to both uniprocessor and multiprocessor platform. On uniprocessor68

platform, any task set schedulable using the optimal preemptive EDF scheduling is also schedulable using69

FPP scheduling. Thus, FPP is also optimal for uniprocessor. On multiprocessor platform, it will be shown70

that the FPP_Test dominates both the state-of-the-art G-FP and G-EDF tests. Simulation result shows71

the effectiveness of FPP scheduling in determining higher percentage of schedulable task sets and in72

reducing the number of preemptions and migrations.73

Finally, techniques to implement priority promotion with and without using hardware timer are proposed.74

We tackle the challenge of using one hardware timer to implement multiple priority promotions that are75

due at some later time. In addition, we also address the problem of implementing priority promotions76

without using a timer (i.e., based on pure software approach). In such software-based approach, a technique77

called delayed promotion is used: some jobs’ priority promotions are delayed until it is necessary to ensure78

specific property of the underlying schedule.79

Related Work. The FPP algorithm is similar to the well-known dual-priority scheduling which was first80

proposed by Burns and Wellings [10] in 1993, and analyzed by Davis and Wellings [13, 14] considering81

shared resources, release jitter and for scheduling soft real-time tasks. In dual-priority scheduling, each task82

undergoes priority promotion only once. In contrast, a task in FPP scheduling may have more than one83

promotion point. The reason for having more than one promotion point is to have the power to prioritize84

jobs in EDF order to meet deadlines.85

Gonzalez Harbour et al. [19] considered scheduling FP scheduling of periodic tasks where each task is86

divided into a collection of precedence-constrained subtasks such that each subtask has its own priority. It87

is shown using an example by Burns and Wellings [10] that a task set may be schedulable in dual-priority88

scheduling and may not be schedulable using the approach proposed by Gonzalez Harbour et al. [19]. After89

around one-and-half decade, Burns [11] presented an open problem at the RTSOPS seminar in ECRTS90

2010: Is the utilization bound of dual-priority scheduling of implicit-deadline tasks on uniprocessor 100%?91

While Burns [11] solved this problem for task set having n = 2 tasks, the answer to this question for92

n > 2 is still unknown for dual-priority scheduling. This paper will show that the utilization bound of93

FPP scheduling of implicit-deadline tasks on uniprocessor is 100% for any n.94

Organization. The rest of the paper is organized as follows. Section 2 presents the task model. The95

IPDD policy and important lemmas of this policy are presented in Section 3. The dispatcher and ready96

queue manager of FPP scheduler are presented in Section 4. Technique to reduce the total number of97

promotion points, particularly, the FPP_Test is proposed in Section 5. The FPP_Test is applied to both98

uni- and multiprocessors considering constrained-deadline tasks and experimental results are presented in99

Section 6 and Section 7, respectively. Techniques to implement priority promotions for FPP scheduling are100

proposed in Section 8. Finally, Section 9 concludes this paper.101

4 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

2 Task Model102

This paper considers scheduling a collection of n sporadic tasks in set Γ = {τ1, . . . τn}. Each task τi is103

characterized by a triple (Ci, Di, Ti), where Ci represents the worst-case execution time (WCET), Di is104

the relative deadline, and Ti is the minimum inter-arrival time of the jobs or instances of task τi. Successive105

arrivals of the instances (called jobs) of task τi are separated by at least Ti time units. Each job of task τi106

after its release requires at most Ci units of execution time before its relative deadline. The release time107

and absolute deadline of job Ja of task τi are respectively denoted by ra and da such that da = ra +Di.108

A job is called active if it is released but has not completed its execution. An active job may be in109

execution or awaiting execution in the ready queue at any time instant. The FPP scheduling is applicable to110

implicit-, constrained- and arbitrary-deadline tasks. This paper assumes that lower priority value implies111

higher priority levels; i.e., 1 and n are the highest and lowest priority levels, respectively.112

3 Priority Promotion Policy: IPDD113

The effectiveness of FPP scheduling depends on the promotion points and promoted priorities for each114

task. In this section, the IPDD priority-promotion policy that can prioritize jobs of the tasks in EDF order115

while executing using priority-promotion-based FPP scheduling is presented.116

The IPDD priority-promotion policy requires n distinct fixed-priority levels to determine the promotion117

points and promoted priorities of n tasks. Tasks are indexed in deadline-monotonic order, i.e., if j < i for118

any two tasks τj and τi, then Dj ≤ Di. Therefore, there are (i− 1) tasks (i.e., τ1, τ2, . . . τi−1) that have119

their relative deadlines no larger than that of task τi. The IPDD policy computes the promotion points and120

promoted priorities for each task τi ∈ Γ as follows:121

Task τi has i different priority levels: starting from priority level i to the highest priority level 1. Task122

τi’s initial priority i is promoted (i− 1) times. At each of the (i− 1) promotion points, the priority is123

promoted by one priority level. Figure 1 depicts IPDD priority-promotion policy for task τi.124

Each job of task τi when released has (initial) priority level i, which is promoted to priority level (i− 1)125

at the first promotion point; then promoted to priority level (i− 2) at the second promotion point; and126

continuing in this manner, finally, promoted to the (highest) priority level 1 at the last, i.e., (i− 1)th127

promotion point.128

The promotion points apply to each job of task τi. Each promotion point of a job is a fixed time129

interval from the release time of the job. The κth promotion point is equal to the (relative) dead-130

line difference of tasks τi and τi−κ, which is equal to (Di − Di−κ). The priority of each job131

of τi is promoted to priority level (i − κ) at the κth promotion point which is (Di −Di−κ) time132

units later than its release time, for κ = 1, 2, . . . (i− 1). Since Di ≥ Di−1 . . . ≥ D1, we have133

(Di −Di−1) ≤ (Di −Di−2) . . . ≤ (Di −D1), which implies that priority of task τi is non-decreasing.134

If any two tasks τi and τj , where i < j, have the same relative deadline, then task τj’s initial priority135

is i (not j) since Dj − Di = 0 and the promotion points of τj are computed the same way that are136

computed for τi.137

Each task τi has i priority levels i, (i − 1), . . . 1 with total (i − 1) promotion points. And, each task138

τj has j priority levels j, (j − 1), . . . i, (i− 1), . . . 1 with total (j − 1) promotion points where i < j. In139

other words, according to IPDD policy, i priority levels are common (shared) for any two tasks τi and τj140

whenever i < j. Due to sharing of priority levels, the number of distinct fixed-priority levels required141

to assign priorities to all the n tasks is at most n. As will be evident later, if two or more newly released142

jobs have the same initial priority, the FPP scheduler breaks the tie arbitrarily. If a newly released job has143

the same priority as that of a currently-executing job, the new job does not preempt the executing job in144

FPP scheduling. Example 1 demonstrates the IPDD policy using an example of three tasks.145

R. M. Pathan 5

Figure 1 IPDD priority-promotion policy for task τi. Consider that an arbitrary job of task τi is released at timeri and has deadline at di = ri +Di. The dotted vertical lines are the promotion points. The κth promotion points is(Di −Di−κ) time units later than time ri for κ = 1, 2 . . . (i− 1). Between two consecutive promotion points ta andtb, the priority of the job remains at the priority level set at the earlier promotion point ta.

I Example 1. Consider (Ci, Di, Ti) for three tasks τ1 ≡ (1, 2, 4), τ2 ≡ (4, 7, 8) and τ3 ≡ (3, 10, 16). In146

IPDD policy, each job of task τ1 starts with priority level 1 which is never promoted since there is no other task with147

smaller relative deadline than D1. If a job of task τ1 is released at time r1, then the priority of this job remains at148

priority level 1 during [r1, r1 +D1).149

Figure 2 FPP schedule of three tasks in Example 1 where each task is assigned priorities using IPDD policy. Notethat task τ3’s priority is promoted to priority level 1 at time t = 8 and is not preempted by the third job of task τ1 that isreleased at time t = 8 although both jobs have the same priority. This is because a newly released job cannot preempt acurrently executing job if both have the same priority in FPP scheduling.

Since there is one other task (i.e., τ1) with smaller relative deadline than D2, each job of τ2 starts with priority150

level 2, which is promoted exactly once at time r2 + (D2 −D1) = r2 + (7− 2) = r2 + 5, where r2 is the release151

time of an arbitrary job of τ2. The priority of the job remains at priority level 2 and 1 respectively during [r2, r2 + 5)152

and [r2 + 5, r2 +D2) = [r2 + 5, r2 + 7).153

Since there are two other tasks (i.e., τ1 and τ2) with smaller relative deadlines than D3, each job of τ3 starts with154

priority level 3, which is promoted twice — first at time r3 + (D3−D2) = r3 + (10−7) = r3 + 3 and second at time155

r3 +(D3−D1) = r3 +(10−2) = r3 +8, where r3 is the release time of an arbitrary job of τ3. The priority of the job156

is at priority level 3, 2 and 1 respectively during [r3, r3 +3), [r3 +3, r3 +8) and [r3 +8, r3 +D3) = [r3 +8, r3 +10).157

The FPP schedule of this task set (assuming strictly periodic release for all tasks staring from time 0) is given in158

Figure 2 (the scheduler is formally presented in subsection 4.1).159

The remainder of this section presents important Lemmas regarding the properties of IPDD policy and will160

be used to show that FPP scheduling generates EDF schedule.161

I Lemma 1. If the priority of job Ja is promoted to priority level ` at time ta, then (da − ta) = D`.162

6 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

Proof. Assume that job Ja is a job of task τi. Therefore, da = ra +Di. According to IPDD policy,163

ta = ra + (Di −D`). Consequently, (da − ta) = D`. J164

I Lemma 2. If job Ja has higher priority than another job Jb at time t according to IPDD policy, then165

1. the deadline da is smaller than the deadline db, and166

2. Ja’s priority never becomes smaller than that of Jb.167

Proof. Consider that Ja and Jb have priorities ν and ` at time t where ν < `. We will show that168

(1) da < db, and (2) Ja’s priority is never becomes smaller than that of Jb.169

Since Jb’s priority is ` at time t, its priority will ultimately be promoted to (higher) priority level ν170

according to IPDD policy. Let Jb’s priority will be promoted to priority ν at time tb where t < tb. On the171

other hand, Ja’s priority is already at priority ν at time t. Let Ja’s priority was set to priority ν at time ta172

where ta ≤ t. Therefore, ta < tb. From Lemma 1, it follows that (da − ta) = Dν and (db − tb) = Dν .173

Since ta < tb, it follows that da < db (part (1) is proved).174

It follows from IPDD policy that the priorities of Ja and Jb are set to priority level κ, for κ =175

ν, (ν − 1), . . . 1, respectively at time (ta + Dν − Dκ) and (tb + Dν − Dκ). Since ta < tb, we have176

(ta + Dν − Dκ) < (tb + Dν − Dκ) for κ = ν, . . . 1. Therefore, priority of Ja is promoted to higher177

priority level earlier than that of Jb. Any job having priority κ remains at priority level κ for duration of178

(Dκ −Dκ−1) time units in IPDD policy. Therefore, Ja’s priority is never smaller than that of Jb (part (2)179

is proved). J180

I Lemma 3. Consider that job Ja has priority ` at time t according to IPDD promotion policy. If a new181

job Jb of task τ` is released at time t, then the da ≤ db.182

Proof. According to IPDD policy, job Jb of task τ` has priority ` at time t since it is released at time t.183

Since Jb is released at time t, we have (db − t) = D`.184

Job Ja’s priority is already at priority ` at time t. Let Ja’s priority was set to priority level ` at time185

ta where ta ≤ t. From Lemma 1, we have (da − ta) = D`. Since ta ≤ t, we have (da − t) ≤ D`. From186

(db − t) = D` and (da − t) ≤ D`, its follows that da ≤ db. J187

I Lemma 4. Consider set J of active jobs. If all the jobs in J have same priority ` at some time instant,188

then the job with the earliest deadline is promoted to priority level ν no later than that of any other job in189

J , where ν < `.190

Proof. Consider any two jobs Ja and Jb in J . Without loss of generality assume that da ≤ db. Let Ja191

and Jb are promoted to higher-priority level ν at time ta and tb, respectively. We will show that ta ≤ tb,192

which implies that Ja with deadline no later than that of Jb is promoted to priority level ν no later than that193

of job Jb. It follows from Lemma 1 that (da − ta) = Dν and (db − tb) = Dν . Since da ≤ db, we have194

ta ≤ tb. J195

It will be shown based on Lemmas 1–4 that the FPP scheduling generates the EDF schedule of the196

tasks when priorities to all the tasks are given using IPDD policy. The dispatcher and the ready queue197

manager of FPP scheduler are presented in Section 4. Then Section 5 presents techniques to reduce the198

number of promotion points by not assigning priorities to all the tasks using IPDD policy (i.e., some tasks199

have no promotion point).200

4 Dispatcher and Ready Queue Manager201

The dispatcher of the FPP scheduler determines which active job to execute while the ready-queue manager202

is responsible for managing the ready jobs in the ready queue.203

R. M. Pathan 7

4.1 The Dispatcher204

The dispatcher of FPP scheduler considering global multiprocessor scheduling on m identical processors205

is presented below. When m = 1, this dispatcher applies to uniprocessor. In addition, some important206

events related to the operations performed by the ready-queue manager are also highlighted below. The207

FPP dispatcher at each time t works as follows.208

At most m highest-priority jobs at time t are dispatched for execution. If t is the promotion point for a209

currently-executing job, then its priority is promoted2 at time t.210

If all the m processors are busy and a new job Jnew with priority higher than that of the currently-211

executing lowest-priority job Jexe_low is released at time t, then Jnew starts execution by preempting212

Jexe_low. The preempted job Jexe_low is inserted in the ready queue. This (insertion) event managed by213

the ready-queue manager is called the “rel_prmt” event.214

If all the m processors are busy and a new job Jnew with priority not higher than that of the currently-215

executing lowest-priority job Jexe_low is released at time t, then Jnew does not preempt Jexe_low. And,216

Jnew is inserted in the ready queue. This (insertion) event managed by the ready-queue manager is217

called the “rel_no_prmt” event. Note that if Jnew has the same priority as that of Jexe_low (ties in218

priority ordering), then Jnew does not preempt Jexe_low.219

If some processor becomes idle while the ready queue is not empty, then the job having the highest220

priority from the ready queue is removed and dispatched for execution on the idle processor. The221

ready-queue manager performs this removal and this event is called the “idle_remv” event.222

In summary, the FPP dispatcher works similar to traditional global FP scheduler with one additional223

feature: jobs may undergo priority promotion. If the total number of active jobs is not more than m, then224

all active jobs are in execution and the ready queue is empty. If the total number of active jobs is more225

than m, then all the processors are busy and some active jobs are in the ready queue. Example 1 presents226

the FPP schedule for three tasks. Theorem 5 proves that FPP scheduling executes jobs in EDF order if all227

tasks have priorities based on IPDD.228

I Theorem 5. If tasks are given priorities based on the IPDD policy, then the jobs of the tasks are229

executed in EDF order by the FPP scheduler at each time instant t.230

Proof. If the number of active jobs is no more than m, then each active job is executing at time t on231

separate processor. The claim of this theorem holds trivially.232

Now consider the case when the number of active jobs is exactly m at time t. If a new job Jnew arrives233

at time t (i.e., number of active job becomes larger than m) such that the priority of Jnew is not higher than234

that of the currently-executing lowest-priority job Jexe_low, then Jnew is inserted in the ready queue. If235

Jnew’s priority is smaller than that of Jexe_low, then from Lemma 2 it follows that the absolute deadline236

of job Jnew is larger than that of job Jexe_low. If Jnew’s priority is equal to Jexe_low, then it follows from237

Lemma 3 that the deadline of job Jnew is not smaller than that of job Jexe_low. Similarly, since Jexe_low is238

the currently-executing lowest-priority job, its deadline is not smaller than any other currently-executing239

job. Therefore, job Jnew with EDF priority not higher than any of the currently-executing job is inserted in240

the ready queue.241

2 For example, to perform the promotion, a special task can be designed whose only job is to promote the priority of theapplication tasks, as pointed by Burns [10] for dual-priority scheduling. In addition, all the priority promotions of acurrently-executing job may be postponed until a new job is released. This is because the execution of a currently-executingjob may be interfered only if a new job is released. When a new job is released at time t, the priority of the currently-executing job is determined considering the last priority promotion at or immediately before t. This can avoid unnecessaryoverhead due to priority promotion of the executing tasks. Section 8 will present different hardware and software-basedtechniques to implement priority promotion.

8 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

On the other hand, if Jnew has higher priority than that of job Jexe_low, then Jnew preempts the242

execution of Jexe_low and Jexe_low is inserted in the ready queue. According to Lemma 2, job Jnew has243

earlier deadline than that of job Jexe_low. Therefore, job Jexe_low having a relatively lower EDF priority is244

inserted in the ready queue.245

According to Lemma 2, if job Ja is prioritized by the dispatcher over another job Jb, then job Jb will246

never have higher priority (even if its priority might be promoted) than job Ja at another (future) time247

instant. Consequently, if job Jb is inserted in the ready queue because it cannot be prioritized by the248

dispatcher over another job Ja, then job Jb from the ready queue (even if its priority might be promoted)249

cannot preempt the execution of job Ja at some other (later) time. Therefore, no job that is inserted in the250

ready queue can preempt the jobs that are in execution.251

Whenever some processor becomes idle at time twhile the ready queue is not empty, the highest-priority252

job from the ready queue is removed and dispatched for execution. However, due to priority promotion,253

there may be multiple jobs waiting at the highest priority level in the ready queue. It will be shown in254

subsection 4.2 that the ready-queue manager (when handling the idle_remv event) removes the job with255

shortest deadline (i.e., highest-priority EDF job) from the ready queue. Therefore, jobs are executed in256

EDF priority order in FPP scheduling in all cases. J257

Now we concentrate on the ready queue manager, in particular, the events it has to manage. In addition258

to the rel_prmt, rel_no_prmt and idle_remv events, the ready queue manager needs to handle259

another event. If some job’s priority is to be promoted while that job is awaiting execution in the ready260

queue, the ready-queue manager needs to manage this promotion. This event managed by the ready-queue261

manager is called “pri_prom” event. Therefore, the ready-queue manager needs to handle four different262

events: rel_prmt, rel_no_prmt, idle_remv and pri_prom. If multiple events occur at the same263

time, they are managed by the ready-queue manager in any order.264

A note on ready-queue manager for FP scheduler. The ready-queue manager of traditional FP schedul-265

ing also needs to manage the rel_prmt, rel_no_prmt and idle_remv events. The ready-queue for266

FP scheduler can be implemented as an array of length n where task control blocks (TCBs) of the ready267

tasks are stored. The κth position of the array stores the TCB of the ready task that has current priority κ268

for κ = 1, . . . n.269

If rel_prmt or rel_no_prmt event occurs, then a job (particularly, Jexe_low or Jnew) is inserted270

in the ready queue. If a job of task τκ is to be inserted in the ready-queue, then the priority of τκ is used271

to index the ready-queue array position at which the TCB of τκ is stored. Therefore, insertion is done in272

constant time.273

If an idle_remv event occurs, then the highest-priority job from the ready queue is removed and274

dispatched for execution. Finding the highest-priority job from the ready-queue can be performed in275

constant time as follows. A bitmap array B[n . . . 1] of the ready-queue array is maintained. Initially, all the276

elements in bitmap B are zero to specify that there is no job awaiting execution at any priority level in the277

ready-queue array. When a job with priority κ is inserted in to the ready-queue array, the κth bit of the278

bitmap is set (i.e., B[κ] = 1) to specify that there is a job awaiting execution in the ready queue at priority279

level κ. Determining the highest-priority job from the ready queue is to find the position of the least set bit280

in the bitmap B[n . . . 1], which can be performed in constant time using, for example, deBruijn sequence281

[22], if not supported as a machine-level instruction [27]. Once the position is known, the TCB of the job282

is removed and corresponding job is dispatched and we set B[κ] = 0. An interesting discussion how the283

highest-priority task from the ready queue can be removed efficiently for FP scheduling can be found in284

[27].285

In FP scheduling at most one element (i.e., job) is stored at each priority level in the ready queue. If the286

number of supported priority levels is smaller than the number of fixed-priority tasks, then the ready queue287

may be split into n different priority levels as is discussed by Buttazzo in [12]. In such case, the a FIFO288

queue is maintained at each priority level.289

R. M. Pathan 9

A note on ready-queue manager for EDF scheduler. Implementing EDF requires to keep track of all290

absolute deadlines and perform a dynamic mapping between absolute deadlines and priorities. If the291

number of possible absolute deadlines for all the active tasks is larger than the the total number of distinct292

priority levels, managing the ready tasks is complex in EDF scheduling. If the number of active tasks293

is smaller than the number of different priority levels, updating the ready queue has higher overhead in294

comparison to that of FP scheduling, as is discussed by Buttazzo [12].295

In the worst case, all the ready jobs may need to be remapped to new priority levels, which increases296

the overhead of ready queue management. The complexity and overhead in managing ready queue of297

EDF scheduler make it less popular in commercial kernel although EDF always performs better in terms of298

schedulability on uniprocessor.299

Theorem 5 shows that the FPP scheduling executes jobs similar to EDF when tasks are given priorities300

using IPDD policy. However, managing jobs in the ready queue of FPP scheduler, if implemented similar301

to that of known for EDF, will have the same overhead problems that EDF suffers. In this paper, a new302

ready-queue management scheme for FPP scheduler is proposed. In particular, a data structure for the ready303

queue and constant-time operations to manage each of the rel_prmt, rel_no_prmt, idle_remv and304

pri_prom events is proposed.305

In FPP scheduling, if the priority of a currently-executing job is promoted, then such promotion does306

not remap any job in the ready queue. However, if the priority of a job residing in the ready queue is307

promoted, then such promotion (as will be evident shortly) remaps that job to a new position in the ready308

queue data structure and thus incurs overhead.309

Inspired by the discussion of Buttazzo [12], the overhead model this paper considers is the sum of310

total number of times each of the jobs in the ready queue is remapped to some other position. It will be311

empirically shown, based on this overhead model, that FPP scheduler has significantly lower overhead312

than that of EDF. Such low overhead of FPP scheduler shall make it popular in practice.313

4.2 The Ready Queue Manager.314

This subsection presents the data structure of the ready queue and operations to handle the events315

rel_prmt, rel_no_prmt, idle_remv and pri_prom.316

4.2.1 Data-Structure for the Ready Queue317

Due to priority promotion and sharing of priority levels in FPP scheduling, multiple active jobs may have318

the same priority at the same time instant. This is because two jobs of two different tasks τi and τj shares i319

priority levels where i < j. Therefore, the ready queue may need to store more than one job at the same320

priority level. An array of total n linked lists are used to implement the ready queue of the FPP scheduler.321

The κth linked list at any time instant stores all the TCBs of the ready jobs that have priority level κ at that322

time instant.323

The κth linked list has two pointers: head[κ] and tail[κ] that respectively point the first and last324

TCB in the κth linked list. This ready queue data structure along with the bitmap is depicted in Figure 3.325

The purpose of the bitmap B[n . . . 1] is to perform efficient searching to find the highest priority job from326

the ready queue.327

4.2.2 Operations by the Ready Queue Manager328

The ready-queue manager updates the ready queue whenever rel_prmt, rel_no_prmt, idle_remv and329

pri_prom event occurs. The jobs stored in the ready queue at any time instant will satisfy the following330

two properties:331

332

10 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

Figure 3 Proposed data structure of the ready queue for FPP scheduling.

P1: All jobs stored in the νth linked list of the ready queue have higher EDF priorities than any other333

job stored in the `th linked list where ν < `.334

P2: All jobs in the `th linked list are stored in order of non-increasing EDF priority, i.e., the head[`]335

and tail[`] respectively points the highest and lowest priority EDF job in the `th linked list for336

` = 1, . . . n.337

Assume that these two properties hold at time t0 (such t0 exists at least for the case when the system starts,338

i.e., when there is no job in the ready queue). Consider that some event (rel_prmt, rel_no_prmt,339

idle_remv or pri_prom) occurs at time t such that there is no other event after t0 and before t. We will340

show that how properties P1 and P2 continue to hold after ready queue is updated to handle the event that341

occurs at time t. Maintaining properties P1 and P2 are very important to ensure that operations on the ready342

queue can be done in constant time. Given the structure of the ready-queue in subsection 4.2.1, operations343

on the ready queue for managing events rel_prmt, rel_no_prmt, idle_remv and pri_prom are344

presented below.345

Event rel_prmt. This event occurs if a newly released job Jnew starts executing by preempting currently-346

executing lowest-priority job Jexe_low. The TCB of job Jexe_low is inserted in the ready queue. If priority347

of job Jexe_low is ` when preempted by Jnew, then the TCB of job Jexe_low is inserted at the front of the348

`th linked list of the ready queue. The insertion at the front is done in constant time using the head[`]349

pointer. If the bit B[`] = 0, then we set B[`] = 1 to specify that there is a TCB awaiting execution at350

priority level `.351

Since job Jexe_low has priority ` at time t and was in execution, the 1st, 2nd, . . . (`− 1)th linked lists of352

the ready queue at time t are empty. It follows from the proof of Theorem 5 that any job in the ready queue353

at time t neither has higher priority nor has earlier deadline than the currently-executing lowest-priority job354

Jexe_low. Therefore, inserting job Jexe_low at the front of the `th linked list at time t guarantees that P1355

and P2 continues to hold. �356

Event rel_no_prmt. This event occurs if a newly released job Jnew cannot preempt currently-executing357

lowest-priority job Jexe_low and Jnew is inserted in the ready queue. If priority of Jnew is ` at time t, then358

the TCB of Jnew is inserted at the end of the `th linked list. The insertion at the end is done in constant359

time using the tail[`] pointer. If bit B[`] = 0, then we set B[`] = 1.360

Since P1 holds at time t0 and job Jnew has priority ` at time t, it follows that all the jobs in the κth361

linked list at time t have higher and lower EDF priorities than that of job Jnew where κ < ` and κ > `,362

respectively. According to Lemma 3, all the jobs in the `th linked list at time t have their absolute deadlines363

no later than that of job Jnew since job Jnew is released at time t. Therefore, inserting Jnew at the end of364

the `th linked list at time t guarantees that P1 and P2 continues to hold. �365

R. M. Pathan 11

Event idle_remv. This event occurs when some processor becomes idle while the ready-queue is not366

empty. In such case, the highest-priority job from the ready queue is removed and dispatched for execution.367

The highest-priority job is in the lowest-indexed non-empty linked list. The lowest-indexed non-empty368

linked list (i.e., non-empty linked-list at the highest priority level) is found in constant time using bitmap B369

based on the same technique used to find the highest-priority ready task in traditional FP scheduling, for370

example, using deBruijn sequence [22].371

Assume that the `th linked list of the ready queue is the lowest-indexed non-empty linked list. Note372

that there may be multiple jobs awaiting execution in the `th linked list. The job from the front of the `th373

linked list is removed and dispatched for execution. The removal from the front is done in constant time374

using head[`] pointer. If head[`] becomes NULL after this removal (i.e., the `th linked list becomes375

empty), then we set the B[`] = 0 to specify that there is no TCB awaiting execution at priority level `.376

Since property P2 holds at time t0, the job from the front of the lowest-indexed non-empty linked list377

has the highest EDF priority at time t. And, after the removal of this job the remaining jobs in the ready378

queue also satisfy P1 and P2 since removal a job cannot violate P1 or P2. �379

Event pri_prom. This event occurs at time t when the priority of some job in the ready queue is to be380

promoted. If the priority of a job from the `th linked list is to be promoted to priority level ν, then this job381

is removed from the `th linked list and inserted to the νth linked list.382

Since P2 holds at time t0, the job at the front of the `th linked list has deadline no later than any other383

jobs in `th linked list. According to Lemma 4, given a set of jobs having the same priority ` at time t0, the384

priority of the job with earliest deadline will be promoted to priority level ν no later than any other job in385

that set. Consequently, the priority of the job at the front of the `th linked list is to be promoted to priority386

level ν. Let job Ja is the job at the front of the `th linked list.387

The TCB of job Ja is removed from the front of the `th linked list and inserted at the end of the ν388

linked list. The removal and insertion can be done in constant time using the head[`] and tail[ν]389

pointers, respectively. Finally, if the `th linked list becomes empty after this removal, then we set the390

B[`] = 0. If B[ν] = 0, then we set the B[ν] = 1 to specify that the νth linked list is now not empty.391

Since the promoted priority of job Ja is ν at time t, all jobs in the κth linked list, where κ > ν, have392

absolute deadline larger than that of job Ja at time t according to Lemma 2. Since P1 holds at time t0393

and job Ja is in the `th linked list at time t0, it follows that all the jobs in the νth linked list have smaller394

absolute deadlines than that of job Ja. Therefore, inserting Ja at the end of the νth linked list ensures that395

P1 and P2 continues to hold. �396

In summary, when all the tasks are given priorities based on IPDD policy, the FPP scheduler executes397

jobs in EDF priority order. Therefore, existing EDF schedulability tests for uniprocessor and multiprocessors398

(i.e., G-EDF test) can be used to determine whether FPP scheduling can guarantee the schedulability of the399

tasks that are given priorities using IPDD policy.400

If a currently-executing job’s priority is promoted, then such promotion does not need to reorder the401

jobs in the ready queue (i.e., no ready queue management overhead is incurred). In contrast, if the priority402

of a job residing in the ready queue is promoted, then such promotion repositions the job to a higher-priority403

position in the ready queue data structure and thus incurs overhead. While the ready queue management404

of FPP scheduler has similar implementation benefits of FP scheduler (i.e., each event can be handled in405

constant time), the only source of additional overhead in comparison to FP scheduler is the cost of priority406

promotion. However, the number of promotion points can be reduced by assigning some tasks of a task set407

traditional fixed priorities with no promotion point. To this end, a technique to reduce the total number of408

promotion points and a new schedulability test called FPP_Test for FPP scheduling are proposed in next409

section.410

12 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

5 FPP_Test to reduce number of promotions411

In this section, a schedulability test called FPP_Test to determine whether a task set is schedulable in412

FPP scheduling is proposed. The FPP_Test also determines the priorities of the tasks where a subset413

of the tasks is assigned traditional fixed priorities (without any priority promotion) while other tasks are414

assigned priorities (with priority promotion) based on the IPDD policy.415

To determine which tasks can be assigned fixed priorities with no promotion point, an important416

feature of the state-of-the-art FP schedulability test is exploited. For uniprocessor and multiprocessor417

(global) FP scheduling, the corresponding state-of-the-art schedulability tests are of iterative nature: the418

schedulability of each task τi is tested separately. For example, the well-known response time analysis419

(RTA) for FP scheduling on uniprocessor [1] and multiprocessors [26] is of iterative nature: the response420

time Ri of each task τi is computed. The crucial observation is that when determining the schedulability of421

τi using an iterative FP schedulability test for uniprocessor [1] or for multiprocessors [25], the worst-case422

interference computation due to the higher-priority tasks in set hp(i) does not assume that the jobs of the423

tasks in hp(i) are also scheduled using FP scheduling; rather, it only assumes that jobs of the tasks in hp(i)424

have higher priorities and cause maximum interference on τi. Consequently, Corollary 1 holds.425

Corollary 1: If task τi is deemed to be schedulable at priority level ` using an iterative test where426

hp(i) is assumed to be the set of higher priority tasks, then the schedulability of τi is preserved427

when it is assigned traditional fixed-priority level ` regardless whether the jobs of the tasks in hp(i)428

are scheduled using dynamic or fixed priority.429

It follows from Corollary 1 that if some task τi is deemed schedulable using an iterative test at fixed-priority430

level `, then task τi does not need to have any promotion point and the tasks in hp(i) may be assigned fixed431

or IPDD (i.e., essentially dynamic) priorities in FPP scheduling. The FPP_Test is designed based on432

this observation.433

The FPP_Test (presented in Figure 4) requires two schedulability tests to determine the schedulability434

of a task set in FPP scheduling. These two tests, denoted by Tfp and Tedf in Figure 4, are not “real”435

schedulability tests. Depending on the task model (e.g., implicit-, constrained- or arbitrary-deadline) and436

processor platform (uniprocessor or multiprocessors), we will plug in the state-of-the-art iterative FP test437

and EDF test respectively in place of Tfp and Tedf . In section 6–7, the actual tests used in place of Tfp and438

Tedf are presented respectively for uniprocessor and multiprocessor platform.439

The FPP_Test in Figure 4 takes as input a task set Γ and returns “true” if the task set is deemed to be440

FPP schedulable; otherwise, it returns “false”. The FPP_Test also determines the tasks that are given441

fixed priorities and the tasks that are given priorities based on IPDD policy.442

Initially, all the tasks in set Γ are “priority-unassigned” in Figure 4, i.e., no task has any priority.443

Based on Audsley’s OPA algorithm [2], the FPP_Test starts assigning traditional fixed priorities to the444

tasks starting from the lowest priority level. For each priority level k in line 1, some priority-unassigned445

task is searched using the inner loop in line 2-10 to assign it the fixed-priority level k. Whether or not a446

(priority-unassigned) task, say task τi, can be assigned priority level k is determined in line 3–5 by applying447

the iterative FP test Tfp and assuming higher priorities for all other (priority-unassigned) tasks. If such a448

task τi is found in line 3–5, then task τi is assigned the traditional fixed-priority level k in line 7 and the449

priority assignment for next (higher) priority level starts by jumping from line 8 to line 1. If the outer loop in450

line 1–18 terminates after assigning fixed priorities to all the tasks in Γ in line 7, then the algorithm returns451

“true” in line 19. And, FPP schedules all tasks similar to FP scheduling without any priority promotion.452

If no task can be assigned the current priority level k (i.e., the test in line 3–5 is false for all the453

priority-unassigned tasks), then the inner loop in line 2–10 terminates. In such case, there exist some454

priority-unassigned tasks. The schedulability of all these priority-unassigned tasks are tested in line 11 by455

applying test Tedf . If these priority-unassigned tasks pass Tedf , then the promotion points only for these456

R. M. Pathan 13

Algorithm: FPP_Test (Task Set Γ)

1. For priority level k = n to k = 12. For each priority-unassigned task τi ∈ Γ3. If τi is schedulable at priority level k using4. test Tfp with all other priority-unassigned5. tasks assumed to have higher priorities6. Then7. assign τi to priority k8. break (continue outer loop)9. End If10. End For11. If all the priority-unassigned tasks pass Tedf , Then12. Compute promotion points only for the13 priority-unassigned tasks using IPDD policy

//Comment: IPDD policy uses (higher) priority levels// k, (k − 1) . . . 1 for these priority-unassigned tasks

14. Return True15. Else16. Return False17. End If18. End For19. Return True

Figure 4 Improved priority promotion policy for FPP scheduling.

priority-unassigned tasks are computed in line 12-13 based on the IPDD policy and the algorithm returns457

“true” in line 14. Otherwise, the algorithm returns “false” in line 16. Note that the tasks assigned priorities458

using the IPDD policy in line 12-13 have higher priorities than any task that is given traditional fixed459

priority in line 7.460

The FPP_Test guarantees schedulability of Γ using FPP scheduling if it returns “true”. Assume that461

when the algorithm returns true, there are q tasks that are assigned traditional fixed priorities in line 7 and462

the remaining (n− q) tasks are given priorities based on IPDD policy in line 12-13 for some q, 0 ≤ q ≤ n.463

Each of the q tasks that is given traditional fixed priority in line 7 is schedulable in FPP scheduling based464

on Corollary 1. The schedulability of the (n− q) tasks that are given IPDD priorities is not affected by the465

q tasks because these q tasks are given lower (traditional) fixed priorities. Since the (n− q) tasks, having466

priorities based on IPDD policy, are essentially scheduled in EDF order by the FPP scheduler (proved in467

Section 4), satisfying the Tedf test in line 11 guarantees that these (n − q) tasks are also schedulable in468

FPP scheduling. If a task set is schedulable using traditional FP scheduling, then no promotion point is469

assigned to any task using the FPP_Test and all tasks are executed similar to traditional FP scheduling470

using FPP scheduler.471

The ready queue management scheme of subsection 4.2.2 still applies when priorities are assigned472

using FPP_Test. This is because the ready jobs of the q tasks having traditional fixed priorities are (i)473

stored in the linked lists corresponding to the q lower (i.e., (n − q + 1), . . . n) priority levels, (ii) never474

promoted to a higher priority level since they have no promotion point, and (iii) dispatched for execution475

only after all the jobs that are given the (n− q) higher (i.e., (n− q), . . . 1) priority levels are dispatched for476

execution. Properties P1 and P2 (defined in Section 4.2.2) do not necessarily need to hold for the tasks that477

are assigned traditional fixed priorities but always hold for the tasks assigned priorities using IPDD policy.478

14 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

6 FPP_Test for Uniprocessor479

In this section, the FPP_Test in Figure 4 is applied for determining schedulability of constrained-deadline480

tasks on uniprocessor. The response-time test for uniprocessor FP scheduling proposed by Audsley et481

al. [1] is considered in place of Tfp in Figure 4 to determine whether a (priority-unassigned) task τi can482

be assigned fixed priority level k. Note that this response-time test (which is an exact test) combined483

with Audsley’s OPA algorithm in Figure 4 guarantees optimal fixed-priority assignment. And, the quick484

processor demand analysis (QPA), which is an exact EDF test, proposed by Zhang and Burns [29], is485

considered in place of Tedf in line 11 to determine whether all the priority-unassigned tasks are schedulable486

using EDF. The QPA test is an efficient implementation of the processor demand analysis proposed by487

Baruah et al. [5].488

If a task set is EDF schedulable, then the QPA test in line 11 will also be satisfied when not all the489

tasks are assigned fixed priorities in line 7. Consequently, any task set that is schedulable using optimal490

EDF scheduling on uniprocessor also satisfies the FPP_Test. Since preemptive EDF is optimal [17], the491

FPP scheduling where priorities are assigned using the FPP_Test is also an optimal scheduling algorithm492

for constrained-deadline tasks on uniprocessor. For implicit-deadline task sets, the utilization bound of493

FPP algorithm is thus 100% because the utilization bound of EDF for such task system is 100% [24].494

While the performance of FPP scheduling in terms optimality is same as EDF scheduling, it is not495

straightforward to see whether the overhead for managing jobs in the ready queue of FPP scheduler is496

lower or higher than that of EDF scheduler. Simulation using randomly generated task sets is conducted to497

measure such overhead.498

Task set generation for uni- and multiprocessors. Each of the experiments is characterized by a pair499

(m,n) where m is the number of processors and n is the cardinality of a task set. For experiments on500

uniprocessor, we use m = 1. The UUnifast-Discard algorithm [16] is used to generate n utilization501

values of a task set. This algorithm takes as input the number of tasks n and total utilization U of the502

n tasks. And, it generates n utilizations {u1, u2, . . . un} of the n tasks such that the total utilization of these503

n tasks is U . Once a set of n utilizations {u1, u2, . . . un} of a task set is generated, the other parameters of504

each task τi in the task set are generated as follows:505

The minimum inter-arrival time Ti of each task τi is generated from the uniform random distribution506

within the range [10ms, 1000ms].507

The WCET of task τi is set to Ci = ui · Ti.508

The relative deadline Di of task τi is generated from the uniform random distribution within the range509

[Ci, Ti] for constrained deadline tasks; otherwise Di is set to Ti for implicit-deadline tasks.510

Task sets are randomly generated at 40 different utilization levels {0.025m, 0.05m, . . . 0.975m,m} for511

each experiment (m,n). A total of 1000 task sets at each of the 40 utilization levels are generated. Each of512

the 1000 task sets generated at a particular utilization level, say U , has cardinality n and total utilization513

equal to U .514

Sources of Overhead. Insertion/removal of jobs to/from the ready queue of FPP scheduler (as discussed in515

subsection 4.2.2) can be done in constant time. However, jobs that are in the FPP ready queue may need to516

change their position (i.e., upgraded to higher-priority linked list) due to pri_prom events. On the other517

hand, if the ready queue of EDF scheduler is implemented as binary min-heap [9] or binomial min-heap518

[7], then each insertion/removal of a job to/from the ready queue of EDF scheduler may need to reorder the519

remaining jobs in the ready queue in order to satisfy the min-heap property. Our objective is to compare520

such overhead in terms of total number of times different jobs in the ready queue change their position521

to handle pri_prom event (in FPP scheduling) and to maintain min-heap property (in EDF scheduling).522

The EDF ready queue is simulated using a binary min-heap where the ready job with the shortest absolute523

deadline is stored in the root. And, the FPP ready queue is simulated using the proposed data structure in524

Figure 3.525

R. M. Pathan 15

Experiments (Uniprocessor). The randomly-generated task sets that are (exclusively) schedulable using526

FPP/EDF (i.e., satisfy FPP_Test) and not schedulable using traditional FP scheduling are considered527

to compare overheads between FPP and EDF. Figure 5 presents the number of such task sets for each528

utilization level for different n.529

0

50

100

150

200

250

300

0.2 0.4 0.6 0.8 1

Num

ber

of ta

sk s

ets

Utilization

n=5, 10, 20, 40, 60 (constrained-deadline)

n=5n=10n=20n=40n=60

Figure 5 Number of task sets (out of 1000 task sets)that are schedulable using FPP/EDF scheduling but notschedulable using FP scheduling.

-100 %-80 %-60 %-40 %-20 %

0 %20 %40 %60 %80 %

100 %

0.4 0.5 0.6 0.7 0.8 0.9 1

Impr

ovem

ent

Utilization

n=5, 10, 20, 40, 60 (constrained-deadline)

n=60n=40n=20n=10n=5

Figure 6 Improvement of FPP overEDF scheduling.

For each such task set, the execution is simulated using both FPP and EDF scheduling. The ready jobs530

that need to await execution are stored in the corresponding ready queue and reordered when necessary.531

Since it is not computationally feasible to consider all possible release offsets and inter-arrival separations532

of sporadic tasks exhaustively in simulation, all release offsets are set to zero and all tasks are released533

periodically. The simulation is run for L time units where L = min{lcm(T1, T2, . . . Tn), 108} to avoid534

simulation for very large hyperperiod.535

Overhead Metric. For each utilization level, the sum of total number of times each of the jobs of a task set536

change their position in the ready queue is computed and then the average over all task sets is determined537

for both FPP and EDF scheduling. EDFav and FPPav denote the average number of times the jobs of a538

task set change their positions in EDF and FPP ready queue, respectively. The improvement of managing539

jobs in the ready queue of FPP scheduler in comparison to EDF scheduler at each utilization level is:540

Improvement = EDFav − FPPavmax{EDFav,FPPav}

× 100%541

The value of Improvement ranges in [−100%,+100%]. For example, Improvement =−50% implies542

that the ready queue of EDF scheduler on average can reduce 50% overhead of managing jobs in the ready543

queue of FPP scheduler. And, Improvement = +60% implies that ready queue of FPP scheduler on544

average can reduce 60% overhead of managing jobs in the ready queue of EDF scheduler.545

Empirical Results (Uniprocessor). The results of a series of simulations for different n ∈ {5, 10, 20, 40, 60}546

are presented in Figure 6 where the x-axis is the utilization levelU and the y-axis represents Improvement.547

The Improvement is non-negative in almost all the utilization levels3. The improvement of FPP sched-548

uler over EDF scheduler is significant in most cases, i.e., FPP incurs noticeably less overhead (in terms of549

number of times jobs in the ready queue are remapped to new positions) than that of EDF.550

The “positive” improvement of FPP is due to two main reasons. First, the proposed data structure for551

FPP ready queue enables a job to be inserted/removed to/from the ready queue in constant time without552

3 The value of Improvement at relatively lower utilization levels (e.g., when U < 0.4) is caused by very few task sets(Figure 5 presents the number of such task sets) and such outliers can be ignored.

16 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

causing other existing jobs in the ready queue to change their position. In contrast, each insertion/deletion553

to/from the ready queue of EDF scheduler may cause multiple (i.e., O(logn)) jobs to change their positions554

to maintain the min-heap property. Second, the FPP_Test test is effective in reducing the number of555

promotion points. This is verified by observing (the outcome of FPP_Test on random task sets) that556

it is almost always the case where some tasks for the majority of the task sets are given traditional fixed557

priorities with no promotion point.558

The reduction in promotion point at each higher utilization level for task set with larger cardinality is559

much higher than that of task set with smaller cardinality. For example, the average reduction in promotion560

points at U = 0.8 is around 80% and 40% for task sets with cardinality n = 40 and n = 10, respectively.561

This is because, when the number of tasks in a task set for a given utilization level is fewer, the utilization of562

individual task is relatively larger and the execution time of individual task tends to be larger. As execution563

time a individual task increases, jobs in the ready queue stay longer and may undergo a relatively larger564

number of priority promotions. And, more priority promotions cause higher number of times the jobs in565

the ready queue change their positions.566

Observing the significant reduction in overhead, it is expected that if the ready queue of EDF scheduler567

is implemented using some other data structure, the benefit of proposed ready-queue management scheme568

for FPP scheduler will still be realized. To verify this, experiment using other data structure is needed and569

is left as a future work.570

7 FPP_Test for Multiprocessors571

In this section, the FPP_Test in Figure 4 is applied to determine schedulability of constrained-deadline572

tasks scheduled on multiprocessors. For G-FP scheduling, Pathan and Jonsson [26] recently proposed573

an iterative G-FP test that is shown to perform better than any other iterative test proposed earlier. This574

G-FP test [26] is used in place of Tfp in Figure 4 to determine if a priority-unassigned task τi can be575

assigned fixed priority level k. For G-EDF scheduling, Bertogna and Baruah [6] proposed a step-by-step576

approach to apply different G-EDF schedulability tests proposed by other researchers. This G-EDF test577

in [6] is used in place of Tedf in line 11 of Figure 4 to determine if all the priority-unassigned tasks are578

schedulable on m processors using G-EDF scheduling.579

There is no evidence regarding whether the G-FP test in [26] dominates or is dominated by the580

G-EDF test in [6]. It is not difficult to see that if a task set is deemed to be schedulable using G-FP test581

[26] or G-EDF test [6], then that task set also passes the FPP_Test for multiprocessors. In other words,582

the FPP_Test dominates the state-of-the-art G-FP and G-EDF tests. To measure the improvement of583

FPP_Test over G-FP test and G-EDF test, experiments using randomly generated task sets are conducted.584

Empirical Results. For each experiment (m,n), random task sets are generated using the approach585

presented earlier.586

The schedulability of each of the 1000 task sets generated at each utilization level is determined based587

on FPP_Test, G-FP test [26] and G-EDF test [6]. The acceptance ratio for each test at each utilization588

level is computed. The acceptance ratio of a schedulability test is the percentage of task sets deemed589

schedulable at a given utilization level.590

A series of experiments for different (m,n), where m ∈ {2, 4, 8} and n ∈ {3m, 5m, 10m}, are591

conducted. The result of two experiments with parameters (m = 2, n = 10) and (m = 4, n = 20) are592

presented in Figure 7 and Figure 8. The x-axis represents the system utilization U/m for utilization level U593

and the y-axis represents the acceptance ratio.594

The performance of G-EDF test is better than G-FP test when m = 2 and n = 10 in Figure 7. This595

behavior is reversed in Figure 8. This shows neither G-FP nor G-EDF test empirically performs better596

than the other. The FPP_Test does not only theoretically dominate but also empirically performs better597

than both G-FP and G-EDF tests. The performance of FPP_Test test using implicit-deadline tasks is598

R. M. Pathan 17

0 %

20 %

40 %

60 %

80 %

100 %

0.2 0.4 0.6 0.8 1

Acc

epta

nce

Rat

io

Utilization/m

m=2, n=10 (constrained-deadline)

FPP-TestG-EDF

G-FP

Figure 7 Acceptance ratio of FPP_Test,G-FP [26] and G-EDF [6].

0 %

20 %

40 %

60 %

80 %

100 %

0.2 0.4 0.6 0.8 1

Acc

epta

nce

Rat

io

Utilization/m

m=4, n=20 (constrained-deadline)

FPP-TestG-FP

G-EDF

Figure 8 Acceptance ratio of FPP_Test,G-FP [26] and G-EDF [6].

0 %

20 %

40 %

60 %

80 %

100 %

0.2 0.4 0.6 0.8 1

Acc

epta

nce

Rat

io

Utilization/m

m=4, n=20 (implicit-deadline)

FPP-TestG-EDF

G-FP

Figure 9 Acceptance ratio of FPP_Test,G-FP [26] and G-EDF [6].

0 %

20 %

40 %

60 %

80 %

100 %

0.2 0.4 0.6 0.8 1

Acc

epta

nce

Rat

io

Utilization/m

m=8, n=40 (implicit-deadline)

FPP-TestG-EDF

G-FP

Figure 10 Acceptance ratio of FPP_Test,G-FP [26] and G-EDF [6].

significantly better (see Figure 9 and Figure 10).599

The difference in acceptance ratios among the tests are more pronounced at higher utilization level600

since task sets with large total utilization are difficult to schedule. The FPP_Test has the ability to accept601

higher percentage of task sets in comparison to that of G-FP and G-EDF tests by exploiting the benefits of602

both fixed and dynamic priority.603

7.1 Preemptions and Migrations604

To investigate whether FPP scheduling incurs higher or lower number of preemptions and migrations in605

comparison to G-EDF, simulations are conducted. Execution of randomly-generated task sets that are not606

G-FP schedulable but schedulable using both FPP and G-EDF are simulated for FPP and G-EDF schedul-607

ing. For each utilization level U ∈ {0.025m, 0.05m, . . .m}, the average number of preemptions and608

migrations that a task set suffers is computed for both FPP and G-EDF scheduling.609

GEDFavpr and FPPavpr denote the average number of preemptions that a task set suffers in G-EDF and610

FPP scheduling, respectively. Similarly, GEDFavmg and FPPavmg denote the average number of migrations611

that a task set suffers in G-EDF and FPP scheduling, respectively. The improvement by FPP in reducing612

preemptions and migrations in comparison to G-EDF at each utilization level is:613

Improvement(prmt) = GEDFavpr − FPPavprmax{GEDFavpr,FPPavpr}

× 100%614

18 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

-20 %

0 %

20 %

40 %

60 %

0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

Impr

ovem

ent(

prm

t)

Utilization/m

Average reduction in number of preemtions

(m=2,n=10)(m=2, n=20)(m=4, n=10)(m=4, n=20)

Figure 11 Improvement(prmt) of FPP overG-EDF scheduling.

-20 %

0 %

20 %

40 %

60 %

0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

Impr

ovem

ent(

mig

r)

Utilization/m

Average reduction in number of migrations

(m=2,n=10)(m=2, n=20)(m=4, n=10)(m=4, n=20)

Figure 12 Improvement(migr) of FPP overG-EDF scheduling.

Improvement(migr) = GEDFavmg − FPPavmgmax{GEDFavmg,FPPavmg}

× 100%615

The value of improvement ranges in [−100%,+100%]. For example, Improvement(prmt) = +50%616

implies that FPP on average can reduce 50% preemptions that occur in G-EDF scheduling. The re-617

sults of simulations for different n ∈ {10, 20} and m ∈ {2, 4} are presented in Figure 11 and Fig-618

ure 12, where the x-axis is the system utilization U/m and y-axis represents Improvement(prmt) and619

Improvement(migr), respectively.620

The value of Improvement for both preemptions and migrations is non-negative in almost all the621

utilization levels. FPP scheduling can significantly reduce the number of preemptions and migrations that622

are incurred in G-EDF scheduling. Since it is more difficult to schedule task sets at higher utilization levels,623

the improvement decreases as utilization level increases in Figure 11 and Figure 12.624

7.2 Other Implementation Issues625

Brandenburg and Anderson identified six different major sources of overhead in implementing G-EDF al-626

gorithm using a Linux extension, called LITMUSRT, that allows different multiprocessors algorithm to627

be implemented as plugin components [8]. By conducting similar experiments for FPP scheduling, the628

execution time of each task can be inflated to account such overhead in the corresponding schedulability629

analysis. Although this paper does not implement FPP scheduling algorithm in an RTOS, two important630

implementation issues of FPP scheduler warrant further discussion: sharing the ready queue and managing631

timers for multiple pri_prom events.632

If scheduling decisions are handled on multiple processors, for example, arrival of different jobs are633

handled concurrently on different processors (similar to [8]), then the ready queue of FPP scheduler is a634

shared resource. This ready queue needs to be protected against concurrent updates using synchronization635

primitives. As a result, the operations on the ready queue of FPP scheduler can be done in constant time636

(as discussed in Section 4.2) plus any additional delay incurred by such synchronization primitives. Note637

that race condition in handling multiple events in FPP scheduling will not occur. This is because when638

multiple rel_prmt, rel_no_prmt, idle_remv and/or pri_prom events occur very close in time,639

then these events can be handled in any order and properties P1 and P2 (defined in Section 4.2.2) continue640

to hold regardless of the order these (nearly concurrent) events are processed.641

Another issue to implement FPP scheduling is the mechanism used to implement priority promotion.642

One way to implement such priority promotion is by using hardware timers to handle pri_prom events:643

R. M. Pathan 19

when a programmed timer expires, the handler can promote the priority and repositions the ready job to644

the appropriate higher-priority linked list of the ready queue. If the number of hardware timers is not645

sufficient to implement all the pri_prom events, then a queue of timers needs to be managed. In next646

section, different techniques to implement priority promotions are proposed. Given the effectiveness of647

FPP scheduling in reducing (i) the number of re-mappings of jobs in the ready queue, and (ii) the number648

of preemptions and migrations, I expect that FPP scheduling when implemented on real platform would649

show benefits over EDF scheduling.650

Applicability of FPP_Test to Arbitrary-Deadline Tasks. The FPP_Test in Figure 4 can also be651

applied arbitrary-deadline tasks as follows. For uniprocessor platform, the iterative FP test proposed by652

Lehoczky [21] can be used as the Tfp test and the QPA test [29], which also applies to arbitrary-deadline653

tasks, can be used as the Tedf test. For multiprocessor platform, the iterative OPA-incompatible global654

FP test proposed for arbitrary-deadline tasks by Guan et al. [18] can be made OPA-compatible using655

approach used by Davis and Burns for the DA-LC test in [16]. This new test then can be used as the Tfp656

test in Figure 4. And, the G-EDF test proposed by Baruah and Baker [3] can be used as the Tedf test for657

arbitrary-deadline tasks.658

8 Techniques to Implement Priority Promotion659

This section presents different techniques to implement priority promotion, i.e., how event pri_prom is660

implemented and is handled. In FPP scheduling, the priorities of the currently-executing jobs need to be661

promoted so that preemption decision can be taken when a (new) job is released while all the cores are busy.662

In addition, priorities of the jobs stored in the ready queue need to be promoted to ensure that properties P1663

and P2 (also restated below for better readability of this section) always hold.664

P1: All jobs stored in the νth linked list of the ready queue have higher EDF priorities than any other665

job stored in the `th linked list where ν < `.666

P2: All jobs in the `th linked list are stored in order of non-increasing EDF priority, i.e., the head[`]667

and tail[`] respectively points the highest and lowest priority EDF job in the `th linked list for668

` = 1, . . . n.669

Based on the operations on the ready queue (please see subsection 4.2.2) an important observation for job670

Jk of task τk is presented below:671

Observation 1: The TCB of job Jk is never stored in the (lower-priority) `th link lists where ` =672

(k+ 1), (k+ 2), . . . n. This is because the priority of the job is k or higher (i.e., (k− 1), (k− 2), . . . 1).673

When the TCB of job Jk is in the `th linked list of the ready queue at time t where 1 ≤ ` ≤ k, its674

absolute deadline is not larger than D` relative to t.675

Maintaining both P1 and P2 at each time instant is the key to efficiently (in constant-time) perform the676

insertion and removal operations to and from the ready queue, which is same as FP scheduler in terms of677

time complexity (please see subsection 4.2.2). However, unlike FP scheduling, priority promotions cause678

repositioning of jobs in the ready queue. Overhead related to such repositioning depends on how priority679

promotion (i.e., event pri_prom) is implemented and handled. In this section, we present techniques to680

implement priority promotions (i) based on hardware-based approach using timers (subsection 8.1), and (ii)681

software-based approach with no timer (subsection 8.2). In the remainder of this section, we consider that682

all the tasks are assigned priorities based on IPDD policy and need priority promotion.683

According to IPDD priority-promotion policy, the initial priority of a job of task τi is i. This initial684

priority i is promoted to priority levels (i−1), (i−2), . . . 1 at offsets (Di−Di−1), (Di−Di−2), . . . (Di−685

D1) relative to the release time of the job. The difference in time between the (κ− 1)th and κth promotion686

times is denoted as θiκ and is given as follows for κ = 1, 2, . . . (i− 1):687

20 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

θiκ = Di−(κ−1) −Di−κ (1)688

If a job of task τi is released at time ri, the first promotion point is at (ri + θi1) which is θi1 time units689

later than its release time. The second priority-promotion point is θi2 time units later than the 1st priority690

promotion point. In general, the κth priority-promotion point is θiκ time units later than the (κ − 1)th691

priority-promotion point.692

8.1 Hardware Timer-Based Priority Promotion693

Most computer platforms have a clock that increments a counter and can be programmed to generate an694

interrupt when the counter reaches a certain expiration count called the expiration time. The combination695

of a clock and an expiration time is called a timer. In this subsection, we present different alternatives to696

implement priority promotion based on such hardware timers.697

Alternative 1. Consider a platform where the number of hardware timers is sufficient such that one timer698

can be used for each active job. For such a platform, a one-shot timer can be programmed at each promotion699

time of an active job such that the timer expires at next priority-promotion time. Based on this principle,700

when a job of task τi is released at time ri, a hardware timer is programmed to expire after θi1 time units.701

Remember that the initial priority i has to be promoted to priority level (i− 1) at time (ri + θi1).702

If a job completes its execution before the timer is expired, then the timer is disabled to avoid unnecessary703

interrupt at expiration. Otherwise, when the timer generates an interrupt at time (ri+ θi1), the priority of the704

job is promoted to priority level (i− 1) and the timer is programmed again to expire after θi2 time units at705

which priority is promoted to (i− 2) and so on. Following this approach, the timer is programmed to expire706

after θiκ time units whenever priority of the job is set to priority level (i− (κ− 1)) for κ = 1, 2, . . . (i− 1).707

After the priority of the job is set to (highest) priority level 1, the timer is no more programmed since there708

is no more priority promotion of this job according to IPDD policy.709

While this approach is simple, it may not work for platform where the number of active jobs is larger710

than the number of available hardware timer. In such case, a queue of (future) timed events related to711

(future) priority promotions needs to be implemented using, for example, a single hardware timer. In the712

remainder of this subsection, different alternatives to manage a queue of (priority-promotion related) timed713

events using a single hardware timer are presented.714

Alternative 2. A queue of (future) timed events can be maintained based on a timing wheel which is a715

sequential array of records [28]. Inspired from the discussion of Baruah et al. in [4], we assumed that time716

is represented using non-negative integers. The required number of records of the timing wheel depends717

on the maximum time difference between any two consecutive priority promotions. Based on Eq. (1), the718

maximum length between two consecutive priority promotions of a job of τi isi−1maxκ=1

{θiκ}. Consequently,719

the maximum length of any two consecutive priority promotions for any task in set {τ1, τ2, . . . τn} is720

nmaxi=1{ i−1maxκ=1

{θiκ}}. For implementing a queue of priority-promotion related timed events, the required721

number of records of the timing wheel, denoted by L, is given as follows in Eq. (2):722

L = 1+ nmaxi=1

{i−1maxκ=1

{θiκ}}

(2)723

724

At each position of the timing wheel, a linked list of pointers to jobs’ TCBs is stored. A variable to725

track current time, called CT, is initially set to 0. This variable is incremented (mod L) at every system726

tick. In other words, CT is set to 1 after the first tick, set to 2 after the second tick, set to back to 1 after L727

ticks, and so on. Such a timing wheel is shown in Figure 13 and Figure 14.728

R. M. Pathan 21

Figure 13 A timing wheel. CT points tothe second record. At every system tick, CT isincremented by 1 (mod L).

Figure 14 The linked list at position 4 stores pointers to theTCBs of those jobs who need priority promotion when CT willpoint location 4. The CT is now at location 2 will point location4 after 2 ticks.

When a job of task τi is released, its next promotion time is θi1 time units later relative to current time.729

A pointer to the TCB of this job is stored in the linked list of the timing wheel at position (CT+ θi1) mod L.730

When CT points to a location of the timing wheel at which the linked list is non-empty, the priorities of the731

jobs pointed by the elements of this linked list are promoted. After the priority of a job of task τi at time732

CT is promoted to priority level (i− (κ− 1)) for some κ such that 1 ≤ κ ≤ (i− 1), a pointer to the TCB733

of this job is again stored in the linked list at position (CT + θiκ) mod L of the timing wheel for next (i.e.,734

κth) priority promotion of this job.735

According to Eq. (2), the value of L is one larger than the maximum difference between any two736

consecutive promotion points. Therefore, (CT + θiκ) mod L is never equal to CT. In other words, to737

distinguish between two (future) priority promotions separated by exactlyn

maxi=1{ i−1maxκ=1

{θiκ}} time units,738

the number of records (as is shown in Eq. (2)) of the timing wheel is one larger than the maximum difference739

between any two consecutive priority promotions.740

Alternative 2 to manage multiple priority promotions requires the variable CT to be incremented at741

every timer’s tick which may have high overhead. Next we propose Alternative 3 based on timing wheel742

but with the exception that variable CT is not incremented at every system’s tick.743

Alternative 3. Similar to Alternative 2, multiple (future) timed events related to priority promotions are744

stored in the linked lists of a timing wheel but without requiring to increment variable CT at every system’s745

tick. A bitmap, denoted by S[1, 2 . . . L], of length L corresponding to the timing wheel is maintained. If746

the linked list of the ath position of the timing wheel is empty, then S[a] = 0; otherwise, S[a] = 1. When747

all the linked lists of the timing wheel are empty, we set CT to 0. The main idea is to program a one-shot748

timer that expires after a duration equal to the earliest time of occurrence of any (future) timed event stored749

in the timing wheel. The approach is described as follows:750

(How an element is inserted in an empty timing wheel?) Consider that there is no element in the751

timing wheel, i.e., CT = 0 and ∀`;S[`] = 0 at time t. Now consider that a new (future) timed event752

appears at time t such that this event needs to occur after a time units relative to time t. In other753

words, there is a future timed event that occurs after a time units relative to CT. To implement priority754

promotion related to this event, a pointer to the TCB of the job is inserted in the ath linked list of the755

timing wheel. A one-shot timer is set to expire after a time units. To remember the total duration for756

which this timer is programmed, we set Initial Value of the Timer as IVT = a. We also set S[a] = 1 to757

specify that the ath linked list of the timing wheel is non-empty.758

(How an element is inserted in a non-empty timing wheel?) Now consider that a new (future) timed759

22 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

event appears at time t′ such that this event needs to occur after c time units relative to time t′ and the760

timing wheel is non-empty at time t′. Since the timing wheel is non-empty, the timer (that was last761

programmed) is running (not yet expired) at time t′. Assume that at time t′ the remaining time to expire762

the timer is b. The total time elapsed between the time instant when the timer was last programmed and763

time t′ is (IVT− b) since IVT stores the total duration for which the time was last programmed. At764

time t′ the value of CT is updated by setting it equal to the old value of CT plus elapsed time form the765

time CT was last set, i.e, CT = CT + (IVT− b). In addition, IVT is set to IVT = b to reflect the fact766

that the timer expires after b time units relative to the (updated) current time CT. After updating CT and767

IVT, we consider where the new event that appears at time t′ is to be inserted in the timing wheel.768

If c < b, then the new event has an earlier time of occurrence than that of any event stored in any linked769

list of the timing wheel. Remember that the one-shot timer was programmed to expire at time when770

the earliest event in the timing wheel will occur. Since c < b, the one-shot timer is reprogrammed771

at time t′ to expire after c time units and we set IVT = c. On the other hand, if c > b, then the new772

event does not have an earlier occurrence time and the one-shot timer is not reprogrammed. After773

CT and IVT are updated at time t′, a pointer to the TCB of the job corresponding to the new event774

is inserted to the (CT + c)th linked list of the timing wheel. Note that the value (CT + c) essentially775

means (CT + c) mod L. If (CT + c)th linked list was empty before this insertion, we set S[q] = 1776

where q = (CT + c) mod L.777

(How to deal with timer’s expiration?) The timer expires when no new event with earlier time of778

occurrence appears after IVT was last set. When the one-shot timer expires after IVT time units and779

generates an interrupt, the value of CT is updated by setting CT = (CT + IVT) mod L. And, the780

priorities of the jobs pointed by the TCB pointers stored in the CTth linked list of the timing wheel are781

promoted. If the next promotion time for such a job is a time units later, then the pointer to the TCB of782

that job is again inserted in the (CT+ a)th linked list and we set S[CT+ a] = 1. After processing each783

element of the CTth linked list in the timing wheel, all the TCB pointers are removed from the CTth784

linked list and we set S[CT] = 0.785

If the timing wheel is not empty after handling a timer’s expiration, then we have to program the timer786

for the next promotion event that will occur the earliest. To program the timer for the next earliest787

promotion time, the position of the first set bit of bitmap S starting from position CT is determined.788

This can be done based on techniques similar to finding the highest priority tasks from the ready queue789

of FP scheduler. Let this position is (CT + k) mod L, i.e., this position points to the kth linked list790

relative to the index of CTth linked list. If k is not a valid index, then there is no element in the timing791

wheel and we set CT = 0. For a valid k, the jobs corresponding to the TCB pointers stored in the792

(CT + k)th linked list have the earliest promotion time. The timer is programmed to expire after k time793

units and we set IVT = k.794

Note that in the approach described above, variable CT is not updated at every system’s tick. It is795

updated either when a new event is to be stored in the timing wheel and/or when the timer expires. One of796

the limitations with this approach is that if L is too large, then a hierarchical bitmap needs to be maintained797

(as is suggested in [27]).798

Alternative 4. This alternative to manage a queue of (future) timed events is based on the RELTEQ799

approach proposed in [20]. The main idea of RELTEQ is that events are stored in an ordered list based800

on the time of occurrences of the events relative to each other. The advantage of this approach is that no801

bitmap needs to be maintained. But the disadvantage is that linear search is needed to find the appropriate802

position for each new event. Please see details of RELTEQ in [20].803

R. M. Pathan 23

8.2 Software-Based Approach to Priority Promotion804

In this subsection, we present software-based approach to show how priority promotion can be implemented805

without using a hardware timer. Under this scheme, the the priorities of the jobs that are in execution are806

never promoted. The priority of a job is promoted only if the job is in the ready queue. For such a job in807

the ready queue, priority promotions that are due at a time instant are delayed as long as properties P1 and808

P2 of the ready queue of FPP scheduler hold.809

The jobs whose promotions are delayed are called colluding jobs. When a rel_prmt or rel_no_prmt event810

occurs (i.e., a new TCB has to be inserted in the ready queue due to the release of new job), we check if811

insertion of this new TCB in the ready queue according to the approach presented in subsection 4.2.2 could812

violate property P1 or P2. Note that such violation may happen since priorities of the colluding jobs were813

not promoted when their promotions were due and the corresponding TCBs of colluding jobs were not814

repositioned in the right place in the ready queue. If we detect that such violation would occur, we fix815

the collusion by promoting some or all colluding jobs so that property P1 and P2 continue to hold after816

insertion of the new TCB.817

A job Ji of task τi is promoted according to IPDD priority-promotion policy in order to determine818

whether a newly released job Jk of task τk needs to preempt the execution of Ji or not. In contrast, the819

priorities of the currently-executing jobs are never promoted in delayed preemption strategy. Whether820

a newly released job Jk preempts Ji or not can be determined by comparing their absolute deadlines821

since we want to execute jobs in EDF order. Therefore, we compare (ri + Di) and (rk + Dk). If822

(ri +Di) > (rk +Dk), then Jk preempts Ji; otherwise, Jk does not preempt Ji. In the remainder of this823

section, we present how the new TCB is inserted in the ready queue such that property P1 and P2 of the824

ready queue continue to hold after this insertion.825

Assume that property P1 and P2 hold at time t. Consider an earliest time instant t′ at which a new job826

Jk of task τk is released and all the cores are busy such that t < t′. A new TCB (i.e., TCB of Jk or TCB of827

the preempted job Ji) is to be inserted in the ready queue at time t′. Since t′ is the earliest time at which a828

new TCB is to be inserted in the ready queue, property P1 and P2 continue to hold during the entire interval829

[t, t′) even if all promotions of the jobs in the ready queue during this interval are delayed. In delayed830

promotion strategy, the promotions of the jobs are delayed until a new job is released. Due to such delayed831

promotions, colluding jobs in the ready queue are not promoted (i.e., repositioned) to higher-priority linked832

lists of the ready queue. Consequently, property P1 and P2 may not hold at time t′ if the new TCB is833

inserted without fixing the collusion. The challenge is to propose mechanism to ensure that after inserting834

the new job, property P1 and P2 continue to hold also at time t′. There are two cases to consider:835

Case (i) Job Jk preempts Ji836

Case (ii) Job Jk does not preempt Ji837

Case (i) Jk preempts Ji: In such case, a newly released job Jk preempts the currently-executing838

lowest EDF priority job Ji at time t′. Since Ji was in execution just before Jk was released and because839

property P1 and P2 hold during [t, t′) during which no new job is released, the EDF priority of job Ji is840

larger than the EDF priority of any other job in the ready queue.841

Job Ji is inserted at the front of the highest-priority non-empty linked list if the index of the highest-842

priority non-empty linked list of the ready queue is smaller than or equal to i; otherwise, it is inserted as843

the first element in the ith linked list of the ready queue. Such insertion can be done in constant time and844

ensures that Observation 1 still holds. It is easy to see that property P1 and P2 continue to hold at time845

t′ after inserting the new TCB of Ji in the ready queue even though all due promotions during [t, t′] are846

delayed. In such case, the delayed promotions in [t, t′] are delayed further.847

Case (i) Jk does not preempt Ji: In such case, a newly released job Jk does not preempt the currently-848

executing lowest EDF priority job Ji at time t′. The TCB of job Jk is to be inserted in the ready queue.849

Based on the operations proposed in subsection 4.2.2, this new TCB is inserted at the end of the kth linked850

24 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

list since the priority of job Jk at time t′ is k. However, property P1 and P2 may not hold at time t′ because851

promotions of the colluding jobs during [t, t′) are delayed and not placed in the right position in the ready852

queue before inserting this new TCB. The strategy to fix the collusion before inserting job Jk is as follows.853

The absolute deadline of job Jk is Dk time units later than time t′ because job Jk is released at time t′.854

Since jobs in the `th linked list of the ready queue at time t′ have their absolute deadlines no later than D`855

time units relative to t′ for ` = 1, 2, . . . k, the EDF priorities of the jobs in these linked lists are higher than856

that of job of Jk (follows from Observation 1). If job Jk is inserted at the end of kth linked list, property857

P1 and P2 continue to hold at time t′ for the 1st, 2nd, . . . , (k − 1)th, kth linked lists even if priority of the858

jobs in these linked lists are not promoted during [t, t′].859

On the other hand, since priority promotions of the jobs in (k+1)th, (k+2)th, . . . , (n−1)th, nth linked860

lists are also delayed during [t, t′], the actual EDF priority of some of the colluding jobs in these linked861

lists may be higher than that of job Jk at time t′. Such colluding jobs need to be promoted (i.e., need to be862

repositioned) to fix the collusion so that property P1 and P2 continue to hold after job Jk is inserted at the863

end of the kth linked list. Although there may be many colluding jobs, we only need to promote the priority864

(i.e., reposition in the ready queue) of those colluding jobs from the (k+1)th, (k+2)th, . . . , (n−1)th, nth865

linked lists whose EDF priority is larger than the EDF priority of Jk at time t′ to fix the collusion.866

Notice that property P1 and P2 hold for the jobs in the (k + 1)th, (k + 2)th, . . . , (n− 1)th, nth linked867

lists before inserting the new TCB at time t′. Before inserting job Jk at the end of the kth linked list, the868

higher EDF priority jobs from the (k + 1)th, (k + 2)th, . . . , (n − 1)th, nth linked lists are inserted (in869

decreasing EDF order) at the end of the kth linked list. Finally, job Jk is inserted at the end of the kth870

linked list. The following algorithm in Figure 15, called Fix_Collusion, implements this insertion.871

Algorithm: Fix_Collusion(Job Jk)

// This algorithm is executed when a new job Jk cannot// preempt any job and needs to be inserted in// the ready queue (i.e., when rel_no_prmt event occurs)

1. NextList = k + 12. s = Position of the first set bit of bitmap B[NextList . . . n]3. If s is a valid position of bitmap B4. While (the absolute deadline of the first element of the sth

5. linked list is smaller than the absolute deadline of Jk)6. J = remove the first element from the sth linked-list7. Insert J at the end of the kth linked list8. If the sth linked list is empty9. NextList = s+ 110. Go to Step 211. End If12. End While13. End If14. Insert Jk at the end of the kth linked list

Figure 15 Coalescing Priority Promotion to handle rel_no_prmt event.

Algorithm Fix_Collusion in Figure 15 selects those jobs from the (k + 1)th, (k + 2)th, . . . , (n−872

1)th, nth linked lists whose EDF priorities are higher than that of job Jk. These selected jobs are inserted873

in decreasing EDF order at the end of the kth linked list, and finally, job Jk is inserted at the end of the kth874

linked list. We will show that property P1 and P2 continues to hold after algorithm Fix_Collusion is875

executed at time t′.876

R. M. Pathan 25

Line 1 initializes a variable NextList to (k + 1) in order to start the search form the (k + 1)th877

linked list. However, the (k + 1)th linked list may be empty. The index of the first non-empty linked list878

among the (k + 1)th, (k + 2)th, . . . , (n− 1)th, nth linked lists is determined in line 2 based on the bitmap879

B[NextList, . . . n]. The index of the first set bit of the bitmap B[NextList, . . . n] is stored in variable s880

in line 2.881

If all of the (n− k) lower priority linked lists are empty, then s has an invalid index. The condition in882

line 3 checks whether all of the (n− k) lower priority linked lists are empty or not. If the condition in line883

3 is false (i.e., there is no non-empty linked lists among the (n− k) lower priority linked lists), then there884

is no TCB in the (k + 1)th, (k + 2)th, . . . , (n − 1)th, nth linked lists and the TCB of job Jk is inserted885

at the end of the kth linked list in line 14. Since P1 and P2 hold for k higher priority linked lists before886

inserting Jk (i.e., jobs in these linked lists have deadline no larger than Dk relative to time t′) and since the887

deadline of Jk is Dk at time t′, P1 and P2 hold after job Jk is inserted.888

If condition in line 3 is true, then s is the index of the highest-priority non-empty linked lists among the889

(k + 1)th, (k + 2)th, . . . , (n− 1)th, nth linked lists. In such case, all the TCBs of the jobs having higher890

EDF priority than Jk (based on the condition of the while loop in line 4–5) are removed from the sth linked891

list one-by-one in line 6 and inserted in non-increasing EDF priority order at the end of the kth linked list892

in line 7.893

Since the first job is removed from the sth linked list each time condition in line 4–5 is true and because894

property P2 is satisfied (jobs in each list are in non-increasing EDF priority order), inserting the removed895

job J at the end of the kth linked list ensures that jobs in the kth linked list are in non-increasing EDF order.896

We exit from the while loop in two cases: (i) some job’s EDF priority in the sth linked list is lower than897

the EDF priority of Jk (i.e., condition in the while loop is false), or (ii) all the jobs from the sth linked898

list are removed (i.e., condition in line 8 is true). In the first case, the algorithm exit from the loop and899

executes line 14. This is because there is no other jobs in the (n − k) lower priority linked list having900

higher EDF priority. In the second case (when the condition in line 8 is true), the sth list is empty and the901

NextList is set to (s+ 1) to select other higher EDF priority jobs from the remaining (n− s) linked lists.902

In such case, the algorithm jumps to line 2 from line 10 and continues as described above. It is easy to see903

that number of times the while loop executes is no more than the number of delayed promotions in [t, t′].904

When the algorithm stops, property P1 and P2 hold at time t′. Note that we need no timer to implement905

priority promotions based on software-based delayed promotion mechanism. Evaluating all these priority906

promotion schemes and the implementation of FPP scheduling on real platform is left as a future work.907

9 Conclusion908

The proposed FPP scheduling algorithm shows how jobs can be executed in EDF order based on priority909

promotion. For uniprocessor, the FPP scheduling is also optimal as EDF scheduling. For multiprocessors,910

it dominates the state-of-the-art G-FP and G-EDF tests for constrained-deadline tasks. Technique to reduce911

the number of promotion points is proposed so that overhead is low. The proposed data structure and912

operations for managing jobs in the ready queue of FPP scheduler have benefits similar to that of traditional913

FP scheduler. Techniques to implement priority promotions based on hardware timers or purely in software914

are proposed. Simulation results show that overhead for managing jobs in the FPP ready queue is reduced915

significantly in comparison to that of EDF scheduler.916

References1 N. Audsley, A. Burns, M. Richardson, K. Tindell, and A.J.

Wellings. Applying new scheduling theory to static prior-ity pre-emptive scheduling. Software Engineering Journal,8(5):284–292, 1993. DOI: http://dx.doi.org/10.1049/sej.1993.0034.

2 N. C. Audsley. On Priority Assignment in FixedPriority Scheduling. Info. Proc. Letters, 79(1):39–44, 2001. DOI: http://dx.doi.org/10.1016/S0020-0190(00)00165-4.

26 Real-Time Scheduling on Uni- and Multiprocessors based on Priority Promotions

3 S. Baruah and T. Baker. Global edf schedulabilityanalysis of arbitrary sporadic task systems. In Proc.of ECRTS, 2008. DOI: http://dx.doi.org/10.1109/ECRTS.2008.27.

4 SanjoyK. Baruah, LouisE. Rosier, and RodneyR. How-ell. Algorithms and complexity concerning the preemp-tive scheduling of periodic, real-time tasks on one pro-cessor. Real-Time Systems, 2(4):301–324, 1990. DOI:http://dx.doi.org/10.1007/BF01995675.

5 S.K. Baruah, A.K. Mok, and L.E. Rosier. Preemptivelyscheduling hard-real-time sporadic tasks on one processor.In Proc. of RTSS, pages 182 –190, 1990. DOI: http://dx.doi.org/10.1109/REAL.1990.128746.

6 Marko Bertogna and Sanjoy Baruah. Tests for global edfschedulability analysis. J. Syst. Archit., 57(5):487–497,May 2011. DOI: http://dx.doi.org/10.1016/j.sysarc.2010.09.004.

7 B.B. Brandenburg, J.M. Calandrino, and J.H. Anderson.On the Scalability of Real-Time Scheduling Algorithmson Multicore Platforms: A Case Study. In Proc. of RTSS,2008. DOI: http://dx.doi.org/10.1109/RTSS.2008.23.

8 Björn B. Brandenburg and James H. Anderson. On theImplementation of Global Real-Time Schedulers. In Proc.of RTSS, pages 214–224, 2009. DOI: http://dx.doi.org/10.1109/RTSS.2009.23.

9 A. Burns, M. Gutierrez, M. Aldea Rivas, and M. Gonza-lez Harbour. A deadline-floor inheritance protocol for edfscheduled embedded real-time systems with resource shar-ing. IEEE Transactions on Computers, 64(5):1241–1253,May 2015. DOI: http://dx.doi.org/10.1109/TC.2014.2322619.

10 A. Burns and A.J. Wellings. Dual Priority Assignment: APractical Method of Increasing Processor Utilisation . InProc. of the Fifth Euromicro Workshop on Real-time Sys-tems, 1993. DOI: http://dx.doi.org/10.1109/EMWRT.1993.639052.

11 Alan Burns. Dual Priority Scheduling: Is the Pro-cessor Utilisation bound 100%? . In Proc. of the1st International Real-Time Scheduling Open ProblemsSeminar (RTSOPS), in conjunction with the ECRTS,2010. https://www.cs.york.ac.uk/ftpdir/papers/rtspapers/R:Burns:2010b.pdf.

12 Giorgio C. Buttazzo. Rate monotonic vs. edf: Judg-ment day. Real-Time Syst., 29(1):5–26, 2005.DOI: http://dx.doi.org/10.1023/B:TIME.0000048932.30002.d9.

13 R. I. Davis. Dual priority scheduling: A meansof providing flexibility in hard real-time sys-tems. Technical Report YCS 230, Dept of Com-puter Science, University of York, UK, 1994.https://www.cs.york.ac.uk/ftpdir/reports/94/YCS/230/YCS-94-230.ps.Z.

14 R.I. Davis and A. J. Welling. Dual Priority Scheduling. InProc. of RTSS, 1995. DOI: http://dx.doi.org/10.1109/REAL.1995.495200.

15 Robert Davis and Alan Burns. A Survey of Hard Real-Time Scheduling for Multiprocessor Systems. ACM Com-puting Surveys, 43(4):35:1–35:44, 2011. DOI: http://dx.doi.org/10.1145/1978802.1978814.

16 Robert Davis and Alan Burns. Improved priority as-signment for global fixed priority pre-emptive schedul-ing in multiprocessor real-time systems. Real-Time Sys-tems, 47:1–40, 2011. DOI: http://dx.doi.org/10.1007/s11241-010-9106-5.

17 Michael L. Dertouzos. Control robotics: The proceduralcontrol of physical processes. In IFIP Congress, pages807–813, 1974.

18 Nan Guan, Martin Stigge, Wang Yi, and Ge Yu. NewResponse Time Bounds for Fixed Priority MultiprocessorScheduling. Proc. of RTSS, pages 387–397, 2009. DOI:http://dx.doi.org/10.1109/RTSS.2009.11.

19 M.G. Harbour, M.H. Klein, and J.P. Lehoczky. Fixed pri-ority scheduling periodic tasks with varying execution pri-ority. In Proc. of RTSS, 1991. DOI: http://dx.doi.org/10.1109/REAL.1991.160365.

20 M. Holenderski, W. Cools, R.J. Bril, and J.J. Lukkien.Multiplexing real-time timed events. In Proc. of ETFA,2009. DOI: http://dx.doi.org/10.1109/ETFA.2009.5347183.

21 J.P. Lehoczky. Fixed priority scheduling of periodictask sets with arbitrary deadlines. In Proc. of RTSS,1990. DOI: http://dx.doi.org/10.1109/REAL.1990.128748.

22 C. Leiserson, H. Prokop, and K. H. Randall. Using debruijn sequences to index a 1 in a computer word. MITTechnical Report, 1998. http://supertech.csail.mit.edu/papers/debruijn.pdf.

23 J. Y. T. Leung and J. Whitehead. On the Complex-ity of Fixed-Priority Scheduling of Periodic, Real-Time Tasks. Performance Evaluation, 2:237–250,1982. DOI: http://dx.doi.org/10.1016/0166-5316(82)90024-4.

24 C. L. Liu and J. W. Layland. Scheduling Algorithmsfor Multiprogramming in a Hard-Real-Time Environment.Journal of the ACM, 20(1):46–61, 1973. DOI: http://dx.doi.org/10.1145/321738.321743.

25 Risat Mahmud Pathan and Jan Jonsson. Improved Schedu-lability Tests for Global Fixed-Priority Scheduling. Proc.of ECRTS, 2011. DOI: http://dx.doi.org/10.1109/ECRTS.2011.21.

26 Risat Mahmud Pathan and Jan Jonsson. Interference-aware fixed-priority schedulability analysis on mul-tiprocessors. Real-Time Systems, 50(4):411–455,2014. DOI: http://dx.doi.org/10.1007/s11241-013-9198-9.

27 Michael Short. Improved task management techniques forenforcing edf scheduling on recurring tasks. In Proc. ofRTAS, 2010. DOI: http://dx.doi.org/10.1109/RTAS.2010.22.

28 G. Varghese and T. Lauck. Hashed and hierarchical tim-ing wheels: Data structures for the efficient implementa-tion of a timer facility. In Proceedings of the EleventhACM Symposium on Operating Systems Principles, pages25–38, 1987. DOI: http://dx.doi.org/10.1145/41457.37504.

29 Fengxiang Zhang and A. Burns. Schedulability analysisfor real-time systems with edf scheduling. Computers,IEEE Transactions on, 58(9):1250–1258, Sept 2009. DOI:http://dx.doi.org/10.1109/TC.2009.58.