Vous êtes sur la page 1sur 55

# Chapter 3

3.1 Introduction
3.2 Rate monotonic analysis
3.3 Other uniprocessor scheduling
algorithms
3.5 Fault-tolerant scheduling
Objective : Look at techniques for allocating &

Introduction
Real-time computing objective :

Objective of Chapter:
Techniques for allocating & scheduling tasks on processors to

Real-Time Systems

Scheduling

Scheduling
research
growth

1970
Real-Time Systems

Years

## The allocation/scheduling problem can be

stated as follows:

## Given a set of factors affecting

allocation/scheduling

periodicity
timing constraints

(best described using precedence graph)
resource requirements
We are asked to devise a feasible
allocation / schedule on a given computer
Real-Time Systems

Precedence Graph
T1

T2

T3

T5

T4

T6
T7
T8

Real-Time Systems

Precedence Graph

## The arrows indicate which task has precedence over

that is , (T) indicates which tasks must be completed
before Y can begin.

Real-Time Systems

## Precedence Graph (Cont.)

<(1) =
<(2) = {1}
<(3) = {1}
<(4) = {1}
<(5) = {1,2,3} or {2,3}
<(6) = {1,3,4} T2
<(7) = {1,3,4,6}
<(8) = {1,3,4,6,7}

T1

T3

T5

T4

T6
T7
T8

Real-Time Systems

## Precedence Graph (Cont.)

We can also write :
i<j
It can also be written as :
j>i
The precedence operator is transitive:
i< j and j < k i < k

## For economic representation:

Only the list of immediate ancestors in the precedence
set:
E.g. < (5) = {2,3} since <(2) = {1}

Real-Time Systems

Each task requires resources. Eg. Processor
Resources examples:
Resources may be (depending to its usage):
Release Time of a task- the time at which all the
data that are required to begin executing the task
are available.
complete its execution. (Deadline maybe hard or
soft).
time

Real-Time Systems

Periodic
every Pi seconds, the constraints is that it has to
run exactly once every period.
not periodic but has an upper bound on the rate
in which it has to be invoked.
Irregular intervals
Aperiodic
Not periodic but has no upper bound

Real-Time Systems

10

Precedence constraints

precedence graph

T1
T4

T2

Resource requirements
exclusive
nonexclusive

T3
T5

T6

T7
T8
Real-Time Systems

11

feasible schedule
a valid schedule by which every task completes by its

in case of multiple processors

## for a set of processors P, time t, set of tasks , the

schedule S is a function such that
S: P t
S(i, t) : task scheduled to run on processor i at time t

## online (dynamically) vs offline scheduling

(precomputed)
Static(doesnt change within a mode) vs dynamic
priority algorithm
preemptive vs nonpreemptive scheduling
Real-Time Systems
12

synchronous
asynchronous

## mutual exclusion problem (synchronization)

priority inversion
chained blocking

Real-Time Systems

13

## Assignment / scheduling problems

Most problems pertaining are more than two
processors must make do with heuristics.
Heuristics are motivated by the fact that
uniprocessor scheduling are tractable.
Thus, multiprocessor schedule are divided
into two (2) steps:
2) Run a uniprocessor schedule to
schedule the task allocated to each
processor. If one or more schedules
cannot be feasible, then we must either
the allocation or declare that a schedule
cannot be found.

Real-Time Systems

14

## Developing a multiprocessor schedule

Make an
allocation
Schedule each
processor based
on the allocation

Change Allocation

## Are all these

schedules
feasible
Output schedule

Check stopping
criterion

Continue

Stop
Declare Failure

Real-Time Systems

15

Overview
Uniprocessor scheduling algorithms

rate-monotonic deferred server (DS)
precedence and exclusion conditions
increased reward with increased service

mode changes

Real-Time Systems

16

Multiprocessor scheduling

## utilization balancing algorithm

next-fit algorithm
bin-packing algorithm
myopic offline scheduling algorithm
assignment with precedence constraints

Critical sections
Fault-tolerant scheduling

Real-Time Systems

17

Notation
ci
Ti
Ii
di

## phase of periodic task i

Di
ri release time of task i

Real-Time Systems

18

## Commonly Used Approaches

Weighted round-robin approach
tasks waiting in the FIFO queue
a task with weight wt get wt time slices every round
suitable for scheduling real-time traffic in high-speed
switched networks
a switch downstream can begin to transmit an earlier portion
of the message upon receipt of the portion, without having to
wait for the arrival of the later portion

## no need for sorted priority queue speedup of

scheduling

Real-Time Systems

19

Priority-driven approach
never leaves any resource idle intentionally
greedy scheduling, list scheduling, work-conserving
scheduling
most scheduling algorithms used in nonreal-time
systems are priority-driven
preemptive vs. nonpreemptive

Real-Time Systems

20

Clock-driven(time-driven) approach
tasks and their timing constraints are known a priori
relies on hardware timers
a static schedule
constructed off-line
cyclic schedule: periodic static schedule
clock-driven schedule: cyclic schedule for hard real-time

foreground/background approach
foreground: interrupt-driven scheduling
background: cyclic executive (Big loop)

Real-Time Systems

21

Foreground/Background Systems
Background
code block
code block

Loop

Foreground

interrupt

ISR

..
.
ISR

interrupt

ISR

## ISR: interrupt service

routine

Real-Time Systems

22

A clock-driven scheduler
Input: Stored schedule (tk, (tk)) for k = 0, 1, , N-1
set the next decision point i and table entry k to 0;
set the timer to expire at tk;
do forever:
accept timer interrupt;
if an aperiodic job is executing, preempt the job;
increment i by 1;
compute the next table entry k = i mod N;
set the timer to expire at f(i/N)H + tk

## if the current task is an idle interval (or idle task),

let the job at the head of the aperiodic job queue execute
sleep;
end SCHEDULER

Real-Time Systems

23

## 3.2 Rate Monotonic Analysis

Assumptions
A1. No nonpreemptible parts in a task, and negligible
preemption cost
A2. Resource constraint on CPU time only
A3. No precedence constraints among tasks

Real-Time Systems

24

Rate-Monotonic Scheduling(RMS)
Overview
rate monotonic priority
the higher rate, the higher priority

## schedulability guaranteed if utilization rate is below a

certain limit
for feasible schedules
fi = 1/Ti : frequency (=rate)
ci or Ci : execution time
n

c f
i 1

Real-Time Systems

25

## 3.3 Other Uniprocessor Scheduling Algorithms

a modified form of RM scheduling

Dynamic scheduling
least laxity first scheduling

imprecise computation

Mode change

Real-Time Systems

26

Period Transformation

## Period transformation for transient overload

changes the period to cope with transient overloads
(in terms of RM scheduling)
actually, to cope with semantic criticality in RM
scheduling
example
T1: T1 = 12, C1 = 4, C1+ = 7

## T2: T2 = 22, C2 = 10, C2+ = 14

utilization rates: average = 0.79, worst case = 1.22

## problem: if T2 is hard rt and T1 is soft (or not), how can we

T1s deadline in the average case?

Real-Time Systems

27

(continued)
solution: boost priority of T2 by reducing its period
replace T2 by T2:
T2 = T2 /2, C2 = C2 /2, C2+ = C2 +/2
an alternative: lower the priority of T1 by lengthening its
period
in this case, double the value of parameters
the new deadline must be ok

Real-Time Systems

28

## Also know as Deadline Monotonic

EDF scheduling
scheduling

Properties
EDF is optimal for uniprocessors
periods: if the total utilization of the task set is no
greater than 1, the task set can be feasibly scheduled
on a single processor by EDF.
Allows preemptions.
Real-Time Systems

29

Procedure
1. Sort task instances that require execution in time
interval [0, L] in reverse topological order.
to (k-1)Ti + di, if necessary
3. Revise the deadlines in reverse topological order.

Real-Time Systems

30

## Uniprocessor Scheduling of IRIS Tasks

Introduction
Not necessary to run to completion. Iterative
algorithms.
Task of this type are known as increased reward

typically
0

R( x) r ( x)
r (o m)

if x m
if m x o m
if x o m

## where r(x) is monotonically nondecreasing in x.

m, o : execution time of the mandatory and optional parts,
respectively

Real-Time Systems

31

use heuristics cannot guarantee that an allocation
will be found that permits all task to be feasibly
scheduled.
consider communication costs precedence of task
completion.
Sometime an allocation algorithm uses
communication costs as part of its allocation criterion.

Real-Time Systems

32

Utilization-balancing algorithm
Objective to balance processor utilization, and proceeds by
allocating the tasks one by one and selecting the least utilized
processor.
Considers running multiple copies for fault-tolerance systems.
allocate one copy of Ti to each of the ri least utilized
processors
update the processor allocation to account for the
allocation of Ti
end do

Real-Time Systems

33

## A Next-fit algorithm for RM scheduling

Used in conjunction with RM
separation of allocation and scheduling

## simplifies the scheduler to a local one

allocation: centralized, scheduler: distributed

objectives:
to partition a task set so that each partition is scheduled later
for execution on a processor by RM scheduling
to use as few processors as possible

independent, no precedence constraints

Real-Time Systems

34

allocation algorithm
ui : utilization factor of Ti
Pi,j : set of tasks assigned to a processor
Nk : number of class-k processors used so far
tasks are divided into M classes such that

task Ti class- k if 2

1
k+1

1
k

1 u 2 1
1
M

task Ti class- M if 0 u 2 1
where 1 k < M , M >3

## assigns k class-k tasks to each class-k processor, keeping

the utilization factor of the class-M processor less than ln 2

Real-Time Systems

35

Algorithm Next-Fit-M

for k = 1 to M do set Nk = 1;
set i = 1;
while i <= n do
if Ti is a task from class-k, 1 <= k < M, then
assign Ti to Pk,Nk;
if Pk,Nk has currently k tasks assigned to it then
set Nk = Nk +1
endif
else (Ti is a task from class-M)
if the total utilization factors of all the tasks
assigned to PM,NM is greater than ln2-ui then
set NM = NM + 1
endif
assign Ti to PM,NM
endif
set i = i +1
endwhile
if Pk,Nk has not task assigned to it then set Nk = Nk -1

Real-Time Systems

36

## Bin-packing assignment algorithm for EDF

bin-packing problem: assign tasks such that the sum
of utilization factors does not exceed 1, and minimize
the number of processors needed
first fit decreasing algorithm
Initialize i to 1. Set U(j) = 0, for all j.
(L : a list of tasks with their utilizations sorted in descending
order, nT : # tasks )
while i <= nT do
Let j = min{k | U(k) + u(i) <= 1}.
Assign the i-th task in L to pj
Set i = i + 1 .
end while

Real-Time Systems

L- sorted list of
utilization are in
non-increasing

37

## Myopic Offline Scheduling (MOS) Algorithm

Offline Algorithm given in advance arrival times, execution time
Not only processor resources but also others resources such as
memory etc.

Schedule Tree
MOS proceeds by building up a schedule tree.
Each node represents an assignment and scheduling of a
The root of the schedule tree is an empty schedule.
Each child of a node consists of a schedule of its parent node,
A leaf of this tree consist of the schedule of the entire task set.

Real-Time Systems

38

## Myopic Offline Scheduling (MOS) Algorithm

algorithm
ii) determine if the current partial schedule is strongly
feasible
then proceed; else backtrack
iii) extend the current partial schedule by one task
2 Questions
when to stop

## (1) apply the heuristic function to the first Nk tasks in the

(2) choose the task with the smallest heuristic value to
extend the current schedule

Real-Time Systems

39

## Develop a node if it is strongly feasible.

If not feasible, we backtrack that is we mark that node
as hopeless and then go back to its parents

## Focused addressing and bidding (FAB)

Introduction

online
distributed environment, loosely coupled
local scheduler: handles (critical) tasks arriving at a
given node
across processor boundary
global state

Real-Time Systems

41

FAB cont.
algorithms for global scheduling
to which node the task should be sent

## noncooperative algorithm-if enough resources for critical yes;

else no for non-critical.
random scheduling algorithm-if a processor load is
exceeding its threshold then another processor is chosen
randomly.
checks its surplus info. and selects a processor which it feels
it is able to process the task within its deadline. Prob: surplus
info may be outdated.
bidding algorithm simultaneous lightly loaded to bid
(Request For Bids)
flexible algorithm <-- focused addressing + bidding

Real-Time Systems

42

parameter
locally unschedulable tasks sent to the node with
the highest surplus ( > FAS)
if no such node is found, the task is rejected

Real-Time Systems

43

bidding algorithm

## first, select k nodes with sufficient surplus

k: chosen to maximize the chances of finding a
node
a request-for-bid(RFB) message is sent to these
nodes
those nodes that receive RFB message
calculate a bid ( = likelihood that the task can
be guaranteed)
send the bid to the bidder node if the bid >
minimum bid reqd
the bidder sends the task to node that offers the
best bid
if no good bid available, reject the task

Real-Time Systems

44

symbols
pi: a processor node with a newly arriving task that is not
locally guaranteed
ps: a node that is selected by FA algorithm
pt: a node that receives RFB message

## the flexible algorithm (FAB algorithm)

pi selects k nodes with sufficient surplus
if the largest value of the surplus > FAS
the node with that surplus is chosen as focused
node(ps)
pi sends the task to ps immediately
also, pi sends in parallel a RFB message to the
remaining k-1 nodes. RFB contains info on ps
when a node receives the RFB message
it calculates a bid, sends the bid to ps if ps exists

Real-Time Systems

45

(continued)

## when the task reaches ps

it first invokes the local scheduler and checks the feasibility
if it succeeds, all the bids for the task will be ignored
if it fails, ps evaluates the bids, sends the task to the node
responding with the highest bid, and sends this info to pi

## in case there is no focused node, pi will handle the bidding

if ps cannot guarantee the task and if there is no good bid
available, then corrective actions follow

Real-Time Systems

46

ps (focused node)
(original node)

pi
network

bidding

Real-Time Systems

47

## The Buddy Strategy

Same as FAB in the sense that if the processor is
lightly
However, it differs in the manner in which it finds the
U:Under (TU), F: full (TF) and T: over (TV)
If a processor has a transition from F/T to U it broadcast
an announcement to this effect. This broadcast is not to
all processors but to a subset and this effect is known as
a buddy effect.

Real-Time Systems

48

## 3.5 Fault-Tolerant Scheduling

Introduction
in case of hardware failure
Systems have sufficient reserve capacity and
sufficiently fast failure-response mechanism.
multiple processors with a set of periodic tasks
multiple copies of each version of a task executed in
parallel
the approach taken : ghost copies of tasks
embedded into the schedule
need not be identical to the primary copies
the tasks concerned are those that were to have been run by
the failing processor

Real-Time Systems

49

Fault-tolerant schedule
should be able to run one or more copies of each
version (or iteration) of a task despite the failure of up
to nsust processor
Output of each fault-tolerant processor
has a ghost schedule + 1+ primary schedules
makes room for ghosts by shifting primary copies.

## feasible pair of a ghost schedule and a primary

schedule
if both schedules can be merged/adjusted to be feasible

Real-Time Systems

50

Ghosts
each version of a task must have ghost copies
scheduled on nsust distinct processors
ghosts are conditionally transparent, only if
two ghost copies may overlap in the schedule of a processor
if no other processor carries the copies of both tasks (that is,
if the primary copies of both tasks are not assigned to the
same processor)
primary copies may overlap the ghosts only if there is
sufficient slack time in the schedule to continue to meet all

Real-Time Systems

51

Algorithm FA1
Ha: assignment procedure, Hs: EDF scheduling procedure

## 1. Run Ha to obtain a candidate allocation of copies to

processors.
2. Run Hs for ghost and primary copies on a processor i.
otherwise, record the position of the ghost copies in ghost
schedule Gi, and the position of the primary copies in
schedule Si. (the primary copies will always be schedule
according to S regardless of any ghost happen or not)
Limitation:
- primary tasks are needlessly delayed when the ghost do
not have to be executed. While all task will meet their
deadlines, it is frequently best to complete execution of the
task early to provide slack time.

Real-Time Systems

52

Algorithm FA2
1. Run Ha to obtain a candidate allocation of copies to
processors.
2. Run Hs for ghost and primary copies on a processor i.
otherwise, record the position of the ghost copies in ghost
schedule Gi. Assign static priorities to the primary tasks in
the order in which they finish executing.

## 3. Run a static-priority preemptive scheduler for primary

copies with the priorities to obtain Si

Real-Time Systems

53

Example
ghosts: g4, g5, g6

release time
execution time

## primaries: h1, h2, h3

h1 h2 h3 g4 g5 g6
2 5 3 0 0 9
2 2 4 2 2 2
6 8 15 5 6 12

## for the primary copies of g4 and g5

case 1: they are allocated to the same processor
case 2: they are on different processors

Real-Time Systems

54

g4

g5

g6

10

15

g4, g5

g6

10

15

h1

h3

h2

h3

10

15

## feasible primary schedule of p if g4 and g5 can overlap

Real-Time Systems

55