Introduction to Real-time theory

Unit 2• Introduction to Real-time

theory: Scheduling theory, Rate Monotonic Scheduling, Utilization bound theorem, RTOS, Task Management, Task management, Race condition, Priority inversion, ISRs and scheduling, Inter-Task communication, Timers.

Questions1. Define Real Time Operating System (RTOS). Explain, what are the characteristics of RTOS?

2. Differentiate between OS and RTOS?

3. Compare two Scheduling Strategies for the real time Scheduling preemptive mode and round robin scheduling?

4. Explain Priority Inversion?

5. Explain the different IPC mechanisms used in RTOS?

6. What are the characteristics of RTOS?

7. What is a Real Time Operating System (RTOS)? Give two examples of RTOS?

8. Differentiate between process, thread and task?

9. Compare scheduling strategies, real time scheduling, round robin mode and round robin scheduling?

10. Explain the use of semaphores for the critical sections of a task.

11. Explain the priority inversion problem.

12. Use of Control Blocks in RTOS?

Introduction to Realtime Theory

• Sometimes the deadlines are very small, i.e. the system must respond rapidly. But, there could be instances when the response can be slow, but deadlines are critical. So, based on these characteristics, a realtime system can be classified as :

1. Hard Realtime system

2. Soft Realtime System

3. Fast Realtime System

4. Slow Realtime System

Contd..

• In realtime software, we might have to ascertain that all the deadlines are met before deploying the software. In desktop software, usually ensuring correctness is sufficient, but not in the case of realtime systems. So, while developing realtime software, we should do ‘Performance Analysis’ during the design phase.

Scheduling Theory• Definition: The scheduling theory deals with Schedulability of

concurrent tasks with deadlines and priorities.

• Analysis:

1. Schedulability: The processing power of a given CPU is fixed. So, if various tasks are present in the system, in the worst case, can all tasks be scheduled in such a way that all the deadlines are met. This is called Schedulability.

2. Concurrent tasks: Because, if the tasks are sequential, (it is known as batch processing), there is no need for complex performance analysis. Since, in sequential processing, a task can begin only after all its predecessors have completed. So, scheduling theory here, deals with scheduling of concurrent tasks.

3. Priorities: Different tasks, though they run concurrently are differentiated based on their priorities.

Rate Monotonic Scheduling• This is one of the most popular and widely

used scheduling mechanisms. This method has also been implemented in Ada 9X (Ada is a programming language that has inbuilt support for tasks and scheduling of tasks).

• Monotonic sequences is a sequence of numbers that, are either arranged in an increasing or decreasing manner.

Definitions

• The rate monotonic scheduling is a way of scheduling in which increasing priorities are assigned to tasks in decreasing order of their periods i.e. the tasks are arranged in monotonic series of their periods e.g. if we have 4 tasks :

•

Tasks Period Priority

1 100 2

2 250 4

3 150 3

4 80 1

• Now the tasks are arranged in increasing order of their periods and priority is assigned.

80 100 150 250

Task#4 Task#1 Task#3 Task#2

1 2 3 4

• Here Task#4 has the highest priority and Task#2 has the lowest. Let us make some assumptions:

• Assumptions:

1. Let Ti be the period of the periodic task.

2. Let Ci be the time the processor would be required by the task.

3. Let Di be the deadline of the task. Initially, the Di is assumed to be equal to Ti (i.e. the task should complete before its period).

Now, let us define a useful term called the utilization ratio (Ui)

Ui = Ci / Ti

Ui is defined as the ratio of the Execution time of task i to its period Ti. Obviously the acceptablelimit of Ui is 1

Necessary Conditions• Individual utilization: The first necessary condition is if

a periodic task takes more time to complete than its own period it cannot be scheduled (even if it is the only task in the system). If this is the case, then the processing power of the processor can be increased to reduce Ci. Or, the algorithm can be improved or changed, or some part of the task can be moved to hardware

i: Ti : Ci Ti

Contd..

• Total Utilization: This rule states that the sum of all utilization ratios cannot exceed 1. This is because if Ui = 1, then it means that CPU is 100% time loaded. It cannot do any extra task. So, the sum of all utilization ratios must be less than or equal to 1.

(Ci / Ti) 1

Contd..

• Deadlines: Deadlines are points in time from the arrival of event to that a task needs to complete its work. But, now let us assume that the deadline of a task is equal to its period, i.e. a task can complete its work before its next period.

t=0 T

D

2T 3T 4Tt

Fig a : Period and Deadline

Contd..

• In the fig a , we see the events occurs periodically with period T. The deadline is the time within which the response must be given, and the task must be accomplished. The deadline and the period of a task are two independent entities. Let us assume that the Deadline = Period.

• Consider the set of following tasks :

Task# Period Ci Ui RMP Ui (cum)

1 50 10

2 100 20

3 200 30

Contd..

• Let us draw a diagram that depicts the state of the system when all the tasks are started at the some instant (t = 0).

Task 1

Task 2

Task 3

50 200150100

Time

Contd..

• Let us see how these 3 different tasks are scheduled in the system. Since RMS uses a strictly pre-emptive scheduling, only the task with highest priority is executed by the system at any time instant.

• We also assume the worst case situation that all the tasks are started simultaneously (at t = 0). Since the task #1, (with T=50) has the highest RMS priority, it is always executed whenever its period occurs.

• When task#1 finishes at T=10, task#2 begin its execution. Now, in a pre-emptive system, only the highest priority task will be executed. Let us see how these three different tasks are getting scheduled. RMS uses a strictly pre-emptive scheduling scheme. From the diagram we see that task#1, gets scheduled exactly at t=50, 100 etc. Task#1 takes a period of 10 from the CPU.

Contd..

• Though all the tasks are ready to execute at t=0, only the highest priority task is executed. After this completes, the task with next higher priority is executed( task#2) with T-100. This executes from time 10-30 in the timeline.

• Now, after task #2 completes, task#3 can execute. Task#3 requires a time of 30 units to finish its jobs. It starts at t=30 and should complete by 80 if it is uninterrupted. But at t=50, the highest priority task—task#1 gets ready to execute. So, task#3 gets pre-empted at t=50. This is called a scheduling point. Now, task#1 completes at t=60. Since task#2 is not ready to execute now, task#3 can continue. Task#3 completes by t=90. So, all the three tasks get scheduled.

Contd..

• Therefore, for any task, Task # j to complete its execution, all the higher priority tasks within the period Tj cannot take time more than Cj. Any task Tj takes Cj time to complete. So, the time it can spare to higher priority tasks is Tj-Cj.

Ci

0

P TCi Ti

Utilization Bound Theorem• Definition: Consider a set of n independent periodic

tasks. They are schedulable (Under the priority assignment of RMS) if

• Ci / Ti n(21/n - 1)

• Independent: Because for RMS, we assume that the tasks do not interact (neither synchronization nor communication) with each other

• Periodic: The tasks are periodic, i.e. they have a certain frequency. They are not event triggered.

• Schedulable: All the tasks can meet their deadlines.

Do the performance analysis on the given data(Assignment 2)

Deadline March 1, 2011• The data is:

• Ui is defined as the utilization ratio of the tasks to the available CPU time.

• Ui(cum) as the name indicates is the cumulative utilization of the tasks so far. For e.g. if two tasks is considered, the total utilization is 0.667. U i(cum) should not exceed the limit set by UB theorem. In this case, we see that by addition of the third task, U i(cum)

becomes greater than UB(i) . So, these three tasks are not schedulable according to UB theorem.

i Ti Ci Ui = Ci / Ti Ui (Cum) UB(i)

1 100 40

2 150 40

3 350 100

4 550 120

5 750 150

Realtime Operating Systems• Desktop OS vs. RTOS:

A desktop OS is usually huge in size. Normally desktop OS uses 300 – 1000 MB just for their installation. But, in embedded systems, even 8-16 MB of memory is sufficient to accommodate.

A desktop OS usually has huge libraries for UI management, support for numerous networking/interconnectivity protocols and fancy features like Plug ‘n’ Play. They also implements complex policies for network communication and facilities for binary reusability (DLLs, Shared Objectsetc.)

Contd..

An RTOS may not provide these features. But simply, every RTOS will provide at least the following features:

1. Task Creation/Management

2. Scheduling

3. Intertask Communication/Synchronization

4. Memory Management

5. Timers

6. Support for ISRs Many good RTOSes also provide support for protocols

like TCP/IP and some applications like telnet, tftp etc.

Operation of a desktop OS

Power-up

OS Initialisation

OS Ready

Load Program #1, #2…

Program #1 exits, #2 exits….#4 starts

Fig : Operation of a desktop OS

In a desktop programming environment, a programmer opens the editor and types in code. Then, he builds it using compilerand then executes his program. Note that OS is already running and it ‘loads’ the executable program. The program then makesUse of the OS services. The OS takes care of scheduling it. When the program completes it exits. The OS can run other Programs even while our program is running. But, this is notThe case in most of the embedded systems. Usually, there willBe no dedicated OS already running on the target to load our Program.

Operation in an RTOS Environment

Power-up

Decompression/Bootloading

Hardware Init

BSP/RTOS Initialisation

Application Code Begins

Fig : Operation in an RTOS Environment

In an embedded System, the software written by us, the RTOS (usually in the form of some library) and a special component called the BSP is bundled into a single executable file. This executable is burnt into a Boot-ROM or Flash.It is not necessary that a boot-ROM/Flash should always be present in the system. There could be cases where the code is obtained over a network on being powered up. This is because,usually embedded systems cannot afford the luxury of having hard disks. In the flowchart, the decompression step is optional.In the startup there is only a single executable that contains:- 1)OS Code 2) Board Support Package (BSP) 3) Application codeBSP is a part of OS code in the sense that it is used by the OS to talk to different hardware in the board. We should remember that the software that we write is run on the target board.

Need for BSP in Embedded Systems

• The OS needs to interact with the hardware on the board. For e.g. if we have a TCP/IP stack (provided by an OS vendor) integrated with our software, it should finally talk to the Ethernet controller on our board to finally put the data in the networking medium. The TCP/IP package has no clue about the Ethernet controller and the location of the Ethernet controller and ways to program it. Similarly, if there is a debug agent that runs as a component in the OS that may want to use the serial port, then we should provide the details and the driver for the UART controller used in our board. The BSP is highly specific to both the board and the RTOS for which the BSP is written.

Contd..• The BSP/Startup code will be the first to be executed at the

start of the system. The BSP code usually does the following:1. Initialisation of processor (BSP code initialises the mode of

operation of the processor. Then, it sets various parameters required by the processor)

2. Memory Initialisation 3. Clock setup4. Setting up of various components such as cache.

• The BSP gets bundled with the software that gets written and hence, any increase in BSP code size will lead to increase in the size of total software as we know that in embedded systems there is only a single executable that includes the code written by the programmer, the RTOS and the BSP code). So, the BSP must be written in a way such that it provides all the required abstractions.

Task Management in RTOS

• Task Management in an RTOS consists of the following:

1. Task creation

2. Task scheduling

3. Task deletion

TASKSTASKS: A task is the atomic unit of execution that can be scheduled by an RTOS to use the system resources.Analysis:

Atomic Unit: A task is considered as an atomic unit because, any other entity smaller than a task cannot compete for system resources.

Scheduled: In a system, there could be many tasks competing for system resources. But, the duty of the RTOS is to schedule tasks such that requirements of tasks are met in such a way that the system objectives are met.

System Resources: All tasks compete for resources like CPU, memory, input/output devices etc.

Contd..

• A task first needs to be created. A task is usually characterised by the following parameters:

1. A task name (“TxTask”)

2. Priority (100)

3. Stack Size (0x4000)

4. OS specific options

These parameters are used to create a task.

Contd..• A typical call might look like:

result = task_create ( “TxTask”, //Task name

100,

0x4000,

OS_PREEMPTABLE);

if (result == OS_SUCCESS) {

//task successfully created…

}

Now, the task can be considered to be in embryonic state (Dormant). It does not have the code to execute. But by now, a task control block (TCB) would have been allocated by the RTOS.

Concept of control blocks The use of control blocks is not limited to a task. The control

blocks are internal to RTOS. Programmer has no access to these blocks but to comprehend the working of an RTOS, we need to know how these control blocks are used by the RTOS:--

1. The RTOS usually reserves a portion of available memory for itself during startup. This chunk of memory is used to maintain structures such as the TCB.

2. The TCB will usually consist of the state of the task, i.e.the value of registers when the task was preempted earlier, its priority and its RTOS specific parameters (say scheduling policy).

3. When a task is blocked, the value of the registers is saved in its context in TCB. When a task is scheduled again, the system registers are restored with these saved values, so that the task will not know even it was pre-empted. An RTOS uses the TCB of a task to store all the relevant information regarding the task.

Task States• At any point of time, a task can be in one of

the following states:

1. Dormant : when the task is created, but not yet added to RTOS for scheduling.

2. Ready : The task is ready to run. But, cannot do so currently because, a higher priority task is being executed.

3. Running : The task is currently using the CPU

4. Blocked : The task is waiting for some resource/input.

Task State Transition

Dormant

Ready

Blocked

Running

Fig. Task State Transition Diagram

Contd..

The stages of a task and its transitions are:

1. When a task is created, it is in a ‘Dormant’ state.

2. When it is added to the RTOS for scheduling, it usually arrives in the ready state. But, if it is the highest priority task, it could begin executing right away.

3. When a task is running and if another higher priority task becomes ready, the task that is running is pre-empted and the highest priority task is scheduled for execution.

4. During the course of execution of a task, it may require a resource or input. In this case, if the resource/input is not immediately available, the task gets blocked.

Other Transitions• There are other transition stages in the execution of the tasks.

Some of them are as follows:

1. Ready to running: For a particular task, if all the higher priority tasks are blocked, then the task is scheduled for execution. It then changes its state from ready to running.

2. Blocked to ready: when a higher priority task releases a resource required by a lower priority task, then the lower priority task cannot begin execution. The higher priority task will continue to run. But, the state of the lower priority task will change from ‘blocked’ to ‘ready’.

3. Blocked to running: Sometimes, it could happen that a higher priority task is blocked on some resource/input. When that resource is available again, then the task begins execution, pre-empting the lower priority task that was executing.

Idle tasks

• There may be a situation when no task is ready to run and all r blocked.

• This puts rtos in trouble.so rtos usually executes a task cald idle task an idle task does nothing .it luks like:

• Void idletask(void)

• {while(1);}it has no sys calls in fact no code except infinite loop.it is lowest priority task.rtos reserve few lowest nd highest priority task eg:of there r 256 tasks it may reserve lowest and highst 10 leavng user with 226 task

• Cpu loading:

• Though an idle task does nothng we can use it to determine cpu loadng:the avg utilizatn ratio of cpu.this can be done by makng idle task writing sys clock in same mem locn.so an ide task need not be idle after all

Task Scheduling• Task Scheduling is one of the primary reasons

for choosing an RTOS. The programmer can assign priorities to various tasks and rest assured that the RTOS would do the needed scheduling. The most used scheduling policies available are :

1. Strictly Pre-emptive scheduling

2. Time Slicing

3. Fairness Scheduling

Strictly Pre-emptive scheduling

• This is one of the most widely used scheduling policies in an RTOS but this is not a preferred scheme in a desktop OS. In this policy, at any instance of time, only the highest priority task that is ready to run executes. If a task Ti runs, it means that all tasks Tj with priorities lesser than Ti are blocked.

• This scheduling policy makes sure that important tasks (i.e. higher priority) are handled first and the less important later. For e.g. in an aircraft cruise control system, the flight controller task will have more priority than a task that controls the air-conditioning system.

Contd..

• Pros: Once the priorities are set properly, we can rest assured that only the higher priorities tasks are handled first.

• Cons: It is possible that one or more of the lower priority tasks do not get to execute at all. So, to avoid this, a proper analysis should be done in the design phase.

There could be a slight deviation in the implementation of this scheduling algorithm. In almost all systems, ISRs will have highest priority irrespective of the priorities assigned to the tasks. This is usually necessary too. So, this deviation from the normal behavior is acceptable.

Time Slicing• In this, the CPU time is shared between all the tasks.

Each task gets a fraction of CPU time. There is no notion of priority here. This type of scheduling is also known as round robin scheduling. This scheduling is not used in its original form.

• However, this can be used in conjunction with pre-emptive scheduling. In a preemptive system, if two or more tasks have same priority, so in this case the scheduler can be made to use time slicing for those tasks with the same priority.

Contd..

• Pros:1. No need for complex analysis of system.

2. This kind of kernel is relatively easy to implement.

3. The pre-emption time of a task is deterministic i.e. if a task is pre-empted, we will know exactly the time after which the task will be scheduled( if the number of tasks in the system do not vary with time)

• Cons: This is a very rigid scheduling policy (and exactly that is what it is meant to be—there is no notion of priority)

Fairness Scheduling• In this type of scheduling, every task is given an

opportunity to execute. Unlike pre-emptive scheduling, in which a lower priority task may not get an opportunity to execute, in this case, every task will be given a ‘fair’ chance to execute. Though some kind of priority mechanism could be incorporated here, it is not strict. Priority of a task, which has not executed for some period will gradually be increased by the RTOS and will finally get a chance to execute.

Contd..

• Pros1. Every task will get an opportunity to execute.

2. This kind of scheduling is widely available in desktop OS (we still listen to music while compiling our programs).

• Cons(cn)1. This scheduling policy is complex (how to vary

priority of tasks in such a way as to achieve fairness).

2. Introduces nondeterminism into the system.

Task Synchronisation