An Introduction to Real-Time Operating Systems and

Schedulability Analysis

Marco Di Natale
Scuola Superiore S. Anna
Outline

• Background on Operating Systems

• An Introduction to RT Systems
• Model-based development of Embedded RT systems
– the RTOS in the platform-based design
• Scheduling and Resource Management
• Schedulability Analysis and Priority Inversion
– The Mars Pathfinder case
• Implementation issues and standards
– OSEK
Credits

• Paolo Gai (Evidence S.r.l.) – slides on EDF and OSEK

• Giuseppe Lipari (Scuola Superiore S. Anna) – slides on OS
• Manas Saksena (TimeSys) – examples on blocking time comput.
• From Mathworks Simulink and RTW manuals – slides on RT
blocks
Background on Operating Systems
 Fundamentals

• Algorithm:
– It is the logical procedure to solve a certain problem
– It is informally specified a a sequence of elementary steps
that an “execution machine” must follow to solve the
problem
– It is not necessarily expressed in a formal programming
language!
• Program:
– It is the implementation of an algorithm in a programming
language
– Can be executed several times with different inputs
• Process:
– An instance of a program that given a sequence of inputs
produces a set of outputs
Operating System

• An operating system is a program that

– Provides an “abstraction” of the physical machine
– Provides a simple interface to the machine
– Each part of the interface is a “service”
• An OS is also a resource manager
– The OS provides access to the physical resources of a
computing machine
– The OS provides abstract resources (for example, a file, a
virtual page in memory, etc.)
 Levels of abstraction

User Level Kim Lisa Bill

Programmer
Level Web Printer
Shell Videogame
Browser Daemon

System
Level Interface (System API)

Operating Virtual Memory Scheduler Virtual File Sys.

System
Device Device Device Device Device Device
Driver Driver Driver Driver Driver Driver
HW Level

Keyboard Network Card Printer

Main Board
CPU
Video Card Printer Hard disk
 Abstraction mechanisms

• Why abstraction?
– Programming the HW directly has several drawbacks
• It is difficult and error-prone
• It is not portable
– Suppose you want to write a program that reads a text file
from disk and outputs it on the screen
• Without a proper interface it is virtually impossible!
 Abstraction Mechanisms

• Application programming interface (API)

– Provides a convenient and uniform way to access to one
service so that
• HW details are hidden to the high level programmer
• One application does not depend on the HW
• The programmer can concentrate on higher level tasks
– Example
• For reading a file, linux and many other unix OS provide the
open(), read() system calls that, given a “file name” allow to
load the data from an external support
 the need for concurrency

• there are many reason for concurrency

– functional
– performance
– expressive power
• functional
– many users may be connected to the same system at the
same time
• each user can have its own processes that execute
concurrently with the processes of the other users
– perform many operations concurrently
• for example, listen to music, write with a word processor, burn a
CD, etc...
• they are all different and independent activities
• they can be done “at the same time”
the need for concurrency (2)

• performance
– take advantage of blocking time
• while some thread waits for a blocking condition, another thread
performs another operation
– parallelism in multi-processor machines
• if we have a multi-processor machine, independent activities can be
carried out on different processors are the same time
• expressive power
– many control application are inherently concurrent
– concurrency support helps in expressing concurrency, making
application development simpler
 theoretical model

• a system is a set of concurrent activities

– they can be processes or threads
• they interact in two ways
– they access the hardware resources
• processor
• disk
• memory, etc.
– they exchange data
• these activities compete for the resources and/or
cooperate for some common objective
Process

• The fundamental concept in any operating system

is the “process”
– A process is an executing program
– An OS can execute many processes at the same time
(concurrency)
– Example: running a Text Editor and a Web Browser at the
same time in the PC
• Processes have separate memory spaces
– Each process is assigned a private memory space
– One process is not allowed to read or write in the memory
space of another process
– If a process tries to access a memory location not in its
space, an exception is raised (Segmentation fault), and
the process is terminated
– Two processes cannot directly share variables
Memory layout of a Process

Other data Dynamically allocated

Dynamically allocated
memory
Heap memory
(variable size)
(variable size)

Stack
Stack
(variable size)
Stack (variable size)

BSS Global variables

Global variables
(non initialized)
(non initialized)
Initialized Data
Global variables
Text Global variables
(initialized)
(initialized)

Contains the process code

Contains the process code
(machine code)
(machine code)
 Memory Protection

• By default, two processes cannot share their

memory
– If one process tries to access a memory
location outside its space, a processor
exception is raised (trap) and the
process is terminated Other data
– The “Segmentation Fault” error!!
Heap
Any reference to this
Any reference to this
memory results in a
memory results in a
segmentation fault
segmentation fault Stack

BSS

Initialized Data

Text
Processes

• We can distinguish two aspects in a process

• Resource Ownership
– A process includes a virtual address space, a process image
(code + data)
– It is allocated a set of resources, like file descriptors, I/O
channels, etc
• Scheduling/Execution
– The execution of a process follows an ececution path, and
generates a trace (sequence of internal states)
– It has a state (ready, Running, etc.)
– And scheduling parameters (priority, time left in the round, etc.)
Multi-threading

• Many OS separate these aspects, by providing the

concept of thread
• The process is the “resource owner”
• The thread is the “scheduling entity”
– One process can consists of one or more threads
– Threads are sometime called (improperly) lightweight
processes
– Therefore, on process can have many different (and
concurrent) traces of execution!
 Multi-threaded process model
Process
Process
• In the multi-threaded
process model each
process can have many Thread
Thread Thread
Thread Thread
Thread
threads Process
control Thread Thread Thread
– One address space block control control control
– One PCB block block block
– Many stacks Process
address
– Many TCB (Thread space User User User
Control blocks) stack stack stack
– The threads are
scheduled directly by the
global scheduler
Kernel Kernel Kernel
stack stack stack
Threads

• Generally, processes do not share memory

– To communicate between process, it is necessary to user
OS primitives
– Process switch is more complex because we have to
change address space
• Two threads in the same process share the same
address space
– They can access the same variables in memory
– Communication between threads is simpler
– Thread switch has less overhead
Threads support in OS
• Different OS implement threads in different ways
– Some OS supports directly only processes
• Threads are implemented as “special processes”
– Some OS supports only threads
• Processes are threads’ groups
– Some OS natively supports both concepts
• For example Windows NT
• In Real-Time Operating Systems
– Depending on the size and type of system we can have
both threads and processes or only threads
– For efficiency reasons, most RTOS only support
• 1 process
• Many threads inside the process
• All threads share the same memory
– Examples are RTAI, RT-Linux, Shark, some version of
VxWorks, QNX, etc.
The thread control block
• In a OS that supports threads
– Each thread is assigned a TCB (Thread Control Block)
– The PCB holds mainly information about memory
– The TCB holds information about the state of the thread

TID
Thread Table PID
CR
IP
SP
Other Reg.
State
Priority
Time left
...
Thread states

• The OS can execute many threads at the same time

• Each thread, during its lifetime can be in one of the following

states
– Starting (the thread is being created)
– Ready (the thread is ready to be executed)
– Executing (the thread is executing)
– Blocked (the thread is waiting on a condition)
– Terminating (the thread is about to terminate)
Thread states

a) Creation The thread is created

b) Dispatch The thread is selected to execute
c) Preemption The thread leaves the processor
d) Wait on condition The thread is blocked on a condition
e) Condition true The thread is unblocked
f) Exit The thread terminates

b
Start
a Ready Running
c
f
e d

Blocked Terminate
Thread queues

Ready queue
Admit Dispatch
CPU

Preemption

Event occurs Wait condition 1

Event occurs Wait condition 2

Event occurs Wait condition 3

 Context switch

• It happens when
– The thread has been “preempted” by another higher priority
thread
– The thread blocks on some condition
– In time-sharing systems, the thread has completed its “round”
and it is the turn of some other thread
• We must be able to restore the thread later
– Therefore we must save its state before switching to another
thread
Time sharing systems

• In time sharing systems,

– Every thread can execute for maximum one round
• For example, 10msec
– At the end of the round, the processor is given to another
thread

Ready queue Context

Switch

CPU

Timer
interrupt
Background on Programming …

• An Example: Sensor networks …

TinyOS: OS for WSN

• Scheduler:
– two level scheduling: events and tasks
– scheduler is simple FIFO
– a task can not preempt another task
– events (interrupts) preempt tasks (higher priority)
main {
…
while(1) {
while(more_tasks)
schedule_task;
sleep;
}
}
TinyOS: OS for WSN
typedef struct {
tp
void (*tp) ();
} TOSH_sched_entry_T; TOSH_MAX_TASKS

Task code
TOSH_sched_full
TOSH_sched_free

TOSH_queue

enum {
TOSH_MAX_TASKS = 8,
TOSH_TASK_BITMASK = (TOSH_MAX_TASKS - 1)};

TOSH_sched_entry_T TOSH_queue[TOSH_MAX_TASKS];
volatile uint8_t TOSH_sched_full;
volatile uint8_t TOSH_sched_free;
TinyOS: OS for WSN
void TOSH_sched_init(void)
{
TOSH_sched_free = 0;
TOSH_sched_full = 0;}

bool TOS_empty(void)
{
return TOSH_sched_full == TOSH_sched_free;
}
TinyOS: OS for WSN
bool TOS_post(void (*tp) ()) __attribute__((spontaneous)) {
__nesc_atomic_t fInterruptFlags;
uint8_t tmp;
/*
fInterruptFlags = __nesc_atomic_start(); * TOS_post (thread_pointer)
*
tmp = TOSH_sched_free; * Put the task pointer into the
TOSH_sched_free++; * next free slot.
TOSH_sched_free &= TOSH_TASK_BITMASK; * Return 1 if successful,
* 0 if there is no free slot.
if (TOSH_sched_free != TOSH_sched_full) { *
__nesc_atomic_end(fInterruptFlags); * This function uses a
* critical section to protect
TOSH_queue[tmp].tp = tp; * TOSH_sched_free.
return TRUE; * As tasks can be posted in both
} * interrupt and non-interrupt
else { * context, this is necessary.
TOSH_sched_free = tmp; */
__nesc_atomic_end(fInterruptFlags);

return FALSE;
}
}
TinyOS: OS for WSN
bool TOSH_run_next_task () {
__nesc_atomic_t fInterruptFlags; uint8_t old_full; void (*func)(void);

if (TOSH_sched_full == TOSH_sched_free) return 0;

else {
fInterruptFlags = __nesc_atomic_start();
old_full = TOSH_sched_full;
TOSH_sched_full++; /*
TOSH_sched_full &= TOSH_TASK_BITMASK; * TOSH_schedule_task()
func = TOSH_queue[(int)old_full].tp; *
TOSH_queue[(int)old_full].tp = 0; * Remove the task at the head of
__nesc_atomic_end(fInterruptFlags); * the queue and execute it,
func(); * freeing the queue entry.
return 1; * Return 1 if a task was executed,
} * 0 if the queue is empty.
} *
* This function does not need a
void TOSH_run_task() { * critical section because it
while (TOSH_run_next_task()); * is only run in non-interrupt
TOSH_sleep(); * context; therefore,
TOSH_wait(); * TOSH_sched_full does not
} * need to be protected.
 resource

• a resource can be
– a HW resource like a I/O device
– a SW resource, i.e. a data structure
– in both cases, access to a resource must be regulated to
avoid interference
• example 1
– if two processes want to print on the same printer, their
access must be sequentialised, otherwise the two printing
could be intermangled!
• example 2
– if two threads access the same data structure, the operation
on the data must be sequentialized otherwise the data could
be inconsistent!
 interaction model

• activities can interact according to two fundamental

models
– shared memory
• All activities access the same memory space
– message passing
• All activities communicate each other by sending messages
through OS primitives
– we will analize both models in the following slides
shared memory

• shared memory communication

– it was the first one to be supported in old OS
– it is the simplest one and the closest to the machine
– all threads can access the same memory locations

Thread Thread Thread

1 2 3

Shared memory
 mutual exclusion problem

• we do not know in advance the relative speed of the

processes
– we don’t know the order of execution of the hardware instructions

shared memory void *threadA(void *) void *threadB(void *)

{ {
...; ...;
int x ; x = x + 1; x = x + 1;
...; ...;
} }

• bad interleaving:
...
LD R0, x TA x = 0
LD R0, x TB x = 0
INC R0 TB x = 0
ST x, R0 TB x = 1
INC R0 TA x = 1
ST x, R0 TA x = 1
...
 critical sections

• definitions
– the shared object where the conflict may happen is a “resource”
– the parts of the code where the problem may happen are called
“critical sections”
• a critical section is a sequence of operations that cannot be interleaved
with other operations on the same resource
– two critical sections on the same resource must be properly
sequentialized
– we say that two critical sections on the same resource must
execute in MUTUAL EXCLUSION
– there are three ways to obtain motual exclusion
• implementing the critical section as an atomic operation
• disabling the preemption (system-wide)
• selectively disabling the preemption (using semaphores and mutual
exclusion)
 critical sections: atomic operations

• in single processor systems

– disable interrupts during a critical section
• problems:
– if the critical section is long, no interrupt can arrive during the
critical section
• consider a timer interrupt that arrives every 1 msec.
• if a critical section lasts for more than 1 msec, a timer interrupt
could be lost!
– concurrency is disabled during the critical section!
• we must avoid conflicts on the resource, not disabling
interrupts!
 critical sections: atomic operations (2)

• multi-processor
– define a flag s for each resource
– use lock(s)/unlock(s) around the critical section
• problems:
– busy waiting: if the critical section is long, we waste a lot of
time
– cannot be used in single processors!

int s;
...
lock(s);
<critical section>
unlock(s);
...
 critical sections: disabling preemption

• single processor systems

– in some scheduler, it is possible to disable preemption for a
limited interval of time
– problems:
• if a high priority critical thread needs to execute, it cannot make
preemption and it is delayed
• even if the high priority task does not access the resource!

<disable preemption>
<critical section>
<enable preemption> no context
switch may happen
during the critical
section
 general mechanism: semaphores

• Djikstra proposed the semaphore mechanism

– a semaphore is an abstract entity that consists
• a counter
• a blocking queue
• operation wait
• operation signal
– the operations on a semaphore are considered atomic
 semaphores

• semaphores are basic mechanisms for providing

synchronization
– it has been shown that every kind of synchronization and
mutual exclusion can be implemented by using sempahores
– we will analyze possible implementation of the semaphore
mechanism later

typedef struct {
<blocked queue> blocked;
int counter;
} sem_t; Note:
the real prototype
void sem_init (sem_t &s, int n); of sem_init is
slightly different!
void sem_wait (sem_t &s);
void sem_post (sem_t &s);
 wait and signal

• a wait operation has the following behavior

– if counter == 0, the requiring thread is blocked
• it is removed from the ready queue
• it is inserted in the blocked queue
– if counter > 0, then counter--;
• a post operation has the following behavior
– if counter == 0 and there is some blocked thread, unblock it
• the thread is removed from the blocked queue
• it is inserted in the ready queue
– otherwise, increment counter
semaphores
void sem_init (sem_t *s, int n)
{
s->count=n;
...
}

void sem_wait(sem_t *s)

{
if (counter == 0)
<block the thread>
else
counter--;
}

void sem_post(sem_t *s)

{
if (<there are blocked threads>)
<unblock a thread>
else
counter++;
}
signal semantics

• what happens when a thread blocks on a semaphore?

– in general, it is inserted in a BLOCKED queue
• extraction from the blocking queue can follow different
semantics:
– strong semaphore
• the threads are removed in well-specified order
• for example, the FIFO order is the fairest policy, priority based
ordering, ...
– signal and suspend
• after the new thread has been unblocked, a thread switch happens
– signal and continue
• after the new thread has been unblocked, the thread that executed the
signal continues to execute
• concurrent programs should not rely too much on the
semaphore semantic
 mutual exclusion with semaphores

• how to use a semaphore for critical sections

– define a semaphore initialized to 1
– before entering the critical section, perform a wait
– after leaving the critical section, perform a post
sem_t s;
...
sem_init(&s, 1);

void *threadA(void *arg) void *threadB(void *arg)

{ {
... ...
sem_wait(&s); sem_wait(&s);
<critical section> <critical section>
sem_post(&s); sem_post(&s);
... ...
} }
mutual exclusion with semaphores (2)

semaphore sem_wait(); (TA)

<critical section (1)> (TA)
sem_wait() (TB)
counter 0
1 <critical section (2)> (TA)
sem_post() (TA)
<critical section> (TB)
sem_post() (TB)
synchronization
• how to use a semaphore for synchronization
– define a semaphore initialized to 0
– at the synchronization point, perform a wait
– when the synchronization point is reached, perform a post
– in the example, threadA blocks until threadB wakes it up
sem_t s;
...
sem_init(&s, 1);
void *threadA(void *) void *threadB(void *)
{ {
... ...
sem_wait(&s); sem_post(&s);
... ...
} }

how can both A and B synchronize on the same instructions?

 semaphore implementation

• system calls
– wait() and signal() involve a possible thread-switch
– therefore they must be implemented as system calls!
• one blocked thread must be removed from state RUNNING and
be moved in the semaphore blocking queue
• protection:
– a semaphore is itself a shared resource
– wait() and signal() are critical sections!
– they must run with interrupt disabled and
by using lock() and unlock() primitives
 semaphore implementation (2)

void sem_wait(sem_t *s)

{
spin_lock_irqsave();
if (counter==0) {
<block the thread>
schedule();
} else s->counter--;
spin_lock_irqrestore(); void sem_post(sem_t *s)
} {
spin_lock_irqsave();
if (counter== 0) {
<unblock a thread>
schedule();
} else s->counter++;
spin_lock_irqrestore();
}
RTOS Standards: POSIX
RTOS Standards: OSEK
Definitions of Real-time system
• Interactions between the system and the environment
(environment dynamics).
• Time instant when the system produces its results (performs an
action).
• A real-time operating system is an interactive system that
maintains an ongoing relationship with an asynchronous
environment i.e. an environment that progresses irrespective of
the RTS
• A real-time system responds in a (timely) predictable way to
(un)predictable external stimuli arrival.
• (Open, Modular, Architecture Control user group - OMAC): a
hard real-time system is a system that would fail if its timing
requirements were not met; a soft real-time system can tolerate
significant variations in the delivery of operating system services
like interrupts, timers, and scheduling.
• In real-time computing correctness depends not only on
the correctness of the logical result of the computation but
also on the result delivery time (timing constraints).
Timing constraints

• Where do they come from ?

• From system specifications (design choices?)
Automotive systems development process
• V-cycle

from Magneti Marelli web site

Specifications

Software design
sign-off
Control algorithm
design

Functional
Control design testing
sign-off

Software design
 RTS and Platform-Based Design
Platform based design and the decoupling of Functionality and Architecture
enable the reuse of components on both ends in the meet-in-the middle
approach
Reuse of functions on different
architectures
Application Space Vehicle functional model
Independent of Platform
Application
instance
Functional
Platform
specification
Functional Model System platform model
interface System
Platform Independent from both and suitable for
Architecture Stack evaluation of mapping solutions
Architecture Platform
Platform space
exploration
Platform
instance
Execution architecture model
Architecture Space Independent of Functionality
Reuse of resources to
implement different
functions
RTS and Platform-Based Design
• Design (continued): matching the logical design into the SW
architecture design
Dispenser Kiosk

«entity» {persistence = persistent} notifies 1 «entity» {persistence = persistent}

Fuel Observer thePrice Fuel
1 theManager
price per litre price per litre
grade 1..16 1 Fuel Change Manager
grade
set price 3 updated by notify set price
get price theObserver gets price from get price
3 fuelPrice
1 updated by
fuel type available at
1
1
1
«focus»
3 1 Dispenser Kiosk Controller
«boundary» «auxiliary» {semantics = controls EH Unit}
EH Unit myEHUnits myDispenser fuel price
Valve dispenser number
2 1

Timing constraints (from

transaction fuel price fuel amount
status active
myValves the 'active' EH Unit is one of the active EH id fuel grade
open EH id
nozzle removed aggregate EH Units of the Dispenser fuel_grade transaction amount
close
dispensing authorised abort select grade
«boundary» get transaction details new price information
halt

functional model)
0..1 active 1 halt 1..16 controlled by 1 payment due
Motor 1 resume
activeEH theDispenser get fuel price aDispenser theKiosk dispensing authorized
status myMotor fuel pulse
nozzle replaced request service display fuel price
stop
dispensing authorised «boundary» request service
start Keyboard Unit 1 1
resume halt dispensing
1 «entity» {persistence = transitory} myController resume dispensing
«boundary» myEH dispensing completed
Fuel Transaction
Flowmeter 1 select dispenser
1
myMeter litres dispensed abort transaction
count 1
price per litre collect transaction
«boundary» 1 total cost 1 dDisplay 1
Holster Switch mySwitch create «boundary»
0..1 1
collect details Dispenser Display
status
destroy
perform display check 1 theDisplay sends trans. details to
add 5ml
freeze display «boundary»
update display Kiosk Display

display transaction details

This Class Diagram is an early, pre-task design view of class relationships, based on the Object design interaction models. display dispenser idle
display dispensing authorised
This diagram would be considerably enhanced as further implementation detail was added. dispensing suspended 1 theEPOS
display service request «boundary»
EPOS
display payment due
display fuel price process transaction
clear

Task and
Resources Threads (tasks)
resource
Threads (tasks)
model

RTOS API

RTOS
Timing attributes (from
platform deployment)
An introduction to Real-Time scheduling
• Application of schedulability theory (worst case timing
analysis and scheduling algorithms)
• for the development of scheduling and resource
management algorithms inside the RTOS, driving the
development of efficient (in the worst case) and predictable
OS mechanisms (and methods for accessing OS data
structures)
• for the evaluation and later verification of the design of
embedded systems with timing constraints and possibly for
the synthesis of an efficient implementation of an
embedded system (with timing constraints) model
– synthesis of the RTOS
Real-time scheduling
• Assignment of system resources to the software threads
• System resources
– pyhsical: CPU, network, I/O channels
– logical: shared memory, shared mailboxes, logical channels
• Typical operating system problem
• In order to study real-time scheduling policies we need a model
for representing
– abstract entities
• actions,
• events,
• time, timing attributes and constraints
– design entities
• units of computation
• mode of computation
• resources
Classification of RT Systems
• Based on input
– time-driven: continuous (synchronous) input
– event-driven: discontinuous (asynchronous) input
• Based on criticality of timing constraints
– hard RT systems: response of the system within the timing
constraints is crucial for correct behavior
– soft RT systems: response of the system within the timing
constraints increases the value of the system
• Based on the nature of the RT load:
– static: predefined, constant and deterministic load
– dynamic: variable (non deterministic) load
• real world systems exhibit a combination of these characteristics
Classification of RT Systems: criticality

• Typical Hard real time systems

– Aircraft, Automotive
– Airport landing services
– Nuclear Power Stations
– Chemical Plants
– Life support systems
• Typical Soft real time systems
– Multimedia
– Interactive video games
Classification of RT Systems: criticality

• Hard, Soft and Firm type

value value value

Hard type Firm type Soft type

time time time

0

deadline deadline deadline

-∞
Classification of RT Systems: Input-based

• Event-Triggered vs. Time-Triggered models

• Time triggered
– Strictly periodic activities (periodic events)
• Event triggered
– activities are triggered by external or internal asynchronous
events, not necessarily related to a periodic time reference
Classification of RT Systems: Input-based

• Example, activity to be executed when the temperature

exceeds the warn level:
• event triggered
• – Action triggered only when temperature > warn
• time triggered
• – controls temperature every int time units; recovery is
triggered when temperature > warn
Classification of RT Systems: Input-based

• Activation models

Periodic Aperiodic Sporadic

Periodic with jitter

Modeling Real-time systems

• We need to identify (in the specification and design phase)

– Events and Actions (System responses).
• Some temporal constraints are explicitly expressed as a
results of system analysis
– “The alarm must be delivered within 2s from the time instant a
dangerous situation is detected”
• More often, timing constraints are hidden behind
sentences that are apparently not related to time …
– And are the result of design choices ….
Modeling Real-time systems

• Example: plastic molding

• The controller of the temperature must be activated within
τtemp seconds from the time instant when temperature
thresholds are surpassed, such that Tboil < T < Tflow
Modeling Real-time systems

• … the injector must be shut down no more than τinj

seconds after receiving the end-run signals A or B such
that vinjτinj < δ
Modeling Real-time systems

• (UML profile, alternate notation)

InstanceA : InstanceB :

helloMsg
{0 ms}
{1.5 ms}

{2 ms}

2.7 ms

{4.7 ms}

ackMsg
{10.2 ms}

{11 ms}
Modeling Real-time systems
• What type of timing constraints are in a Simulink
diagram?
Scheduling of Real-time systems
• What are the key concepts for real-time systems?
– Schedulable entities (threads)
– Shared resources (physical – HW / logical)
– Resource handlers (RTOS)
• Defined in the design of the Architectural level
Our definition of real-time
• Based on timing correctness
Completion time Slack
– includes timing constraints Start time
Deadline
• Response times
• Deadlines
• Jitter Release time
time
• Release times, slack …
• Precedence and resource constraints
Real-time systems: handling timing constraints

• Real Time = the fastest possible implementation dictated by

technology and/or budget constraints ?

• “the fastest possible response is desired. But, like the cruise control
algorithm, fastest is not necessarily best, because it is also desirable
to keep the cost of parts down by using small microcontrollers. What is
important is for the application requirements to specify a worst-case
response time. The hardware and software is then designed to meet
those specifications“
• “Embedded systems are usually constructed with the least powerful
computer that can meet the performance requirements. Marketing and
sale concerns push for using smaller processors and less memory
reducing the so-called recurring costs”
 Real-time systems: handling timing constraints

• Faster is always better ?

Task 1

Task 2

Task 1

Task 2
Real-time systems: handling timing constraints

• Scheduling anomalies [Richards]

• The response time of a task in a real-time system may
increase if
– the execution time of some of the tasks is reduced
– precedence constraints are removed from the specifications
– additional resources (processors) are added to the system ...
Operating Systems background
• Scheduling anomalies
completion time=12

C
T1 3
T2 2
T3 2
P1 T1 T9 T4 2
P2 T2 T4 T5 T7 T5 4
P3 T3 T6 T8 T6 4
T7 4
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 T8 4
T9 9
Operating Systems background
• Increasing the number of processors …
completion time=15

C
T1 3
T2 2
T3 2
P1 T1 T7
T4 2
P2 T2 T5 T8
T5 4
P3 T3 T6 T9 T6 4
P4 T4 T7 T7 4

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
T8 4
T9 9
A typical solution: cyclic scheduler

• Used for now 40 years in industrial practice

• military
• navigation
• monitoring
• control …
• Examples
• space shuttle
• Boeing 777
• code generated by Mathworks embedded coder (single task
mode)
A typical solution: cyclic scheduler
The individual tasks/functions are arranged in a cyclic pattern according
to their rates, the schedule is organized in a major cycle and a minor
cycle.

ABE ACF AB AD AB AC ABG ADH

50msec (GCD of periods)

Minor cycle

400msec (LCM of periods)

Major cycle

= 50 msec function A
= period 100 msec (function B)
= 200 msec (2 functions C, D)
= 400 msec (4 functions : E, F, G, H)
A typical solution: cyclic scheduler

Advantages:
• simplicity (no true OS, only dispatcher tables)
• efficiency
• observability
• jitter control
• extremely general form (handles general precedence and resource
constraints)
Disadvantages
• almost no flexibility
• potentially hides fundamental information on task interactions
• additional constraints on scheduling
• all functions scheduled in a minor cycle must terminate before
the end of the minor cycle.
A+B+E ≤ minor cycle time (the same for A+C+F, A+B+G, A+D+H)
Problems with cyclic schedulers
• Solution is customized upon the specific task set
– a different set, even if obtained incrementally, requires a completely
different solution
• Race conditions may be “hidden” by the scheduling solution
– see the shared resource section
– problems due to non-protected concurrent accesses to shared
resources may suddenly show up in a new solution
Problems with cyclic schedulers
• Solution is customized upon the specific task set
• what happens if in our example …
– we change the implementation of C and A+C+F > minor cycle?
– Possible solution: C is split in C1 and C2 (this might not be easy)

ABE A C1 F A B C2 AD A B C1 A C2 ABG ADH

50msec (GCD of periods)

Minor cycle

400msec (LCM of periods)

Major cycle

– we change the execution rate of (some) functions?

– The minor and major cycle time change! We must redo everything!
From cyclic schedulers (Time triggered systems) to
Priority-based scheduling
• Periodic timer:
– once initialized send periodic TimeEvents at the appropriate time
instants (minor cycle time) until explicitly stopped or deleted
• Threads exclusively activated by periodic timers are periodic
tasks
– scheduled according to a fixed priority policy
A Taxonomy for FP scheduling

D=T D<=T Any D

Optimal pri ass. Y (RM) [L&L] Y (DM) [JP] [Leh] Yes (Aud) [Aud]
Test Util (sufficient) Resp. time (1st inst.) Resp. time (1st busy
Resp. time (1st inst.) Process. demand period)
Process. demand Process. demand

With Resources

Optimal Pri ass. NP-complete [Mok]

Test Sufficient tests (PIP,PCP)

With Offsets
Optimal Pri ass. Yes (Aud) [Aud]
Test Processor Demand
Case 1: Independent periodic tasks

• Activation events are periodic (period=T),

• Deadlines are timing contraints on the execution of tasks (D=T)
– evey task instance must be completed before the next instance
– (no need to provide queues (buffers) for activation events)
• tasks are independent
– the execution of a task does not depend upon the execution
(completion) of another task
– periods may be correlated
• The execution time of each task is constant
– approximated with the worst case execution time
Task set

• n indipendent tasks τ1, τ2, … τn

• Task periods T1, T2, ... Tn
– the activation rate of τi is 1/Ti
• Execution times are C1, C2, ... Cn
Scheduling algorithm
• Rules dictating the task that needs to be executed on
the CPU at each time instant
• preemptive & priority driven
– task have priorities
• statically (design time) assigned
– at each time the highest priority task is executed
• if a higher piority task becomes ready, the execution of the
running task is interrupted and the CPU given to the new task
• In this case, scheduling algorithm = priority
assignment + priority queue management
Priority-based scheduling
• Static (fixed priorities)
• as opposed to ... Dynamic
– the priority of each task instance may be different from the
priority of other instances (of the same task)
Definitions ...
• Deadline of a task - latest possible completion time and
time instant of the next activation
• Time Overflow when a task completes after the deadline
• A scheduling algorithm is feasible if tasks can be
scheduled without overflow
• Critical instant of a task = time instant t0 such that, if the
task instance is released in t0, it has the worst possible
response (completion) time (Critical instant of the system)
• Critical time zone time interval between the critical instant
and the response (completion) of the task instance
Critical instant for fixed priorities
• Theorem 1: the critical instant for each task is when
the task instance is released together with (at the
same time) all the other higher priority instances
• The critical instant may be used to check if a priority
assignment results in a feasible scheduling
– if all requests at the critical instant complete before their
deadlines
Example
• τ1 & τ2 with T1=2, T2=5, & C1=1, C2=1
• τ1 has higher priority than τ2
– priority assignment is feasible
– C2 may b increased to 2 and the task set is still feasible

T1 T1 t
t
1 2 3 4 5 1 2 3 4 5

T2 t
T2 t
1 2 3 4 5 1 2 3 4 5

CRITICAL TIME ZONE CRITICAL TIME ZONE

Example
• However, if τ2 has higher priority than τ1
– Assignment is still feasible
– but computation times cannot be further increased C1=1, C2=1

T2 t
1 2 3 4 5

T1 t
1 2 3 4 5

CRITICAL
TIME ZONE
Rate Monotonic

• Priority assignment rule Rate-Monotonic (RM)

• Assign priorities according to the activation rates (indipendently
from computation times)
– higher priority for higher rate tasks (hence the name rate monotonic)
• RM is optimal (among all possible staic priority assignments)
• Theorem 2: if the RM algorithm does not produce a feasible
schedule, then there is no fixed priority assignment that can
possibly produce a feasible schedule
A priori guarantees
• Understanding at design time if the system is
schedulable
• different methods
– utilization based
– based on completion time
– based on processor demand
Processor Utilization
• Processor Utilization Factor: fraction of processor time spent in
executing the task set
• i.e. 1 - fraction of time processor is idle
• For n tasks, τ1, τ2, … τn the utilization factor U is

U = C1/T1 + C2/T2 + … + Cn/Tn

• U can be improved by increasing Ci’s or decreasing Ti’s as long

as tasks continue to satisfy their deadlines at their critical
instants
Processor Utilization

• Given a priority assignment, a set of tasks fully utilizes

a processor if:
• the priority assignment is feasible for the set
• and, if an increase in the run time of any task in the set will make
the priority assignment infeasible
• The least upper bound of U is the minimum of the U’s
over all task sets that fully utilize the processor
• for all task sets whose U is below this bound, ∃ a fixed priority
assignment which is feasible
• U above this bound can be achieved only if the task periods Ti’s
are suitably related
Processor Utilization
• The upper bound on U depends on the task set

Uub = 0.833 Uub = 1

• Imagine we try all possible sets

Uub
unschedulable
100 %

Q: is there a A: yes, we can

fully utilized
task sets
minimum or build the task
0% least upper set with least
bound? upper bound
Processor Utilization for Rate-Monotonic
• RM priority assignment is optimal
• for a given task set, the U achieved by RM priority
assignment is ≥ the U for any other priority
assignment
• the least upper bound of U = the minimum Uub for RM
priority assignment over all possible T’s and all C’s
for the tasks
Processor Utilization
• Theorem: For a set of n tasks with fixed priority
assignment, the least upper bound to processor
utilization factor is U=n(21/n-1)

• Or, equivalently, a set of n periodic tasks scheduled

by RM algorithm will always meet their deadlines for
all task start times if

C1/T1 + C2/T2 + … + Cn/Tn ≤ n(21/n-1)

Processor Utilization

• If n→∞, U converges quickly to ln 2 = 0.69

• sufficient only condition (quite restrictive)
– what happens to the missing 31%?
• We need a necessary and sufficient condition!

0,9

0,8

0,7

0,6
1 2 3 4 5 6 7 8 9 10

1 0,828 0,78 0,757 0,743 0,735 0,729 0,724 0,721 0,718

number of t a s k s
Response time based guarantee
• Response time is the sum of
• Execution time
– Time spent executing the task
• Non schedulable entities with higher priority
– Interrupt Handlers
• Scheduling interference
– Time spent executing higher priority jobs
• Blocking time
– Time spent executing lower priority tasks
• Because of access to shared resources

• Applying the critical instant theorem we can compute the worst

case completion time (response time) ...
Theorem 1 Recalled
• Theorem 1: A critical instant for any task occurs whenever the
task is requested simultaneously with requests of all higher
priority tasks
• Can use this to determine whether a given priority assignment
will yield a feasible scheduling algorithm
• if requests for all tasks at their critical instants are fulfilled before their
respective deadlines, then the scheduling algorithm is feasible
• Applicable to any static priority scheme… not just RM
Example #1
• Task τ1 : C1 =20; T1 =100; D1 =100
Task τ2 : C2 =30; T2 =145; D2 =145

Is this task set schedulable?

U = 20/100 + 30/145 = 0.41 ≤ 2(21/2-1) = 0.828

Yes!
Example #2
• Task τ1 : C1 =20; T1 =100; D1 =100
Task τ2 : C2 =30; T2 =145; D2 =145
Task τ3 : C3 =68; T3 =150; D3 =150

Is this task set schedulable?

U = 20/100 + 30/145 + 68/150

= 0.86 > 3(21/3-1) = 0.779

Can’t say! Need to apply Theorem 1.

Example #2 (contd.)

• Consider the critical instant of τ3, the lowest priority

task
– τ1 and τ2 must execute at least once before τ3 can begin
executing
– therefore, completion time of τ3 is ≥ C1 +C2 +C3 =
20+68+30 = 118
– however, τ1 is initiated one additional time in (0,118)
– taking this into consideration, completion time
of τ3 = 2 C1 +C2 +C3 = 2*20+68+30 = 138
• Since 138 < D3 = 150, the task set is schedulable
Response Time Analysis for RM
• For the highest priority task, worst case response
time R is its own computation time C
– R=C
• Other lower priority tasks suffer interferences from
higher priority processes
– Ri = Ci + Ii
– Ii is the interference in the interval [t, t+Ri]
Response Time Analysis (contd.)

• Consider task i, and a higher priority task j

• Interference from task j during Ri:
– # of releases of task k = Ri/Tj
– each will consume Cj units of processor
– total interference from task j = Ri/Tj * Cj
• Let hp(i) be the set of tasks with priorities higher than
that of task i
• Total interference to task i from all tasks during Ri:
Response Time Analysis (contd.)
• This leads to:

 Ri 
Ri = Ci + ∑  C j
j∈hp ( i )  T j 

• Smallest Ri will be the worst case response time

• Fixed point equation: can be solved iteratively

 win
wi = Ci + ∑  C j
n +1

j∈hp ( i )  T j 
Algorithm
Deadline Monotonic (DM)

• If deadlines are different from the periods, then RM is no

more optimal
• If deadlines are lower than periods the Deadline
Monotonic policy is optimal among all fixed-priority
schemes
Deadline Monotonic (DM)

• Fixed priority of a process is inversely proportional to its

deadline (< period)
Di < Dj ⇒ Pi > Pj
• Optimal: can schedule any task set that any other static
priority assignment can
• Example: RM fails but DM succeeds for the following
Deadline Monotonic (DM)

• The sufficient-only utilization bound is very pessimistic ...

• The set (C, D, T) τ1=(1, 1.5, 5) and τ2=(1.5, 3, 4) is

schedulable even if ...

Σi Ci/Di = 1/1.5+1.5/3 = 0.66+0.5 = 1.16 > 1

Can one do better?
• Yes… by using dynamic priority assignment

• In fact, there is a scheme for dynamic priority

assignment for which the least upper bound on the
processor utilization is 1

• More later...
Arbitrary Deadlines
• Case when deadline Di < Ti is easy…
• Case when deadline Di > Ti is much harder
– multiple iterations of the same task may be alive
simultaneously
– may have to check multiple task initiations to obtain the
worst case response time
• Example: consider two tasks
– Task 1: C1 = 28, T1 = 80
– Task 2: C2 = 71, T2 = 110
– Assume all deadlines to be infinity
Arbitrary Deadlines (contd.)
• Response time for task 2:
activation completion time response time
0 127 127
110 226 116
220 353 133
330 452 122
440 551 111
550 678 128
660 777 117
770 876 106

• Response time is worst for the third instance (not

the first one at the critical instant !)
– Not sufficient to consider just the first iteration
Arbitrary Deadlines (contd.)
• Furthermore, deadline monotonic priority
assignment is not optimal anymore ...
• Let n = 2 with
• C1 = 52, T1 = 100, D1 = 110
• C2 = 52, T2 = 140, D2 = 154.
• if τ1 has highest priority, the set is not schedulable
(first instance of τ2 misses its deadline)
• if τ2 has highest priority ...

t1 response times t2 response times

104 52
208 192
260 332
Arbitrary Deadlines (contd.)

• Can we find a schedulability test ?

– Yes
• Can we find an optimal priority assignment ?
– Yes
Schedulability Condition for Arbitrary Deadlines

• Analysis when Di (and hence potentially Ri ) can be greater than Ti

 w n
i (q)

wi (q ) = (q + 1)Ci + ∑ 
n +1
C j
j∈hp ( i )  T j 
Ri (q) = wi (q ) − qTi
• The number of releases that need to be considered is bounded by
the lowest value q* of q = 0,1,2,… for which the following relation is
true:

q* = min q Ri (q ) ≤ Ti
• Note: for D ≤ T, the condition is true for q=0 if the task can be
scheduled, in which case the analysis simplifies to original
– if any R>D, the task is not schedulable
Arbitrary Deadlines (contd.)

• The worst-case response time is then the maximum

value found for each q:

Ri = max q =0,..q* Ri (q)

Optimal priority assignment for Arbitrary Deadlines
• Audsley’s algorithm Glossary

PriorityAssignment(∆)
∆ set of all tasks
{
j priority level
for j in (n..1) { feasible() feasibility test
unassigned = TRUE Ψ(j) inverse of priority
for τA in ∆ { level assignment
if ((feasible(τA, j)) { function
Ψ(j) = τA
∆ = ∆ – τA
unassigned = FALSE
}
if (unassigned)
exit // NOT SCHEDULABLE
}
}
• Processor demand criterion
Response Time Analysis
• Response time Analysis runs in pseudopolynomial
time
• Is it possible to know a-priori the time intervals over
which the test should be performed?
– The iterative procedure tests against increasing intervals
corresponding to the wik
• The alternative method is called processor demand
criterion
• It applies to the case of static and dynamic priority
Fixed Priority Scheduling
• Utilization-based Analysis
• Response time Analysis
• Processor Demand Analysis
– Important: allows for sensitivity analysis ....
Processor Demand Analysis
• Consider tasks τ1, τ2, … τn in decreasing order of
priority
• For task τi to be schedulable, a necessary and
sufficient condition is that we can find some t ∈ [0,Ti]
satisfying the condition

t = t/T1C1 + t/T2C2 + … t/Ti-1Ci-1 + Ci

• But do we need to check at exhaustively for all values

of t in [0,Ti]?
Processor Demand Analysis
• Clearly only Ti is not enough ...
• Example: consider the set τ1=(2, 5) and τ2=(3,6)
• The processor demand for τ2 in [0,6] is 7 units
• ... but the system is clearly schedulable since the
processor demand in [0,5] is 5 units
Processor Demand Analysis
• Observation: right hand side of the equation changes
only at multiples of T1, T2, … Ti-1
• It is therefore sufficient to check if the inequality is
satisfied for some t ∈ [0,Ti] that is a multiple of one or
more of T1, T2, … Ti-1

t ≥ t/T1C1 + t/T2C2 + … t/Ti-1Ci-1 + Ci

Processor Demand Analysis

• Notation
Wi(t) = Σj=1..iCjt/Tj
Li(t) = Wi(t)/t
Li = min0 ≤ t ≤ Ti Li(t)
L = max{Li}
• General sufficient & necessary condition:
– Task τi can be scheduled iff Li ≤1
• Practically, we only need to compute Wi(t) at all times
αi = {kTj | j=1,…,I; k=1,…,Tj/Tj}
– these are the times at which tasks are released
– Wi(t) is constant at other times
• Practical RM schedulability conditions:
– if mint∈αi Wi(t)/t ≤ 1, task τi is schedulable
– if maxi∈{1,…,n}{mint∈αi Wi(t)/t} ≤ 1, then the entire set is schedulable
Example

• Task set:
• τ1: T1=100, C1=20
Wi(t)
• τ2: T2=150, C2=30
• τ3: T3=210, C3=80
• τ4: T4=400, C4=100
• Then:
• α1 = {100}
• α2 = {100,150} time
• α3 = {100,150,200,210} Points that need to be checked
• α4 = {100,150,200,210,300,400}

• Plots of Wi(t): task τi is RM-schedulable iff any part of the

plot of Wi(t) falls on or below the Wi(t)=t line.
• We will improve this formulation (see next slide(s) …)
Processor Demand Analysis
• Improvement [Bini]
Preemption Threshold (dual priority)

• Derived from Fixed priority scheduling theory

– Also available for dynamic priority policies
• Uses two priority levels for each task
– Ready priority for enqueuing tasks in the ready queue
– Dispatch priority for preempting the currently executing task
– Ready priority <= Dispatch priority
• Advantages
– May perform better than purely preemptive or non-preemptive
schemes
– Allows selectively disabling preemption
Preemption Threshold (dual priority)
preemption
enabled
Higher Dispatch Priority, or
Preemption ThresholdExecuting Job’s
priority
preemption Dispatch Priority
disabled
Base priority
(ready)

• Preemptive Scheduling
– Dispatch Priority = Base Priority
• Non-Preemptive Scheduling
– Dispatch Priority = Maximum Priority
Preemption Threshold (dual priority) : esempio

Tasks Ci Ti Di πi
• Task τ1 20 70 50 1
τ2 20 80 80 2
τ3 35 200 100 3

• Worst-case Response Time

Tasks πi γi WCRT WCRT WCRT

Preemptive Non-Preemptive With Threshold
τ1 1 1 20 55 40
τ2 2 1 40 75 75
τ3 3 2 115 75 95
Preemption Threshold (dual priority): an example

τ1

τ2

τ3

0 20 40 70 80 90 95
WCRT τ3
Preemption Threshold: analysis
• Before a task τi starts execution, there is blocking from lower
priority tasks and interference from higher priority tasks.
Among all lower priority tasks, only one lower priority task can
cause blocking. The maximum blocking time of a task τi,
denoted by B(τi), is given by:

• All higher priority tasks that come before the start time
Si(q) and any earlier instances of task τi before instance q
should be finished before the q-th start time.
Preemption Threshold: analysis
• Once the q-th instance of task τi starts execution, we have to
consider the interference to compute its finish time. From the
definition of preemption threshold, we know that only tasks with
higher priority than the preemption threshold of τi can preempt
τi and get the CPU before it finishes. Furthermore, we only
need to consider new arrivals of these tasks, i.e., arrivals after
Si(q).
Release Jitter

• A key issue in
distributed systems
• Sporadic task will be
released at time 0, 5,
25, 45, and so on …
• i.e. at times 0, T-J, 2T-
J, 3T-J, and so on…
Release Jitter (contd.)
• Examination of the derivation of the schedulability
equation implies that process i will suffer one
interference from S if Ri is between 0 and T-J, that is
Ri ∈ [0, T–J), two if Ri ∈ [T–J, 2T-J), three if Ri ∈ [2T–
J, 3T-J), and so on…
Release Jitter (contd.)
• In general, periodic tasks do not suffer jitter
• But, an implementation may restrict granularity of
system timer which releases periodic tasks
• a periodic task may therefore suffer from jitter
• If response time is to be measured relative to the real
release time then the jitter value must be added to
that previously calculated:
Riperiodic = Ri + Ji
Arbitrary Deadlines with Release Jitter
Tasks with Jitter/Processor demand (dbf)
• Task τ1: T1=50, C1=10 J1=10, τ2: T2=80, C2=20 J2=20

 Ri + J j 
Ri = Ci + ∑  C j
match=wcrt
match=wcrt j∈hp ( i )  Tj 

Demand of processor time

J1 time
Availability of processor time
J2

Points/intervals that need to be

checked
Earliest Deadline First

• With EDF (dynamic priorities) the utilization bound is

100%

Task A
• RM
Task B

• EDF...
Task A
Task B

…utilization Task A
can be
further Task B
increased !
Earliest Deadline First

• EDF is clearly optimal among all scheduling schemes

• Proof for any D: interchange argument [Dertouzos ‘74]

if left side is feasible

→ so is the right side

• (Proof D=T: [LiuLayland73] follows from utilization

bound=100%)
Earliest Deadline First

• There are few (if any) commercial

implementations of EDF

“EDF implementations are inefficient and

should be avoided because a RT system
should be as fast as possible”

“EDF cannot be controlled in overload

conditions”
Implementation of Earliest Deadline First

• Is it really not feasible to implement EDF scheduling ?

• Problems
– absolute deadlines change for each new task instance,
therefore the priority needs to be updated every time the task
moves back to the ready queue
– more important, absolute deadlines are always increasing,
how can we associate a (finite) priority value to an ever-
increasing deadline value
– most important, absolute deadlines are impossible to compute
a-priori (there are infinitely many). Do we need infinitely many
priority levels?
– What happens in overload conditions?
Implementation of fixed priority

• When implementing fixed priority scheduling, it is possible to build

ready queues and semaphore queues with constant-time
insertion and extraction times (at the price of some memory)

Inserting aq task requires scanning the list

Step 1: simple ready list

Ready list (extraction O(1) insertion
First task in
O(n)) where n is the number
the list
of task descriptors
Implementation of fixed priority

• Simple queue experimental measures

Implementation of fixed priority

extracting a task
requires finding First task in
the first non-empty the ready list
bucket Inserting a task requires
0 finding the appropriate
priority bucket

0 1 1 0 1…
…
1

1
Step 2: multiple priority queue
0 ready list (extraction O(m)
insertion O(1)) where m is the
11111…
…11 1 number of priorities

Address of bucket 0
Implementation of fixed priority

• Multiple queue experimental measures

Implementation of fixed priority

Step 3: hierarchical priority

queues (extraction O(logbm)
insertion O(1)) + lookup tables
in order to avoid bit shifting. B
is the size (in bits) of the
bitmask containing the status
of the priority queues
If m=256 and b=8 than
extraction is in constant time
(2 steps)
Implementation of fixed priority

• Bitmapped queue experimental measures

Count Leading Zeros (where available)
Implementation of fixed priority

From an evaluation of VxWorks 5.3 (www.embedded-systems.com)

Implementation of fixed priority

From an evaluation of VxWorks 5.3

Implementation of Earliest Deadline First

• Problem 2: deadline encoding ?

– The EDF scheduler, requires a time reference to compute the
absolute deadline (the priority) of a newly activated task. Such
a timer must necessarily feature a long lifetime and a short
granularity. For example, in POSIX systems, a 64 bit structure
allows for a granularity of nanoseconds. In an embedded
system, such a high precision might actually become
undesirable since it leads to an unacceptable overhead.
Implementation of Earliest Deadline First

• Problem 2: deadline encoding ?

– The problem can be efficiently solved using a limited resolution
(i.e. 16 bit) timer and an algorithm first described in
[Fonseca01]. Suppose the current timer value and the
absolute deadlines are represented as 16 bit words. Each time
a task is activated, the system computes an absolute deadline
for it as the current timer value plus the task's relative
deadline: this operation could result in an overflow. However,
ignoring overflows, it is still possible to compare two absolute
deadlines in a consistent way. Suppose that the maximum
relative deadline is less than 7FFFh timer ticks, and let δ be
the difference between two absolute deadlines d1 and d2: δ is
always in the interval [-8000h; +7FFFh] and can be
expressed as a signed 16 bit integer. The sign of δ can be
used as a way to compare d1 and d2: if δ >0 then d1>d2.
 Implementation of Earliest Deadline First
• This compare algorithm is very simple and can efficiently be
implemented with two simple operations: a difference between
integers and a sign check.

0000h
1013h d1-
d1-d2 = 43F2h-
43F2h-2148h = 22AA > 0

d2 d2 d1>d2
2148h

43F2h
d1
A01Fh
d1-
d1-d2 = A01Fh-
A01Fh-1013h = 900C < 0
d1
d1<d2
8000h
Implementation of Earliest Deadline First

• Overload conditions
• EDF can give rise to a cascade of deadline miss
– There is no guarantee on which is the task that will miss its
deadline
– (see also problems with determination of worst case
completion time)
• Try the case
– C1=1 T1=4
– C2=2 T2=6
– C3=2 T3=8
– C4=3 T4=10

(utilization =106%)
Overload in FP scheduling

• Overload conditions
• Misconception: In FP the lowest priority tasks are the
first to miss the deadline
• Counterexample: start from the set (2,4) (2,6) fully
utilizing the processor
Task Synchronization
• So far, we considered independent tasks
• However, tasks do interact: semaphores, locks,
monitors, rendezvous etc.
• shared data, use of non-preemptable resources
• This jeopardizes systems ability to meet timing
constraints
• e.g. may lead to an indefinite period of priority inversion where
a high priority task is prevented from executing by a low priority
task
Optimality and Ulub
• When there are shared resources ...
– The RM priority assignment is no more optimal. As a matter
of fact, there is no optimal priority assignment (NP-complete
problem [Mok])
– The least upper bound on processor utilization can be
arbitrarily low
• It is possible (and quite easy as a matter of fact) to build a
sample task set which is not schedulable in spite of a utilization
U→0
Key concepts
• Task
– Encapsulating the execution thread
– Scheduling unit
– Each task implements an active object

• Protected Objects
– Encapsulating shared information (Resources)
– The execution of operations on protected objects is mutually
exclusive
Response time of a real-time thread
• Execution time
– time spent executing the task (alone)
• Execution of non schedulable entities
– Interrupt Handlers
• Scheduling interference
– Time spent executing higher priority jobs
• Blocking time
– Time spent executing lower priority tasks
• Because of shared resources

HIGHER PRIORITY TASK

P B
MY TASK

LOWER PRIORITY TASK Interference

Blocking
An example of “unbounded” priority inversion
τ high

S1

τ low

τ highest
Lock tried (S1)

τ high
s1

τ medium

τ low
s1 s1 s1

Normal s1 Critical section

Unbounded Priority inversion
Methods
• Non-preemptable CS
• Priority Inheritance
• Priority Ceiling (Original Priority Ceiling Protocol)
• Immediate priority ceiling or highest locker (Stack
Resource Protocols)
Non-preemptable CS
• A task cannot be preempted if in critical section
• When a task enters a CS its priority is raised to the
highest possible value
Advantages
• Simple and effective
• Prevents deadlocks
• Predictable!
Disadvantages
• May block tasks (even highest priority!) regardless of
the fact that they use (some) resource or not …
• Blocking term Bi=max(CSlp)
Preemption vs. non preemption

Task Ci Ti πi WCRT WCRT Di1 Di2

(P) (NP)
τ1 20 70 1 20 20+35 45 60
=55
τ2 20 80 2 20 + 20 20+35+20 80 80
= 40 =75
τ3 35 200 3 35+2*20+2*20 35+20+20 120 100
= 115 =75
Priority Inheritance Protocol
• [Sha89]
• Tasks are only blocked when using CS
• Avoids unbounded blocking from medium priority
tasks
• It is possible to bound the worst case blocking time if
requests are not nested
• Saved the Mars Pathfinder …
Priority Inheritance Protocol
τ high
• High and low priority tasks share a common
S1 resource
τ • A task in a CS inherits the highest priority
low
among all tasks blocked on the same resource
τ highest
Try lock on S1

τ high
s1

τ medium
Ready

τ low
s1 s1 s1

Normal s1 Critical section

priority inheritance

• low priority task inherits the priority of T1

• T2 is delayed because of push-through blocking (even if it
does not use resources!)

normal execution Push-Through

critical section Blocking
W S
T1
T2
W
T3 S
Priority Inheritance Protocol: multiple blocking

τ 1 Each task τi may block K times where

R2 K=min(ntlp(i), nrusage(i,k))
τ 2
R3
τ 3 R4
τ 4

wait (R4) wait (R3) wait (R2)

R4 R3 R2
τ1
R2 B R2
τ2

priority
B
R3 R3
τ3
R4 R4
τ4
Priority Inheritance Protocol
• Disadvantages
• Tasks may block multiple times
• Worst case behavior (CS not nested) even worse
than non-preemptable CS
• Costly implementation except for very simple cases
• Does not even prevent deadlock (nested CS)
Priority Ceiling Protocol
• priority ceiling of a resource S = maximum priority among all tasks
that can possibly access S
• A process can only lock a resource if its dynamic priority is higher
than the ceiling of any currently locked resource (excluding any that it
has already locked itself).
• If task τ blocks, the task holding the lock on the blocking resource
inherits its priority
• Two forms
– Original ceiling priority protocol (OCPP)
– Immediate ceiling priority protocol (ICPP, similar to Stack Resource
Policy SRP)
• Properties (on single processor systems)
– A high priority process can be blocked at most once during its execution
by lower priority processes
– Deadlocks are prevented
– Transitive blocking is prevented
Deadlock (prevention)
• Conditions for deadlock (Coffman 71)
1. Mutual exclusion : a resource cannot be used by more than one
process at a time
2. Hold and wait : processes already holding resources may request
new resources
3. No preemption: No resource can be forcebly removed from a
process holding it, Resources can be released only by the explicit
action of the process
4. Circular wait: two or more processes form a circular chain where
each process waits for a resource that the next process in the
chain holds

• Deadlock only occurs when all of the previous four hold true

PCP
PCPprevents
preventscircular
circularwaits!
waits!
Example of OCPP

τ 1

R2 ceiling R2 = 1
τ 2
R3 ceiling R3 = 1
τ 3 R4 ceiling R4 = 1
τ 4
wait (R4) wait (R3) wait (R2)

R4 R3 R2
τ 1 wait (R2)
R2
τ 2 wait (R3)

priority
B
R3
τ3
R4
τ 4 R4
Immediate Priority Ceiling Protocol
• High and low priority task share a
τ high
critical section
S1
• Ceiling priority of CS = Highest priority
τ low among all tasks that can use CS
• CS is executed at ceiling priority

τ highest
Ready
τ high
s1

τ medium
Ready

τ low
s1 s1

Normal s1 Critical section

Example of ICPP

τ 1

R2 ceiling R2 = 1 Execution of tasks is

τ 2
R3 ceiling R3 = 1 perfectly nested !
τ 3 R4 ceiling R4 = 1
τ 4

R4 R3 R2
τ1
ready
R2
τ2

priority
ready B
R3
τ3
R4
τ4
OCPP vs. ICPP
• Worst case behavior identical from a scheduling point of view
• ICCP is easier to implement than the original (OCPP) as
blocking relationships need not be monitored
• ICPP leads to less context switches as blocking is prior to first
execution
• ICPP requires more priority movements as this happens with all
resource usages; OCPP only changes priority if an actual block
has occurred.
Response time analysis

Response
time

Computation
Preemption from
time
higher priority tasks

Blocking from lower

priority tasks
(priority inversion) PI

PC IPC
Response Time Calculations & Blocking (contd.)

PI

PC IPC

• Where usage is a 0/1 function:

usage(k, i) = 1
if resource k is used by at least one
process with a priority less than i, and at
least one process with a priority greater or equal to i.
Otherwise it gives the result 0.

• CS(k) is the computational cost of executing the longest k-th

critical section called by a lower priority task .
Blocking time in PCP and IPCP

• An example ...

R1 R2 R3 BPIP BPCP

τ1 20 5 5
τ2 5 10 20 10
τ3 5 5 18 10
τ4 5 13 10
τ5 10 3
Example: Shared resources
ES • Task
– 5 Tasks
• Shared resources
IS
– Results buffer
• Used by R1 and R2
T1 • R1 (2 ms) R2 (20 ms)
R1 C1 – Communication buffer
• Used by C1 and C3
write()
Br write() • C1 (10 ms) C3 (10 ms)
write_2()
T2
R2

read() Bc
T3
C3
Example: Shared Resources

Task C T π WCRT WCRT D

(PI) (PC)
ES 5 50 1 5+0+0 5+0+0 6
=5 =5
IS 10 100 2 10+0+5 10+0+5 100
= 15 =15
T1 20 100 3 20+30+20 20+20+20 100
= 70 =60
T2 40 150 4 40+10+40 40+10+40 130
=90 =90
T3 100 350 5 100+0+200 100+0+200 350
=300 =300
Blocking factor in the sufficient schedulability formula
• Let Bi be the duration in which τi is blocked by lower
priority tasks
• The effect of this blocking can be modeled as if τI’s
utilization were increased by an amount Bi/Ti
• The effect of having a deadline Di before the end of
the period Ti can also be modeled as if the task were
blocked for Ei=(Ti-Di) by lower priority tasks
– as if utilization increased by Ei/Ti
Scheduling with Offsets

• Enhanced model ...

• Each periodic task τi is characterized by the
quadruple (Ti, Di, Ci, Oi )
• The offset Oi is the instant of the first request
• The requests of τi are separated by Ti time units and
occur at time Oi + (k - 1)Ti (k=1, 2, ... ).
• The execution of the k-th request of task τi, which
occurs at time Oi + (k - 1)Ti, must finish before or at
time Oi + (k - 1)Ti +Di
Scheduling with Offsets

• Synchronous model: all Oi=0

• Asynchronous model: Oi may be ≠ 0, but the values
are given
• Offset free model: the values of the Oi may be defined
to improve schedulability
Scheduling with Offsets

• The synchronous case is the worst case, hence it is

clearly pessimistic ...
• Example:
• consider the case (C, D, T)
τ1=(3, 8, 8), τ2=(6, 12, 12), τ3=(1, 12, 12)
• The example is not schedulable in the synchronous case
(not even with RM priority assignment), given that task 3
misses its deadline.
Scheduling with Offsets

• But if you try O1=0, O2=0, O3=10 the set becomes

schedulable !
Scheduling with Offsets

• This brings the promise for an increase in schedulability

– Unless all periods are prime, in which case there is still a critical
instant!
• Unfortunately ...
• The RM/DM priority assignments are no more optimal!
– We need a way to find a (possibly optimal) priority assignment
• There is no critical instant
– the standard response time test is not valid anymore
– We need a (possibly efficient) schedulability test
• There is availability of a priority assignment method and
a schedulability test !
– but what is really needed is an offset synthesis procedure !
Scheduling with Offsets

• The (RM/DM) priority assignment is (in general) not

optimal.
• counterexample (O, C, D, T)
τ1=(2, 2, 3, 4), τ2=(0, 3, 4, 8)
• if τ1 has priority higher than τ2 (as in RM/DM) deadline is
missed at time 4.
• When priorities are reversed, deadlines are met ...
Scheduling with Offsets

• Feasibility test for asynchronous task sets:

• Given a set of offsets O1, O2, ... On
• [Leung82] a task set is feasible if all deadlines are met in [s, 2P],
where s=max{O1, O2, ... On} and P = lcm {T1, T2, ... Tn}
– in practice it is sufficient to build the schedule and check all the busy
periods originating from a task release time in [s, 2P)
• For fixed priority tasks and D≤T it is possible to further restrict the
interval [Audsley91]

• This means that it is sufficient to check the interval [Sn, Sn+P]

Scheduling with Offsets

• Now we do have a test and the algorithm by audsley to

find an optimal fixed priority assignment for the case
D>T works in this case as well ...
• But ...
• the most important case (offset free systems) requires a
procedure for setting up the offsets.
• The problem of finding the optimal offset assignment is
probably NP-complete [Goosens00]
• Approximate solutions are sought ...
Scheduling with Offsets
• An example: dissimilar offset assignment [Goossens00]
The MARS PATHFINDER
A Priority Inversion case ….
The Mars Pathfinder Case
• Overview
• MARS PATHFINDER – ARCHITECTURE
• THE 1553 BUS
• THE PROBLEM
• A PRIORITY INHERITANCE SOLUTION

Mars Pathfinder was the

second mission in the
NASA Discovery program.

Mission started on
November th
16 1996 and
finished on September 27th
1997.
 The Mars Pathfinder Case

The system consists of two units:

cruiser / lander (fixed) hosting the navigation and
landing functionality and the subsystems :
• ASI/MET for sensing meteorological
atmospheric data
• IMP for image acquisition
microrover (mobile) hosting :
• APXS : X-ray spectrometer
• Image acquisition devices
System architecture

CPU Interfaces to radio

Risc RS6000 and camera

VME bus

Interface to 1553 bus

1553 bus

Cruise part: Lander part: interfaces

interfaces to to accelerometers,
propulsion, valves, altimetric radar and
sun sensor and ASI/MET
star scanner
Interface hardware
inherited from the
Cassini probe
Architecture

CPU

ASI/MET
BUS 1553

The hardware interface of

the bus assumes a bus
CRUISE cycle time of 125 ms. (8 Hz) LANDER
STAGE STAGE
 Software Architecture

• Cyclic Scheduler @ 8 Hz
• The 1553 is controlled by two tasks:
– Bus Scheduler: bc_sched computes the bus schedule for the
next cycle by planning transactions on the bus (highest priority)
– Bus distribution: bc_dist collects the data transmitted on the bus
and distributes them to the interested parties (third priority level)
– A task controoling entry and landing is second level, there are
other tasks and idle time
• bc_sched must complete before the end of the cycle to setup the
transmission sequence for the upcoming cycle.
– In reality bc_sched and bc_dist must not overlap

bc_sched

priority
bc_dist
other tasks
active bus
t1 t2 t3 t4 t5 0.125 ms
What happened

• The Mars Pathfinder probe lands on Mars on July 4th

1997
• After a few days the probe experiences continuous
system resets as a result of a detected critical (timing)
error
Software architecture of the Pathfinder
bc_dist forwards the data received
bc_dist from the bus to other tasks by using

IPC
switched communication
buffer (pipe)

Other tasks ASI/MET

reading data task

IPC (InterProcess Communication mechanism)

• VxWorks provided POSIX pipes
• Files descriptors associated to the reading and writing sides of
the pipe are shared resources protected by mutexes
• ASI/MET called a select() for reading data from the pipe
The problem
• The task responsible for system malfunctions is ASI/MET
• The ASI/MET task handles meteo data and transmits them using an
IPC mechanism based on pipe()
• Other tasks read from the pipe using the select() primitive, hiding a
mutex semaphore
• Tasks in the system
bc_sched maximum priority
bc_dist priority 3
several medium priority tasks
ASI/MET with low priority
• ASI/MET calls select() but, before releasing the mutex, is preempted
by medium priority tasks. bc_dist, when ready, tries to lock the
semaphore that controls access to the pipe. The resource is taken by
ASI/MET and the task blocks
• When bc_sched starts for setting the new cycle, it detects that the
previous cycle was not completed and resets the system.
The problem
• The select mechanism creates a mutual exclusion semaphore to
protect the "wait list" of file descriptors
• The ASI/MET task had called select, which had called pipeIoctl(),
which had called selNodeAdd(), which was in the process of giving the
mutex semaphore. The ASI/ MET task was preempted and semGive()
was not completed.
• Several medium priority tasks ran until the bc_dist task was activated.
The bc_dist task attempted to send the newest ASI/MET data via the
IPC mechanism which called pipeWrite(). pipeWrite() blocked, taking
the mutex semaphore. More of the medium priority tasks ran, still not
allowing the ASI/MET task to run, until the bc_sched task was
awakened.
• At that point, the bc_sched task determined that the bc_dist task had
not completed its cycle (a hard deadline in the system) and declared
the error that initiated the reset.
The priority inversion
RESET
bc_sched
blocked
bc_dist

Priority
others
lock
ASI/MET
0 t1 t2 t3 t4 t5 0.125 s
• ASI/MET acquires control of the bus (shared resource)
• Preemption of bc_dist
• Lock attempted on the resource
• bc_sched is activated, bc_dist is in execution after the deadline
• bc_sched detects the timing error of bc_dist and resets the system
The Solution
• After debugging on the pathfinder replica at JPL,
engineers discover the cause of malfunctioning as a
priority inversion problem.
• Priority Inheritance was disabled on pipe semaphores
• The problem did not show up during testing, since the
schedule was never tested using the final version of
the software (where medium priority tasks had higher
load)
• The on-board software was updated from earth and
semaphore parameters (global variables in the
selectLib()) were changed
• The system was tested for possible consequences on
system performance or other possible anomalies but
everything was OK
Pathfinder with PIP

bc_sched
blocked end
bc_dist

Priority
others
lock unlock
ASI/MET

0 t1 t2 t3 t4 t5 0.125 s

ASI/MET is not interrupted by medium priority tasks since

inherits bc_dist priority.
Should you use PIP?
• See “Against priority Inversion” [Yodaiken] available from the
web
• Critical sections protected by PIP semaphores produce a
large worst case blocking term
– chain-blocking
– The blocking factor is the sum of the worst case length of the
critical sections (plus protocol overhead)
• PIP does not support nested CS with bounded blocking (very
difficult to guess where implementation of OS primitives such
as pipe operations implies CS)
Should you use PIP?

• Except for very simple (but long) CS, PIP does not provide
performances better then other solutions (non preemptive CS or
PCP)
• PIP has a costly implementation, overheads include:
– Managing the basic priority inheritance mechanism not only
requires updating the priority of the task in CS, but handling
a complex data structure (not simply a stack) for storing the
set of priorities inherited by each task (one list for each task
and one for each mutex)
• Dynamic priority management implies dynamic reordering
of the task lists

• For a full account …

http://research.microsoft.com/~mbj/Mars_Pathfinder/Authoritative_Account.html
That’s all folks !

• Please ask your questions

...
• Backup slides 1- Anomalies and cyclic schedulers
Operating Systems background
• Shortening tasks

completion time=13
Operating Systems background
• Releasing precedence constraints

completion time=16