This document contains information about real-time operating systems and scheduling algorithms. It discusses the architecture of real-time systems, including hard and soft real-time systems. It also covers common task categories and why scheduling is needed. The document then summarizes several important scheduling algorithms for real-time systems, including rate monotonic, deadline monotonic, earliest deadline first, least laxity first, and maximum urgency first. It provides examples and explanations of how each algorithm works.

1. Department of Information Technology
Session 2018-19
Eight Semester
Subject Incharge: Prof. Sarvesh Warjurkar
1
Department of Information Technology
Embedded Systems
UNIT –III

2. Syllabus
UNIT –III
• Architecture of the kernel, Tasks and Task Scheduler,
Threads , ISR, Multiprocessing and Multitasking,
Semaphore and Shared Data, Mutex, Mailboxes,
Message Queue, Events, Pipes, Timers, Signals,
Memory Management, RTOS Task Scheduling
Models, Interrupt Latency, Response of the task, OS
Security issues, Introduction to Android.
Department of Information Technology 2

3. Windows Architecture
hardware interfaces (buses, I/O devices, interrupts,
interval timers, DMA, memory cache control, etc., etc.)
System Service Dispatcher
Task Manager
Explorer
SvcHost.Exe
WinMgt.Exe
SpoolSv.Exe
Service
Control Mgr.
LSASS
Object
Mgr.
Windows
USER,
GDI
File
System
Cache
I/O Mgr
Environment
Subsystems
User
Application
Subsystem DLLs
System Processes Services Applications
System
Threads
User
Mode
Kernel
Mode
NTDLL.DLL
Device &
File Sys.
Drivers
WinLogon
Session Manager
Services.Exe POSIX
Windows DLLs
Plug
and
Play
Mgr.
Power
Mgr.
Security
Reference
Monitor
Virtual
Memory
Processes
&
Threads
Local
Procedure
Call
Graphics
Drivers
Kernel
Hardware Abstraction Layer (HAL)
(kernel mode callable interfaces)
Configura-
tion
Mgr
(registry)
OS/2
Windows
Copyright Microsoft Corporation

4. Kernel-mode Architecture of Windows
Copyright Microsoft Corporation
NT API stubs (wrap sysenter) -- system library (ntdll.dll)
user
mode
kernel
mode
NTOS executive layer
Trap/Exception/Interrupt Dispatch
CPU mgmt: scheduling, synchr, ISRs/DPCs/APCs
Drivers
Devices, Filters,
Volumes,
Networking,
Graphics
Hardware Abstraction Layer (HAL): BIOS/chipset details
firmware/
hardware CPU, MMU, APIC, BIOS/ACPI, memory, devices
NTOS
kernel
layer
Caching Mgr
Security
Procs/Threads
Virtual Memory
IPC
glue
I/O
Object Mgr
Registry
Copyright Microsoft Corporation

5. Real-Time System
• Real-time systems have been defined as: “those systems in
which the correctness of the system depends not only on the
logical result of the computation, but also on the time at
which the results are produced“
• Correct function at correct time
• Usually embedded
• Deadlines
– Hard real-time systems
– Soft real-time systems

6. Real-Time System continue
• Soft RTS: meet timing constraints most of the time, it is not
necessary that every time constraint be met. Some deadline
miss is tolerated.
• Hard RTS: meet all time constraints exactly, Every resource
management system must work in the correct order to meet
time constraints. No deadline miss is allowed.

7. Tasks Categories
• Invocation
– Periodic (time-triggered)
– Aperiodic (event-triggered)
• Creation
– Static
– Dynamic
• Multi-Tasking System
– Preemptive: higher-priority process taking control
of the processor from a lower-priority
– Non-Preemptive : Each task can control the CPU
for as long as it needs it.

8. Why we need scheduling ?!
• each computation (task) we want to execute needs resources
• resources: processor, memory segments, communication, I/O
devices etc.)
• the computation must be executed in particular order
(relative to each other and/or relative to time)
• the possible ordering is either completely or statistically a
priori known (described)
• scheduling: assignment of processor to computations;
• allocation: assignment of other resources to computations;

9. • Job (Jij): Unit of work, scheduled and executed by system. Jobs
repeated at regular or semi-regular intervals modeled as
periodic
• Task (Ti): Set of related jobs.
• Jobs scheduled and allocated resources based on a set of
scheduling algorithms and access control protocols.
• Scheduler: Module implementing scheduling algorithms
• Schedule: assignment of all jobs to available processors,
produced by scheduler.
• Valid schedule: All jobs meet their deadline
• Clock-driven scheduling vs Event(priority)-driven scheduling
• Fixed Priority vs Dynamic Priority assignment
Real-time Scheduling Taxonomy

10. Scheduling Periodic Tasks
 In hard real-time systems, set of tasks are known apriori
 Task Ti is a series of periodic Jobs Jij. Each task has the
following parameters
 ti - period, minimum interrelease interval between jobs in
Task Ti.
 ci - maximum execution time for jobs in task Ti.
 rij - release time of the jth Job in Task i (Jij in Ti).
 i - phase of Task Ti, equal to ri1.
 ui - utilization of Task Ti = ci / ti
 In addition the following parameters apply to a set of
tasks
 H - Hyperperiod = Least Common Multiple of pi for all i: H =
lcm(pi), for all i.
 U - Total utilization = Sum over all ui.

11. Real-Time Scheduling Algorithms
Fixed Priority Algorithms Dynamic Priority Algorithms Hybrid algorithms
Rate
Monotonic
scheduling
Deadline
Monotonic
scheduling
Earliest
Deadline
First
Least Laxity
First
Maximum
Urgency
First

12. Scheduling Algorithm
Static vs. Dynamic
 Static Scheduling:
All scheduling decisions at compile time.
 Temporal task structure fixed.
 Precedence and mutual exclusion satisfied by the
schedule (implicit synchronization).
 One solution is sufficient.
 Any solution is a sufficient schedulability test.
 Benefits
 Simplicity

13. Scheduling Algorithm
Static vs. Dynamic
• Dynamic Scheduling:
– All scheduling decisions at run time.
• Based upon set of ready tasks.
• Mutual exclusion and synchronization enforced by
explicit synchronization constructs.
– Benefits
• Flexibility.
• Only actually used resources are claimed.
– Disadvantages
• Guarantees difficult to support
• Computational resources required for scheduling

14. Scheduling Algorithm
Preemptive vs. Nonpreemptive
• Preemptive Scheduling:
– Event driven.
• Each event causes interruption of running tasks.
• Choice of running tasks reconsidered after each
interruption.
– Benefits:
• Can minimize response time to events.
– Disadvantages:
• Requires considerable computational resources for
scheduling

15. • Nonpreemptive Scheduling:
– Tasks remain active till completion
• Scheduling decisions only made after task completion.
– Benefits:
• Reasonable when
task execution times ~= task switching times.
• Less computational resources needed for scheduling
– Disadvantages:
• Can leads to starvation (not met the deadline)
especially for those real time tasks ( or high priority
tasks).
Scheduling Algorithm
Preemptive vs. Nonpreemptive

16. Rate Monotonic scheduling
• Priority assignment based on rates of tasks
• Higher rate task assigned higher priority
• Schedulable utilization = 0.693 (Liu and Leyland)
Where Ci is the computation time, and Ti is the release period
• If U < 0.693, schedulability is guaranteed
• Tasks may be schedulable even if U > 0.693

17. RM example
Period
Execution Time
Process
8
1
P1
5
2
P2
10
2
P3
The utilization will be:
The theoretical limit for processes, under which we can conclude that
the system is schedulable is:
Since the system is schedulable!

18. Deadline Monotonic scheduling
• Priority assignment based on relative deadlines of tasks
• Shorter the relative deadline, higher the priority

19. Earliest Deadline First (EDF)
• Dynamic Priority Scheduling
• Priorities are assigned according to deadlines:
– Earlier deadline, higher priority
– Later deadline, lower priority
• The first and the most effectively widely used dynamic
priority-driven scheduling algorithm.
• Effective for both preemptive and non-preemptive scheduling.

20. Two Periodic Tasks
• Execution profile of two periodic tasks
– Process A
• Arrives 0 20 40 …
• Execution Time 10 10 10 …
• End by 20 40 60 …
– Process B
• Arrives 0 50 100 …
• Execution Time 25 25 25 …
• End by 50 100 150 …
• Question: Is there enough time for the execution of two periodic
tasks?

22. Five Periodic Tasks
• Execution profile of five periodic tasks
Process Arrival Time
Execution
Time
Starting
Deadline
A 10 20 110
B 20 20 20
C 40 20 50
D 50 20 90
E 60 20 70

24. Least Laxity First (LLF)
• Dynamic preemptive scheduling with dynamic priorities
• Laxity : The difference between the time until a tasks
completion deadline and its remaining processing time
requirement.
• a laxity is assigned to each task in the system and minimum
laxity tasks are executed first.
• Larger overhead than EDF due to higher number of context
switches caused by laxity changes at run time
– Less studies than EDF due to this reason

25. Least Laxity First Cont
• LLF considers the execution time of a task, which EDF does
not.
• LLF assigns higher priority to a task with the least laxity.
• A task with zero laxity must be scheduled right away and
executed without preemption or it will fail to meet its
deadline.
• The negative laxity indicates that the task will miss the
deadline, no matter when it is picked up for execution.

26. Least Laxity First Example

27. Maximum Urgency First Algorithm
• This algorithm is a combination of fixed and dynamic priority
scheduling, also called mixed priority scheduling.
• With this algorithm, each task is given an urgency which is
defined as a combination of two fixed priorities (criticality and
user priority) and a dynamic priority that is inversely
proportional to the laxity.
• The MUF algorithm assigns priorities in two phases
• Phase One concerns the assignment of static priorities to
tasks
• Phase Two deals with the run-time behavior of the MUF
scheduler

28. The first phase consists of these steps :
1) It sorts the tasks from the shortest period to the longest
period. Then it defines the critical set as the first N tasks such
that the total CPU load factor does not exceed 100%. These
tasks are guaranteed not to fail even during a transient
overload.
2) All tasks in the critical set are assigned high criticality. The
remaining tasks are considered to have low criticality.
3) Every task in the system is assigned an optional unique user
priority
Maximum Urgency First Algorithm phase 1

29.  In the second phase, the MUF scheduler follows an algorithm
to select a task for execution.
 This algorithm is executed whenever a new task is arrived to
the ready queue.
 The algorithm is as follows:
1) If there is only one highly critical task, pick it up and execute it.
2) If there are more than one highly critical task, select the one
with the highest dynamic priority. Here, the task with the least
laxity is considered to be the one with the highest priority.
3) If there is more than one task with the same laxity, select the
one with the highest user priority.
Maximum Urgency First Algorithm phase 2

30. Questions ??

31. Referances
• http://en.wikipedia.org/wiki/RTOS#Scheduling
• http://en.wikipedia.org/wiki/Rate-
monotonic_scheduling
• http://www.netrino.com/Publications/Glossar
y/RMA.php

32. What is real-time?
• Correctness of output depends on timing as
well as result
• Hard vs. soft real-time
• Are Windows and Linux real-time?

33. In a Hard RTOS…
• Thread priorities can be set by the client
• Threads always run according to priority
• Kernel must be preemptible or bounded
• Interrupts must be bounded
• No virtual memory

34. In a Soft RTOS…
• Like a hard RTOS:
– Priority scheduling, with no degradation
– Low dispatch latency
– Preemptible system calls
– No virtual memory (or allow pages to be locked)
• Linux: guarantees about relative timing of
tasks, no guarantees about syscalls

35. Basic RTOS References
• http://www.dedicated-
systems.com/encyc/publications/faq/rtfaq.htm
• http://www.steroidmicros.com/mtkernel.html
• http://www.qnx.com/developer/articles/dec1200b/
• Silberschatz and Galvin, Operating System Concepts.

36. Example RTOS’s
• Micrium c-OS II
http://www.ucos-ii.com/
• AvrX
http://www.barello.net/avrx/
• RTLinux
http://fsmlabs.com/developers/man_pages
/
• QNX Neutrino
http://www.qnx.com/

37. c-OS II
• Features
• Sample main() function
• Calling OSTaskCreate()
• Creating a task

38. C-OS II
• Ports to the AVR, ATmega103
• Comes with book: Micro-C OS: The Real-Time
Kernel by Jean Labrosse ($52)
• Features
– Semaphores and mutexes
– Event flags
– Message mailboxes and queues
– Task management (priority settings)

39. void main (void) {
/* Perform Initializations */
...
OSInit();
...
/* Create at least one task by
calling OSTaskCreate() */
OSStart();
}
C-OS Sample Code

40. INT8U OSTaskCreate (
void (*task)(void *pd),
void *pdata,
OS_STK *ptos,
INT8U prio);
C-OS Sample Code

41. void UserTask (void *pdata) {
pdata = pdata;
/* User task initialization */
while (1) {
/* User code goes here */
/* You MUST invoke a service
provided by µC/OS-II to: */
/* ... a) Delay the task for ‘n’
ticks */
/* ... b) Wait on a semaphore */
/* ... c) Wait for a message from a
task or an ISR */
/* ... d) Suspend execution of this
C-OS Sample Code

42. AvrX
• Specs
• Internal structures
• Sample code: task creation

43. AvrX Specs
• Code size: 500-700 words (2x bigger with
debug monitor)
• 16 priority levels
• Overhead: 20% of CPU
• Version 2.3 for assembly code, 2.6 for C
interface

44. AvrX Internals
• Routine _Prolog saves state, _Epilog
restores it
• Task info stored in a PID block and a task
control block
• Modules for timers, semaphores, etc.

45. An AvrX Task
AVRX_TASKDEF(myTask, 10, 3){
TimerControlBlock MyTimer;
while (1)
{
AvrXDelay(&MyTimer, 10);
// 10ms delay
AvrXSetSemaphore(&Timeout)
;
}}
Arguments: task name, additional stack bytes, priority

46. RTLinux
• Additional layer between Linux kernel and
hardware
• Worst-case dispatch latency on x86: 15 s

47. RTLinux: Basic Idea

48. QNX Neutrino
• Powerful hard RTOS
• Includes GUI
• Memory protection and fault tolerance

49. Summary
• Hard real-time, soft real-time
• Characteristics of an RTOS
• Example RTOS’s
– Specs
– Internal structure/ideas
– Sample code