Real Time Operating Systems
Definition: An RTOS is an OS for response time-controlled and event-controlled
processes. The processes have predictable latencies. An RTOS is an OS for the systems
having the real timing constraints and deadlines on the task, ISTs and ISRs.
(Or)
“The ability of the operating system to provide a required level of service in a bounded
response time.”
It responds to inputs immediately(Real-Time).
Here the task is completed within a specified time delay.
In real life situations like controlling traffic signal or a nuclear reactor or an aircraft.
The operating system has to respond quickly.
Round-Robin with Priority Algorithms
The round-Robin algorithm can be slightly modified by assigning priority levels to some or
all the tasks.
The high priority task can interrupt the CPU and execute the task.
This algorithm can meet the desired response for high priority task.
Example: Bar Code Scanner.
Shortest Job First Algorithms
The task that will take minimum time to be executed will be given priority.
This approach fulfills the maximum number of tasks, however, some tasks may have to
wait forever.
Real Time Operating Systems
Those systems in which the correctness of the system depends not only on the logical
result of computation, but also on the time at which the results are produced.
Arealtimesystemisasystem/thatensurestheexacttime
requirementsforajob.
Real Time Operating Systems
Real Time Operating Systems
Soft Real Time Systems
In a soft real-time system, tasks are completed as fast as possible without having to
be completed within a specified timeframe.
In a soft real-time system, it is considered undesirable, but not catastrophic, if deadlines
are occasionally missed.
Also known as “best effort” systems.
Most modern operating systems can serve as the base for a soft real time systems.
One in which deadlines are mostly met.
Soft real time means that only the precedence and sequence for the task operations are
defined, interrupt latencies and context switching latencies are small but there can be
few deviations between expected latencies of the tasks and observed time constraints and
a few deadline misses are accepted.
Soft Real Time Systems
Examples: Multimedia transmission and reception, – Networking, Telecom (cellular)
networks, web sites and services, and computer games.
Soft Real Time Tasks:
The preemption period for the soft real time task in worst case may be about a few ms.
Mobile phone, digital cameras and orchestra playing robots are examples of soft real
time systems.
Hard Real Time Systems
In a hard real-time operating system however, not only must tasks be completed
within the specified timeframe, but they must also be completed correctly.
A hard real-time system has time-critical deadlines that must be met; otherwise a
catastrophic system failure can occur.
Requires formal verification/guarantees of being to always meet its hard deadlines
(except for fatal errors).
Hard real time means strict about adherence to each task deadline.
When an event occurs, it should be serviced within the predictable time at all times
in a given hard real time system.
The preemption period for the hard real time task in worst case should be less than a
Few micro seconds.
Hard Real Time Systems
A hard RT RTOS is one, which has predictable performance with no deadline miss,
even in case of sporadic tasks (sudden bursts of occurrence of events requiring
attention).
Examples: Air traffic control, vehicle subsystems control, Nuclear power plant
control, Automobile engine control system and antilock brake.
Characteristics of RTOS
Basic Functions of RTOS
Task management
Task synchronization
Avoid priority inversion
Task scheduling
Interrupt handling
Memory management
No virtual memory for hard RT tasks
Exception handling (important)
Task
A task (also called a thread) is a program on a computer which can be executed and run.
A task is an independent thread of execution that can compete with other concurrent tasks
for processor execution time.
A task is schedulable.
The design process for a real-time application involves splitting the work to be done into
tasks which are responsible for a portion of the problem.
Each task is assigned a priority, its own set of CPU registers, and its own stack area.
Task States
DORMANT
READY
RUNNING
DELAYED
PENDING
BLOCKED
INTERRUPTED
Task States
Task States
DORMANT-The DORMANT state corresponds to a task that resides in memory but has not
been made available to the multitasking kernel.
READY-A task is READY when it can be executed but its priority is less than that of the
task currently being run.
In this state, the task actively competes with all other ready tasks for the processor’s
execution time.
The kernel’s scheduler uses the priority of each task to determine which task to move to the
running state.
Task States
RUNNING-A task is RUNNING when it has control of the CPU and it's currently being
executed.
On a single-processor system, only one task can run at a time.
•When a task is preempted by a higher priority task, it moves to the ready state.
•It also can move to the blocked state.
–Making a call that requests an unavailable resource
–Making a call that requests to wait for an event to occur
–Making a call to delay the task for some duration
Task States
WAITING-A task is WAITING when it requires the occurrence of an event (waiting for
an I/O operation to complete, a shared resource to be available, a timing pulse to occur,
time to expire, etc.).
BLOCKEDCPU starvation occurs when higher priority tasks use all of the CPU
execution time and lower priority tasks do not get to run.
The cases when blocking conditions are met.
A semaphore token for which a task is waiting is released.
A message, on which the task is waiting, arrives in a message queue.
A time delay imposed on the task expires.
ISR(Interrupt Service Routine)-A task is in ISR state when an interrupt has occurred and
the CPU is in the process of servicing the interrupt.
Task States
Scheduling
Scheduling Cont…
Task Scheduling
Schedulers are parts of the kernel responsible for determining which task runs next
Most real-time kernels use priority-based scheduling
• Each task is assigned a priority based on its importance
• The priority is application-specific
The scheduling can be handled automatically.
Many kernels also provide a set of API calls that allows developers to control the state changes.
Manual scheduling
Non Real -time systems usually use Non-preemptive Scheduling
• Once a task starts executing, it completes its full execution
Most RTOS perform priority-based preemptive task scheduling.
Basic rules for priority based preemptive task scheduling
• The Highest Priority Task that is Ready to Run, will be the Task that Must be Running.
Why Scheduling is necessary for RTOS?
More information about the tasks are known
• Number of tasks.
• Resource Requirements.
• Execution time.
• Deadlines.
Being a more deterministic system better scheduling algorithms can be devised.
Scheduling Algorithms
Depending upon the requirement of ES, the scheduling algorithm needs to be choosen.
• First-In First-Out
• Round-Robin Algorithm
• Round Robin With Priority
• Shortest Job First
• Non-Preemptive Multi-tasking
• Preemptive Multi-tasking
First-In First-Out
Task-1 Task-2 Task-3 Scheduler
Queue
• The task which ready to run are kept in a queue and CPU serves the task on first come first serve
basis.
Round-Robin Algorithm
Task-1 Task-2 Task-3 Task-1 Task-2 Task-3
Time
• The kernel assign a certain amount of time for each task waiting in the Queue.
• The time slice allocated to each task is called Quantum.
Non-Preemptive Multi-Tasking Algorithms
Low-priority task Interrupt Service High-priority task Low-priority task
running Routine running running
Time
ISR makes high priority task High priority task release the
Ready-to-run CPU
This is also called as cooperative multitasking as the tasks have to cooperate with one
another to share CPU time.
Low-priority task Interrupt Service High-priority task Low-priority task
running Routine running running
Time
ISR makes high priority task Low priority task release the
Ready-to-run CPU
Preemptive Multi-Tasking Algorithms
Low-priority task Interrupt Service High-priority task Low-priority task
running Routine running running
Time
ISR makes high priority task Low priority task release the
Ready-to-run CPU
The high priority tasks is always executed by the CPU, by preempting the lower priority
task.
All real time OS implement this scheduling algorithm.
Rate Monotonic Analysis
It is used to calculate the percentage of CPU time utilized by the tasks and to assign
priorities to tasks.
Priorities are proportional to the frequency of execution.
There are two types of priority assignments,
• Static priority assignment
• Dynamic priority assignment
Static priority assignment: A task will be assigned a priority at the time of creating the
task and it remains the same.
Dynamic priority assignment: the priority of the task can be changed during the
execution time.
It is not very easy to assign priorities to task, with the help of Rate Monotonic analysis
priorities of the tasks has been assign.
Task Management Function Calls
Create a Task
Delete a Task
Suspend a Task
Resume a Task
Change priority of a task
Query a Task.
Semaphores Cont…
Let us consider, two tasks wants to access a display. Display is a shared resource, in order
to control the access a semaphores is created.
If task 1 wants to access the printer, it acquires the semaphore, uses the printer and then
releases the semaphore.
If both tasks want to access a resource simultaneously, the kernel has to give the semaphore
only to one of the task.
This allocation may be based on the priority of the task or FIFO basis.
If a number of tasks have to access the same resource then the tasks are kept in a queue and
each task can acquire the semaphore one by one.
Resource Synchronization
When multiple tasks are running, two or more tasks may need to share the same resource.
In order to access a shared resource, there should be a mechanism so that there is
discipline.
That mechanism is known as Resource Synchronization.
Display Unit
Task 1 Task 2
Fig: Resource Synchronization
Task Synchronization
Let us consider, one task can reads the data from ADC and writes in to memory.
Another task read the data and sends it to DAC. However, the read operation takes place
only after write operation and it has to be done very fast with minimal time delay.
This is done through a well defined procedure called task synchronization.
Voltage
Signal A D
Task to write the Task to read the
D A
Data data
C C
Memory
Fig: Task Synchronization
Display Semaphores
Display Unit
Semaphore
1 3
4
2
Task 1 Task 2
1 2 3 4
Task 1 Task 2
Task 1 Uses Task 1 releases Task 2 Uses Task 2 releases
Acquires Acquires
Display Semaphore Display Semaphore
Semaphore Semaphore
Fig: Display Semaphore
Semaphores
Semaphores is just an integer.
There are two types
• Counting Semaphores
• Binary Semaphores
Counting Semaphores: counting semaphores will have an integer value greater than 1.
Binary Semaphores: Binary Semaphores will take the values either 0 or 1.
Semaphore is a kernel object that is used for both resource synchronization and task
synchronization.
Semaphores is like a key to enter the house.
Counting Semaphores
Pool of Buffers
Buffer 1 Buffer 10
Task 1 Task 2 Task n
Fig: Counting Semaphore
Semaphores Cont…
Let us consider, a pool of 10 buffers is available, the buffers need to be shared by a number
of tasks. Any task can write to a buffer.
Here, the counting semaphore is used. However, the initial value of the semaphore is set to
10.
Whenever a task acquires a semaphore, the value is decremented by 1 and whenever a task
releases a semaphore, the value is incremented by 1.
When the value is 0, it is indicated that the shared resource is no longer available.
A counting semaphore is like having multiple keys to enter a house.
Semaphores Management Function Calls
The OS API provides the following function calls for semaphore Management
• Create Semaphore
• Delete Semaphore
• Acquire Semaphore
• Release Semaphore
• Query a Semaphore
Semaphores can be used for several activities such as
• To control access to a shared resource.
• To indicate the occurrence of events.
• To synchronize the activities of task.
Deadlock
Deadlock occurs when two or more tasks wait for a resource being held by another task. If
the resource is not released for a long time due to some problem in that task then the
system may be reset by the watchdog timer.
To avoid deadlock , a time limit can be set.
Mailbox
It is a kernel object used for inter-task communication
It is just like a normal postal mailbox.
A task post a message in a mail box another task will read the message.
Mailbox Management Function calls
Create a mailbox
Delete a mailbox
Query a mailbox
Post a message in a mailbox
Read a message from a mailbox
Message Queues
Message Queues can be consider as an array of mailboxes.
It is a kernel object used in a inter-task communication. A task post the message in message
queue and another task will read the message.
Some of the applications of Message Queues are
• Taking the inputs from keyboard.
• To display output.
• Reading voltage from sensors or transducers.
• Data packet transmission in a network.
Message Queues cont…
In each of these applications, a task deposits the message in the message queue and other
task can take the messages.
Based on the application, the highest priority task or the first task waiting in the queue can
take the message.
At the time of creating queue, the queue is given a name or ID, queue length, sending task
waiting list and receiving task waiting list.
The applications of message queues are
1. One-way data communication.
2. Two-way data communication.
3. Broadcast data communication.
Message Queue Management Function calls
Create a queue
Delete a queue
Flush a queue
Post a message in a queue
Post a message in front of queue
Read message from queue
Broadcast a message
Show queue information
Show queue waiting list
Event Registers
A task can have an event register in which the bits correspond to different event.
Each bit in an event register can be used to obtain the status of an event.
A task can have an event register and other tasks can set/clear the bits in the event
register to inform the status of an event.
The meaning of 1 or 0 for a particular bit has to be decided beforehand.
Event Registers Management Function Calls
Create an event register.
Delete an event register.
Query an event register.
Set an event flag.
Clear an event flag.
Event Registers
0 1 0 0 1 0 1 1 0 0 1 0 0 1 0 0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Task#2 Task#5 Task#7 Task#4
Fig: 16-Bit Event Register
Pipes
Pipe is a kernel object. In pipes, the output of one task is passed on as input of other
task.
By using pipes tasks-to task or ISR to task data transfer can takes place.
Pipes can also used for inter-task communication also.
Task Task
Write Data Reads Data
To pipe From pipe
Fig: Pipe
Pipes
One task may send the data packets to one pipe and the other task may send the
acknowledgements through the other pipe.
In Unix/Linux, the pipe concepts are used.
Task 1 Task 2
Fig: pipes for Inter-task Communication
Pipe Management Function Calls
Create a pipe.
Open a pipe.
Close a pipe.
Read the pipe.
Write to the pipe.
Priority Inversion Problem
Priority Inheritance
