rtos by mohit
TRANSCRIPT
Real-Time Operating Systems
What does real time mean? What is an OS? Why would I need an OS? Why would I need a real time OS? How do we use an OS on embedded
systems?
By Mohit Kumar
A human operator must regulate the temperature of a system A human operator must regulate the temperature of a system with a +/- 5 degrees Fwith a +/- 5 degrees F
The temperature adjusts the current intensity to regulate the temperature.
The oven has a huge inertia: its temperature varies by at most 2 degrees per hour
The union imposes 2 coffee breaks a day The coffee break was negotiated to last one hour!
Consider the following case:
Consider a system that can achieve 10 Mflops We want to use this machine for 24-hour weather
prediction. The atmosphere is respectively divided in longitude
and latitude in areas of 200 miles X 200 miles. Measures are made at different altitudes
It takes 100 billion floating operations to solve the Navier-Stockes equations.
A piece of software It provides tools to manage (for embedded systems)
Processes, (or tasks) Memory space
It is a program (software) that acts as an intermediary between a user of a computer and the computer hardware.
Make the use of a computer CONVENIENT and EFFICIENT.
What is an OS?
What Is an Operating System?For an Embedded System
Provides software tools for a convenient and prioritized control of tasks.
Provides tools for task (process) synchronization.
Provides a simple memory management system
Convenient and Efficient?(General Purpose)
Convenient : Simplicity of use Messy or complicated details are
hidden User is unaware that he is using an
OS Efficient
Resources are optimally used
Layered View of a Computer System
A computer system consists of hardware system programs application programs
Operating System Definitions(General Purpose)
Resource allocator – manages and allocates resources Control program – controls the execution of user programs
and operations of I/O devices Kernel – the one program running at all times (all else being
application programs)
Dual-Mode Operation
Sharing system resources requires operating system to ensure that an incorrect program or poorly behaving human cannot cause other programs to execute incorrectly
OS must provide hardware support to differentiate between at least two modes of operations1. User mode – execution done on behalf of a user2. Monitor mode (also kernel mode or system
mode) – execution done on behalf of operating system
Mode bit added to computer hardware to indicate the current mode: monitor (0) or user (1)
When an interrupt or fault occurs hardware switches to monitor mode
kernel user
set user mode
Privileged instructions can be issued only in kernel mode
Interrupt/fault
Process/Task Concept
An operating system executes a variety of programs: Batch system – jobs Time-shared systems – user programs or tasks
Similar terms job, process, task (ES) almost interchangeably Process – a program in execution; process execution must
progress in sequential fashion A process includes:
program counter stack data section
Example of ProcessesThe Process Model
Multiprogramming of four programs Conceptual model of 4 independent, sequential
processes Only one program active at any instant
Key Difference on Embedded SystemsKey Difference on
Embedded Systems General Purpose OS: processes may be initiated by:
Different users Different application
Embedded system: tasks are part of a unique application
Process/Task State Bottom line: keep track of which
process/task runs (has the CPU) As a process executes, it changes state
(in some states, process/task does need CPU) new: The process is being created running: Instructions are being executed waiting: The process is waiting for some
event to occur ready: The process is waiting to be
assigned to a process terminated: The process has finished
execution
Process Control Block (PCB)Information associated with each
process Process state Program counter CPU registers CPU scheduling information Memory-management information Accounting information I/O status information
CPU Scheduler
What? This is a prime OS function that decides which process/task will run
Why? The application is made of multiple processes/tasks with possibly different time constraints. CPU scheduler implements this prioritization
How? On embedded systems, priorities assigned by the programmer are the main criteria
Scheduler
Non preemptive (kernel): the process/task relinquishes VOLUNTARILY the CPU.
Preemptive (kernel): OS preempts the CPU from a task and takes control of the CPU after a scheduled event or an interrupt .
Example:(http://www.netrino.com/Publications/Glossary/
RMA.html) P1 = 50ms, C1= 25ms (CPU uti. = 50%) P2 = 100ms, C2= 40ms (CPU uti. = 40%)
Looks like total CPU utilization is less than 100%: can these tasks be scheduled real time? (not missing their deadlines, next cycle start)
How to schedule these and not miss deadlines?
Example (cont’d):(http://www.netrino.com/Publications/Glossary/RMA
.html) Case 1: Priority(Task1) > Priority(Task2) Case 2: Priority(Task2) > Priority(Task1) P1 = 50ms, C1= 25ms (CPU uti. = 50%) P2 = 100ms, C2= 40ms (CPU uti. = 40%)
Question:
If I assign priorities such that most frequent tasks get highest priorities, does my scheduling GUARANTEE meeting the deadlines?
• Given– m periodic events
– event i occurs within period Pi and requires at most Ci seconds
– Tasks are independent (do not have to synchronize)
– Tasks are prioritized based on highest rate. Highest priority goes first
– Preemptive scheduling is used
• Then the load can only be handled if and only if
1
m(2(1/m) -1)m
i
i i
CP
Answer: Rate Monotonic Scheduling (RMS)
RMS: Example
Let a system with 3 tasks T1, T2, and T3:
T1 requires 3 ms every 10ms T2 requires 5 ms every 15 ms T3 requires 1 ms every 5 ms
Can these tasks be scheduled in real time? (Deadline is next time cycle)
Reentrant Function
A function F is reentrant if it can be invoked by multiple processes/tasks that can execute F CORRECTLY and concurrently.
In other words, F is correctly used by multiple processes/tasks at the same time.
Reentrant Function (2)
In general, if a function modifies only local variables (usually stored on stack), it is reentrant.
Example: non reentrant functionint temp; /* global variable */
void swap(int *x, int *y){
temp = *x;
*x = *y;
*y = temp;
}
Dealing With Non Reentrant F.
Modify functions to make them reentrant
If not possible, treat them as critical regions (sections) and enforce mutual exclusion
Enforcing Mutual Exclusion
Disable/Enable interrupts: OS_ENTER_CRITICAL() OS_EXIT_CRITICAL()
Using Test-and-Set function Disable/Enable scheduling:
OSSchedLock() OSSchedUnlock()
Using semaphores
Hardware Support (1)
Implementation of Test-And-Set Instruction Test-and Set must be an atomic operation
(either completely executed or not executed at all)
Boolean Test-and-Set(int *lock){int register;register = *lock;lock = 1;return(register = = 0);
}
Test-and-Set atomically:• Sets lock to 1• Tests whether the lock was open (0)
while (1){
} /* end while (1) */
While (!Test-And-Set(&Lock));
Lock = 0;
Critical Region
Remainder
Mutual Exclusion Using Test-And-Set
System variables: Lock = 0;
Mutual Exclusion ? Yes
Progress ? Yes
while (1){
} /* end while (1) */
Remainder
Lock = 0;
Critical Region
While (!Test-And-Set(&Lock));
Bounded Waiting ? Yes
Semaphore (Cont’d)
Down function: (Wait) if (S <= 0)
sleep(); S = S – 1;
Up function: (Signal) S = S + 1;
wake up some process
Mutexes are binary semaphores
while (1){
} /* end while (1) */
OSSemPend(SharedDataSem,0,&err);
OSSemPost(SharedDataSem);
Critical Region
Remainder
Mutual Exclusion Using Semaphores C
System variables: Lock = 0;
Mutual Exclusion ? Yes
Progress ? Yes
while (1){
} /* end while (1) */
Remainder
Critical Region
Bounded Waiting ? Yes
OSSemPend(SharedDataSem,0,&err);
OSSemPost(SharedDataSem);
Semaphores for Scheduling
Consider a task that waits for some event that can be generated by another task or some interrupt. Solution 1: use a flag variable
Solution 2: use a semaphore
Process/Task Communication
Necessary and useful for multi-tasking systems and/or in a distributed system
Design and implementation issues : How to establish links among processes ? Link’s connectivity : how processes are linked ?
How many of them should be linked Link’s capability: how many messages can be
passed ?
Link’s Connectivity
Direct : each process that wants to send or receive a message must explicitely name the recipient or sender or sender of the communication
Send(P,message) Receive(Q,message)
Example of Producer/Consumer Problem
Process ProducerRepeat …….. Produce an item in nextp; …….. Send(consumer,nextp);Until false
Process ConsumerRepeat receive(producer,nextp); …… consume the item in nextp ……..Until false
Link’s Connectivity
Indirect : messages are sent to and received from
mailboxes (ports). Each mailbox has a unique id. Two processes may communicate only if
they have a shared mailbox. A mailbox may be owned by a process or by
the system
Semantics of send
Normal situation The sending process continues (its execution)
Asynchronous communication The sending process suspends until an
acknowledgement comes back : Remote procedure call Synchronous communication
Semantics of send
Abnormal situations What happens if a link (say, a mailbox) is full
when the process want to send a message Delay the process until mailbox has room The sending process continues as if the
message has been sent (the current message is lost)
The sending process continues while the current message replaces one of the old messages in the mailbox
The sending process terminates (run-time error!)
Semantics of send
Abnormal situations (2) What happens if the receiver/mailbox does not
exist when a process sends a message to it ? The sending process continues as the message
has been sent. The current message is lost The sending process terminates (run-time
error!)
What happens if a message is lost by the system?
Semantics of receive
Abnormal situations What happens if a link (say, a mailbox) is empty
when a process wants to receive a message from it ?
The receiving process is delayed until the mailbox has some message
The receiving process receives a nil message The receiving process receives a copy of an old
message which was in the mailbox The receiving process terminates (run-time
error!)
Semantics of receive
Abnormal situations (2) What happens if the sender/mailbox does not exist
when a process wants to receive a message from it ?
The receiving process receives a nil message The receiving process terminates (run-time
error!)