1. Implications of Classical Scheduling Results For Real-Time Systems
John A. Stankovic, Marco Spuri, Marco Di Natale and Giorgo Buttazzo

2. Introduction Classical scheduling theory
Vast amount of literature
Not always directly applicable for RT systems
Summarize implications and new results
Provide important insight in making good design choices
Address common problems and design issues

3. Contents Preliminaries Uni-processor systems Multiprocessor systems
Preemptive vs. Non-preemptive
Precedence constraints
Shared resources
Overload
Multiprocessor systems
Static vs. Dynamic
Preemptive vs. Non-preemtive
Anomalies
An analogie
Complexity increased gradually

4. Static vs. Dynamic scheduling
The algorythm has complete preliminary knowledge regarding the task set, constraints, deadlines, computation times, release times
i.e. laboratory experiment, process control
Dynamic
The algorythm has complete knowledge on the current state, but nothing about the future
i.e. multi-agent problems
Typically problems are static

5. On-line vs. Off-line On-line calculating the schedule
Takes the current conditions into account
Decisions are based on the current conditions
Off-line scheduling is always done
Premilinary analysis (what we should expect)
A scheduling algorithm can be applied to both static and dynamic scheduling, and can be used on- or off-line
Dynamic case: static scheduling can be applied to the worst case off-line

6. Metrics Carefully choose metrics Minimize the:
Sum of completion time
Weighted sum of completion time
Schedule length
Number of required processors
Maximum lateness (useful)
Number of tasks who miss their deadlines (usually used)
Deadlines are usually included as constraints
*Useful
** Usually used

7. Problem with the Lmax property
First case: everybody missed their deadlines
Second case: 4 out of 5 have met their deadlines

8. Complexity theory NP P NP-Complete NP-Hard
NP: a proof can be recognized in polynomial time, but no polynomial algorithm exist to solve the problem
P: polynomial algorithm exist to find a proof
NP-Complete: R ϵ NP-Complete if all NP problems can be polynomial tranformed to R and R ϵ NP
NP-Hard: R ϵ NP-Hard if all NP problems are polynomial transformable to R

9. Uni-processor systems
Problem definition syntax
α | β | γ
α: machine environment (number of processors)
β: job characteristics (preemption, constraints...)
γ: optimality criterion (max lateness... etc.)

10. Independent tasks 1. Preemption vs Nonpreemption
First thing to consider: use of preemption
Problem: 1 | nopmtn | Lmax
Single machine – no preemption – minimize maximum lateness
Jackson’s Rule: Any sequence is optimal that puts the jobs in order of nondecreasing due dates
EDF algorithm: Earliest Deadline First (ϵ P)
EDD optimal is some other cases too
Proof: interchange argument (not presented)

11. Independent tasks 2. Release times
Release time: a task has release time ri if its execution cannot start before time ri
1 | nopmtn, rj | Lmax ϵ NP
1 | pmtn, rj | Lmax ϵ P
Jackson’s Rule Modified: Any sequence that any instant schedules the job with the earliest due date among all the eligible jobs is optimal with respect to Lmax

12. Independent tasks 3. EDF and LLF
Proof of Jackson’s rule is the interchange argument (not discussed in the paper)
Usually allowing preemption decreases complexity
EDF and LLF algorithms are optimal in these cases
LLF = Least Laxity First (laxity = „slack time”)
Laxity = d-t-c t c
Slack time d

13. Independent tasks 4. Rate monotonic approach
Rate-monotonic approach (Liu and Layland)
Shorter period – higher priority
A set of n independent periodic jobs can be scheduled by the rate monotonic policy if
pi: worst case execution time; Ti: period
69% utilization can always be achieved
Both rate-monotonic and EDF are broadly used

14. Precendence constraints 1.
Tasks are not independent anymore
i → j means that task i must precede task j
G(V,E) precedence graph can be constructed
1 | prec, nopmtn | Lmax
Lawler algorithm solves it in: O(n2) (ϵ P)
But task start times must be identical

15. Precendence constraints 2.
If we introduce release times, the problem becomes exponential
(1 | prec, nopmtn, ri | Lmax) ϵ NP
The general case cannot be solved
BUT: Polynomial algorithm exists when the precedence graph is a series-parallel graph

16. Precendence constraints 3. Series-parallel graphs 1.
Graphs that can be construted from an empty graph with two operators:
Or if their transitive closure does not contain a Z-graph

17. Precendence constraints 4. Series-parallel graphs 2.
Series-parallel graphs only contain intrees OR outrees, but not both of them
The precedence problem than can than be solved with Lawler’s algorithm in
O(|N| + |A|) ϵ P
|N| - number of nodes; |A| - number of edges

18. Precendence constraints 5.
Bad news: Z-graphs almost always occur in RT systems
For example: an asyncronous send followed by a syncronous receive
Preemption again can reduce the complexity of the scheduling problem
(1 | prec, pmtn, ri | Lmax) ϵ O(n2)
Baker’s algorithm (not discussed)

19. Precedence constraints 6.
Another idea is to encode the precedences into the deadlines, and use EDF
Blazewicz: EDF is optimal for this case if we revise the deadlines and release dates of tasks according to these formulas:
starting from tasks having no successor step by step
starting from tasks having no predecessor step by step

20. Precedence constraints 7.
Still no shared resources are taken into account
The general problem of scheduling tasks with precedence constraints and resource conflicts is still NP-hard
Solutions usually use heuristic and branch-and-bound methods
Branch and bound (BB) is a general algorithm for finding optimal solutions of various optimization problems, especially in discrete and combinatorial optimization. It consists of a systematic enumeration of all candidate solutions, where large subsets of fruitless candidates are discarded en masse, by using upper and lower estimated bounds of the quantity being optimized.

21. Shared resources 1. Problem is solved with mutual exclusion primitives
Several additional problems arise:
Mok:
When there are mutual exclusion constraints, it is impossible to find a totally on-line optimal run-time scheduler
It is even worse: The problem of deciding whether it is possible to schedule a set of periodic processes which use semaphores (only to enforce mutual exclusion) is NP-hard

22. Shared resources 2.
Even deciding whether a solution exists, is NP-hard
Proof: polynomial tranformation to the 3-partition problem (a.k.a. Karp-reduction)
3 partition problem ϵ NP
A given multiset of integers
Divide it into three equal-sum groups

23. 1 | nopmtn, prec, rj, pj=1 | Cmax
Shared resources 3.
Mok also points out: the reason for the NP-hardness is the different possible computation times of the mutually exclusive blocks
Confirmation:
1 | nopmtn, rj, pj=1 | Lmax
and
1 | nopmtn, prec, rj, pj=1 | Cmax
ϵ P

24. Shared resources 4.
Somehow the algorithm should force using same length critical sections
Sha and Baker found efficient suboptimal solutions guaranteeing minimum level of performance
Kernelized monitor: Use longer time quantum on the processor, than the longest critical section:

25. Shared resources 5.
Mok: If a feasible schedule exists for an instance of the process model with precedence constraints and critical sections, then the kernelized monitor scheduler can be used to produce a feasible schedule

26. Shared resources 6.
Rate-monotonic approach – Priority Ceiling Procotol (PCP)
We assign priority to the mutex object
We prevent accessing all the mutexes based on this priority
Proved to be deadlock-free
Prevents unbounded priority inversion (a job can block only once)
Chen and Lin extended PCP to work with EDF

27. Shared resources 7. Stack Resource Policy (SRP)
A more general solution by Baker
A job should not be permitted to start
until the resources currently available are sufficient to meet its maximum requirements
until the resources currently available are sufficient to meet the maximum requirements of any single job that might preempt it
The first property prevents deadlocks, the second prevents multiple priority inversion

28. Shared resources - summary
It is very important to deal with the problem of shared resources
The classical results are usually applicable to RT systems, but only in uniprocessor systems

29. Overload and value 1.
If transient large overload occur, we still want a suboptimal schedule
Some tasks should meet their deadlines between all conditions
We associate values with tasks, so that we can define our preferences

30. Overload and value 2.
EDF (and LLF) algorithms perform very poorly in overloaded conditions
EDF gives the highest priority to tasks with the closest deadline, so the „Domino effect” may occur
For example: all tasks miss their deadline, while a suboptimal solution could have been found

31. Overload and value 3.
We use different metrics, however Lmax=0 could express that every task should meet its deadline
Task sets with values: wi
Smith’s rule: finding an optimal schedule for:
is given by any sequence that puts jobs in order of non-decreasing ratios:

32. Overload and value 4. This solution does not work in general
All of these problems are in NP
1 | prec | ΣwjCj 1 | dj | ΣwjCj
1 | prec | Σcj 1 | prec, pj=1| ΣwjCj
These are solved by a polynomial algorithm:
1 | chain | ΣCj 1 | series-parallel | ΣCj
1 | dj | ΣCj

33. Overload and value 5.
Baruah: there is an upper bound on the performance of any on-line, preemptive algorithm working between overloaded conditions
Competitve factor: ratio of the cumulative values accomplished by the algorithm and the clairvoyant scheduler
No on-line scheduling algorithm exists with a competitive factor greater than 0.25

34. Overload and value 6.
Ratio to the clairvoyant
scheduler 1
0.385
0.25
Load 1 2
This is the achiveable competitive factor as the function of the load size

35. Summary of uni-processor results
Huge amount of theoretical results,
Many used algorithms are based on the EDF or the rate-monotonic scheduling
Operating in overload and fault-tolerant scheduling are the fields where additional research is necessary

36. Multi-processor RT scheduling
Far less results are presented in this field
Almost all of the problems are NP-hard
The most important goal is to develop clever heuristics
There are serious anomalies that should be avoided
Processors are considered to be identical

37. Deterministic (static) scheduling 1. Non-preemptive
Multiprocessor scheduling results usually consider tasks with constant execution time
Theorems for non-preemptive, partially ordered tasks with resource constraints and one single(!) deadline cases show that they are almost always NP-hard
The following theorems consider arbitrary partial, forest partial ordered and independent tasks
Forest partial order: in terms of the precedence graph

38. Deterministic (static) scheduling 2. Non-preemptive
Processors
Resources
Ordering
Computational time
Complexity
Theorem 2
Arbitrary
Unit P
Coffmann and Graham
Independent NP
Garey and Johnson
1 or 2 Units 1
Forest 3 N Hu
Ulmann

39. Deterministic (static) scheduling 3. Non-preemptive
These cases are far less complex than a usual embedded system scheduling problem
No unit tasks
More shared resources
Tasks with different deadlines (!)
Heuristical algorithms must be used

40. Deterministic (static) scheduling 4. Preemptive
Introducing preemption usually makes the problem easier, but:
P | pmtn | ΣwjCj
McNaughton: For any instance of the multiproc. Scheduling problem, there exists a schedule with no preemption for which the value of the sum of computation times is as small as for any schedule with a finite number of preemptions
There is no advantage of preemption in this case
We should rather minimize overhead (such as context switches) and not use preemption

41. Deterministic (static) scheduling 5. Preemptive
Lawler: The multiprocessing problem of scheduling P processors, with task preemption allowed and where we try to minimize the number of late tasks is NP-hard.
(P | pmtn | ΣUj) ϵ NP
Uj – late tasks
Solution always requires heuristics!

42. Dynamic scheduling 1.
There are very few theoretical results in this field
Consider the EDF algorithm (which is optimal in the uni-processor case):
Mok: Earlies deadline first scheduling is not optimal in the multiprocessor case
Example

43. Example of EDF in multiprocess case
Ti(Ci, di): T1(1,1), T2(1,2), T3(3,3.5) P1 T1 T3
EDF P2 T2 t 1 2 3
3.5 4 P1 T1 T2
optimal P2 T3 t 1 2 3
3.5 4

44. Dynamic scheduling 2.
Mok: For two or more processors, no deadline scheduling algorithm can be optimal without complete a priori knowledge of
deadlines
computation times
start times of tasks
This implies, that none of the classical scheduling algorithms can be optimal when used online

45. Dynamic scheduling 3. Possibilities
Analyse the worst case scenario. If a scheduling exists, than every run-time situation can be schedules
Use well-developed heuristics – this can really increase computational requirements (sometimes additional hardware required)
Baruah: No on-line scheduling algorithm can guarantee a cumulative value greater than one-half for the dual-processor case

46. Multiprocessing anomalies 1.
Richard’s anomalies
Optimal schedule , fixed number of processors, fixed execution times, precedence constaints
Graham: For the stated problem, changing the priority list, increasing the number of processors, reducing execution times, or weakening the precedence constraints can increase the schedule length.

47. Multiprocessing anomalies 2.
Weakening the constaints can ruin the schedule
Example: P1 P2
↓ We decrease the C1 P1 P2
Static allocation:
P1: T1; T2
P2: T3; T4; T5

48. Multiprocessing anomalies 3.
Richard’s anomalies are the proof of that it is not always sufficient to schedule the worst-case
We can overcome these anomalies by having tasks simply idle if they finish earlier than their allocated computation time
This can be really inefficient
However their are solution for this [Shen]

49. Similarity to bin-packing
Bin-packing problem is a famous algorithmic problem
There are N bins, each have a capacity
There are boxes, and we have to put them into those bins
Two variations:
What is the minimum number of required bins (same size)
Fixed number of bins given, minimize the maximum bin length

50. Bin-packing implications
Several algorithms can be used, such as: first-fit (FF), best-fit (BF), first-fit decreasing (FFD), best-fit decreasing (BFD)
Theroetical boundaries exists:
For FF and BF worst case: (17/10) L* (L* = optimal)
FFD >= BFD boundary: (11/9) L* (L* = optimal)
In RT systems, we have much more constraints than the ones this analogie takes into account, but the implications might still be useful in off-line analysis

51. Summary
Uniprocessor RT scheduling can use the vast amount of theoretical knowledge from the classical theory
We do not know too much from multi-processor scheduling, and most of the problems are NP-hard
We need to develop clever heuristics, and do additional research in these fields

52. Thank you for you attention!