Embedded Systems OS Concepts

https://www.facebook.com/groups/embedded.system.KS/
Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Automotive Embedded
Systems part1
(RTOS) Basics
ENG.KEROLES SHENOUDA
1

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Real-Time Systems Concepts
it's time to wake up 
2

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Bare metal
 “Bare metal" means your application is
accessing the silicon chip directly
without any intermediary like an OS.
 The application is the only software that
executes on the
microprocessor/microcontroller.
 So we can considered that the Drivers is a
bare metal Code and the bios also.
3
Bare-Metal application
C - Code

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
OS Application
 Write your application on the top
of the Operating System.
 On desktop computers, the
selection of an operating system
(OS) is largely a matter of taste -
Windows vs Apple vs Linux. There
is relatively little choice.
 For an embedded system, the
matter is much more complex. The
large number of options available
reflect the wide diversity of
embedded applications.
4
OS
Application
OS
Drivers
• Linux Command
• Graphical GUI “ex.QT application”
• C/C++ app.
• RTOS Tasks
• Autosar SW Component
Embedded Linux
• Linux Kernel “Linux.org”
• Open embedded YOCTO
• Android
• Windows IOT
Embedded windows
RTOS
Autosar• Free RTOS
• μC/OS-III
• RTOS OS + BSW +RTE
Embedded Linux Drivers
RTOS Drivers
MCAl Layer

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
How to execute two function at the
same time on the baremetal
application?
#THINK IN DEPTH
5

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Answer
//pseudo code
Int main()
{
Switch (get_cpu_ID())
{
case core0: //if core0 who is execute the main now
FUNC1(); //funch1 will be called by core0
break;
case core1: //if core1 who is execute the main now
FUNC2(); //funch2 will be called by core1
break;
}
6
Bare Metal Application

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Hypervisors in embedded systems
7
Virtualization you can run operating
systems called guests, inside a sandbox
contained under the control of another
piece of software (the hypervisor) that
manages all interaction of the guest
toward hardware. The hypervisor runs at
a more privileged level of hardware
access than the operating system (OS)
kernel (supervisor) and user privilege of
the guest OS

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
8

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
What is an Operating System
9
 A software layer between the application software
and the hardware
 Typical embedded system (ES) solves a problem by
decomposing it into smaller pieces called tasks
that work together in an organized way
 System is called multitasking system and
design aspects include:
 Exchanging/sharing data between tasks
 Synchronizing tasks
 Scheduling tasks
 The piece of software that provides the required
coordination is called an operating system (OS)
 When the control must ensure that task execution
satisfies a set of specified time constraints, the
OS is called a real-time operating system (RTOS)

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
The Operating System (OS)
10
Also it provides a services:
–Process or task management
•Creation and deletion of user and system processes
–Memory management
•Includes tracking and control of which tasks are loaded into
memory, monitoring memory, administer dynamic mem
–I/O System management
•Interaction with devices done through a special piece of software
called a device driver
•The internal side of that software is called a common calling
interface (an application programmer's interface, API)
–File system management
–System protection
–Networking

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Memory Management
 In multiprogramming, OS decides which
process will get memory when and how much.
•Allocates the memory when the process
requests it to do so.
•De-allocates the memory when the process
no longer needs it or has been terminated.
 Sometimes if the CPU hardware “MMU”
provides mapping between virtual and physical
addresses, the OS “memory management” will
manage the Virtual memory for each task
11

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Processor Management
 OS decides which process gets the
processor when and how much time.
This function is called process
scheduling.
 Operating System does the following
activities for processor management.
•Keeps tracks of processor and status of
process. Program responsible for this task
is known as traffic controller.
•Allocates the processor (CPU) to a process.
•De-allocates processor when processor is
no longer required.
12

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Device Management (I/O System management )
 OS manages device communication via
their respective drivers. Operating
System does the following activities for
device management.
•Keeps tracks of all devices. Program
responsible for this task is known as the I/O
controller.
•Decides which process gets the device when
and for how much time.
•Allocates the device in the efficient way.
•De-allocates devices.
13

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
The Kernel
 The Kernel is the smallest portion of the OS that provides
these functions
• Scheduler
–Determines which task will run and when it will do so
•Dispatcher
–Performs the necessary operations to start the task
•Intertask or interprocess communication
–Mechanism for exchanging data and information between tasks and
processes on the same machines or different ones
14

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
What is Real Time?
 “not only depends upon the logical correctness of the
computation but also upon the time at which the result is
produced.
 If the timing constraints of the system are not met, system
failure is said
 A real time system is one in which the correctness of the
computations to have occurred.” at specific timeline
15
Real Time:
Correct logic
With a specific
Timeline

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Real Time System
 A system is said to be Real Time if it is required to complete
it’s work & deliver it’s services on time.
 Example – Flight Control System
 All tasks in that system must execute on time.
 Non Example – PC system
 There are types of Real Time System
 Soft real time
 Hard real time
16

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
There are types of Real Time
System
Soft real time
• Tasks are performed by the system as fast as
possible, but tasks don’t have to finish by
specific times
• Multitask based on Priority scheduling
• Ex. Multimedia streaming
25 frames per second on an average
 Hard real time
• Tasks have to be performed correctly
and on time
• Multitask based on Deadline scheduling
• Ex. Aircraft controller, Nuclear reactor
controller
17

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
The Real-Time Operating
System (RTOS)
 An RTOS provides an Abstraction Layer between
Application Software and Embedded Hardware
 Key characteristic of an RTOS is that it has
deterministic behavior
 Basic Services provided by a Real-Time Operating System
Kernel
 “Real-time” means keeping deadlines, not speed
 Advantages of RTOS in SoC design
• Shorter development time
• Less porting efforts
• Better reusability
18
Task0Task1

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
When is RTOS necessary?
An RTOS may not be necessary in a small-scaled
embedded system.
An RTOS is necessary when scheduling of multiple
processes and devices is important.
19

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Characteristics of an RTOS
 Reliability:
 Available and doesn’t fail.
 Predictability:
 Deterministic with small time variance.
 Performance:
 Fast enough.
 Compactness
 Small and efficient.
 Scalability
 Result of modularity and RTOS configurations to be used in many systems.
20

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Foreground/Background Systems
 An application consists of an infinite loop that calls modules (that is,
functions) to perform the desired operations (background).
 Interrupt Service Routines (ISRs) handle asynchronous
events (foreground).
So Foreground is also called interrupt level while background is called task level
21
Background
Foreground
ISR ISR
ISR
(more
important)
Interrupts may be
prioritised, so that an ISR
may itself be interrupted so
that a more important event
may be serviced.

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Handling an Interrupt
22
1. Normal
program
execution
2. Interrupt
occurs
3. Processor
state saved
4. Interrupt routine
runs
5. Interrupt routine
terminates
6. Processor state
restored
7. Normal
program
execution
resumes

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Handling an Interrupt
23

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Reentrancy
 A reentrant function is a function
that can be used by more than
one task without cause of data
corruption.
 A reentrant function can be
interrupted at any time and
resumed at a later time without
loss of data.
 An error caused by a non-
reentrant function may not show
up in your application during the
testing phase
24
 non-reentrant
int temp; // global
function swap(int *x,
int *y) {
temp = *x;
*x = *y;
*y = temp;
}
 reentrant version
function swap (int *x,
int *y) {
int temp; // local
temp = *x;
*x = *y;
*y = temp;
}

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Non-reentrant function
25

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Process or Task
 A task is usually implement in C by writing a function
 When a C function is executing, it is called a process or task
 So Task is not code
 Two tasks can be executing the same code simultaneously
 When a process is created, it is allocated a number f
resources by the OS, which may include:
 –Process stack
 –Memory address space
 –Registers (through the CPU)
 –A program counter (PC)
 –I/O ports, network connections, file descriptors, etc.
 These resources are generally not shared with other
processes
26
int x;
int Func() {
int y;
y = y + 1;
x = x + 1;
...
}
Task 1 Task 2

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Multitasking
 Multitasking is the process
of scheduling and switching
the CPU (Central Processing
Unit) between several tasks.
 Each task is
assigned a priority,
its own set of CPU
registers, and its
own stack area
27
Multiple tasks

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Context Switch (or Task Switch)
 When a multitasking kernel decides to
run a different task, it simply saves the
current task's context (CPU registers)
in the current task's context storage
area – it’s stack.
 Once this operation is performed, the
new task's context is restored from
its storage area and then resumes
execution of the new task's code.
 This process is called a context switch
or a task switch. Context switching adds
overhead to the application.
28

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Tasks conclusion
 Each task thinks it has the CPU to itself
 Each task has its own stack space and its own set of CPU
registers
 Each task has a priority
 A task may well take the form of
 a sequence of initialisation code; followed by
 a loop which iterates forever (or until a flag is set to exit it)
 Body of loop will contain application code
 A task calls functions which are preferably reentrant:
 Can be safely called by more than one function at a time
 Interrupting them does not corrupt their data
 Typically implemented using local variables
 Reusable and reentrant Code
29
Void task1()
{
// a sequence of
//initialisation code
While(1)
{
//application code
}
}

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Task States
30
1.DORMANT
2.READY
3.RUNNING
4.DELAYED
5.PENDING
6.BLOCKED
7.INTERRUPTED
A task can be in any
of one of states
Waiting
Dormant Ready Running ISR
Task Create
Task Delete
Highest Priority Task
Task is Preempted
Task Pending EventsTask Gets Event
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Task States
 DORMANT-The DORMANT state
corresponds to a task that
resides in memory but has not
been made available to the
multitasking kernel.
31
Waiting
Task Create
Task Delete
Task is Preempted
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Task States
 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.
32
Waiting
Task Create
Task Delete
Task is Preempted
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
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 if:
 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
33
Waiting
Task Create
Task Delete
Task is Preempted
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
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.).
34
Waiting
Task Create
Task Delete
Task is Preempted
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Task States
 BLOCKED
CPU starvation occurs when higher
priority tasks use all of the CPU
execution time and lower priority
tasks do not get to run
 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.
35
Waiting
Task Create
Task Delete
Task is Preempted
Task Delete
Interrupt
Int. Exit
Task Delete
μC/OS-II

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Exchanging CPU Control
36
void ExampleTask(void *pdata)
{
for(;;) {
/* User Code */
/*System Call */
/* User Code */
}
}
OSMboxPend();
OSQPend();
OSSemPend();
OSTaskSuspend();
OSTimeDly();
OSTimeDlyHMSM();
More…
uC/OS-II Kernel API
Control returns from task to OS
when Kernel API is called

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Exchanging CPU Control
37
A B B C A
Interrupt Handler
OS
Task
Time
Only one of OS, Task, Interrupt Handler gets CPU control at a time
Scheduling
System Call
Interrupt
Interrupt Exit

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Task Scheduling
 Schedulers are parts of the kernel responsible for determining
which task runs next
 In a Multitasking System, the main objective is to have the CPU
utilized at all times.
 At each opportunity, OS asks:
 IF N Tasks are ready ?
 Which one Should I run ?
 The scheduling can be handled automatically..
 Many kernels also provide a set of API calls that allows
developers to control the state changes.
38

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduling - types
 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.
39
Non-preemptivepreemptive

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Non-preemptive
 It is also called cooperative multitasking;
 tasks cooperate with each other to share the CPU.
 tasks decide for themselves when to give up the CPU; when
completed.
 The new higher priority task will gain control of the CPU only when
the current task gives up the CPU.
 asynchronous events are handled using interrupts
 tasks still have an assigned priority
advantages:
- interrupt latency time is low
- less need to “guard” shared resources
-At the task level, non-preemptive kernels can also use non-reentrant
functions.
disadvantages:
- responsiveness is non-optimal & non-deterministic
- one task may lock-up system
40
Time
ISR
Low-priority Task
High-priority Task
ISR makes the
high-priority task ready
low-priority task
Relinquishes the CPU
(low priority task is finished)

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Preemptive
 the highest priority task (ready) is given
control of the CPU
 current running task is suspended
 after an Interrupt Service Routine (ISR), the
new highest priority task is run
 Most commercial real-time kernels are
preemptive
advantages:
- responsiveness is optimal & deterministic
(Execution of the highest-priority task is
deterministic)
-Task-level response time is minimized
disadvantages:
- shared resources must be properly guarded
-Should not use non-reentrant functions unless
exclusive access to these functions is ensured
41
Time
ISR
Low-priority Task
High-priority Task
ISR makes the
high-priority task ready
high-priority task
Relinquishes the CPU

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduler Concepts
 CPU utilization : keep the CPU as busy as possible.
How much of CPU (usually in %) is in use ?
 Throughput : number of processes (# pf processes) that complete their execution per
time unit.
 Turnaround : total time between submission of a process and its completion.
(waiting + executing + IO Time)
 Waiting time : a mount of time a process has been waiting in the ready queue.(task
enters by System initially), then it is placed in “ready state” when the conditions are
met.
 Response time : amount of time it takes from when a request was submitted until the
first response is produced.
42

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduler Concepts
43

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduling Algorithms in
time-shared System
1. First-Come First-Served
2. Shortest Job First
3. Round Robin
4. Round-robin with priority scheduling
44

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
First In First Out Algorithm
 Also known as First Come, First Served (FCFS).
 It is the simplest scheduling algorithm.
 FIFO simply queues processes in the order that they arrive in the ready queue
 It is non-preemptive
 scheduling overhead is minimal.
 Throughput can be low.
 This is considered as a very good algorithm when few small tasks all with small execution times
45

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Shortest Job First Algorithm
 Also known as Shortest Job First (SJF).
 With this strategy the scheduler arranges processes with the
least estimated processing time remaining to be next in the
queue.
 If a shorter process arrives during another process
'execution, the currently running process may be interrupted.
 This algorithm is designed for maximum throughput in most
scenarios.
 Starvation is possible, especially in a busy system with many
small processes being run
 This algorithm can be
 Preemptive (Running task can be interrupted by another task).
 Non Preemptive
46
Kindly Note Starvation, in general, means a situation
where some process has been denied service for a long
time or has been repeatedly denied service.

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_systemRound-robin scheduling Algorithm
(time-slicing)
 Designed especially for time shared systems.
 Similar to first –come first-served, with preemption
added to switch between process.
 tasks with the same priority are only allowed to run for a
predetermined time period, “a quantum” This is also called
time slicing.
 not necessarily supported by all preemptive kernels
 microC/OS-II does not support round-robin
47
Assumption: Time Slice = 20 time unites

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Round-robin with priority scheduling
 The Round Robin Algorithm is slightly modified by assigning priority to
all tasks.
 Highest priority task can interrupt the CPU so it can be executed.
48

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduling - priorities
 static
 the priority of a task is set at compile time and does not change during
application execution
advantage:
all timing constraints can be known at compile time
disadvantage:
may get priority inversion
 dynamic
 each task can change its priority during execution
advantage:
useful in avoiding priority inversion
disadvantage:
not easy to guarantee schedulability
49

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Priority Inversions
 Low-priority process acquires lock, blocks higher-priority
process
 Priority inheritance temporarily raises process priority
 Difficult to analyze
50

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Priority Inversions Example
51
Task 1 (high)
Task 2 (medium)
Task 3 (low)
1 2 3 4 5 6
 This can happen even in Preemptive kernels. Ex: 3 tasks with low, medium, high priority:
 Task 3 (low) runs while 1 and 2 wait for some event.
 At point 1 Task3 acquires an exclusive lock on a resource.
Get the resource

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
52
Task 1 (high)
Task 2 (medium)
Task 3 (low)
1 2 3 4 5 6
 At point 2, task 1 becomes ready and preempts task 3
 At point 3, task 1 wants the resource but it is still
locked by task 3; so task 1 waits and task 3 resumes
Get the resource

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
53
Task 1 (high)
Task 2 (medium)
Task 3 (low)
1 2 3 4 5 6
 At point 4, task 2 becomes ready and starts running,
preempting task 3.
 Task 2 runs until done, point 5 and task 3 resumes, not task
1 because the latter is still waiting for the resource locked
by task 3
Get the resource

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
54
Task 1 (high)
Task 2 (medium)
Task 3 (low)
1 2 3 4 5 6
 Finally at point 6, task 3 releases the resource and task 1 acquires it and
can run.
 Effectively task 1 has been trapped at the level of task 3 until 3
releases the resource.
Get the resource

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Priority Inheritance Solution
55
Task 1 (high)
Task 2 (medium)
Task 3 (low)
1 2 3 4 5 6
 In a kernel that supports priority
inheritance,
 As soon as task 1 wants the resource (point 3)
locked by task 3, task 3 is temporarily
promoted to task 1’s priority so that it can
continue running until it releases the resource
(point 4)
 Then, task 1 becomes ready because it can
acquire the resource released by task 3.
 Task 1 releases the resource at point 5, but
keeps running also task 2 is ready, because it
has the highest priority
 Finally at point 6, task 1 finishes and task 2 can
run. Task 3, with the lowest priority, waits.
 NB Task 2 could have become ready at point 2
or any after thereafter, with no difference in
outcome..

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Scheduling - the “tick” or quantum
 A hardware Timer generates interrupts at a regular interval
 10 -- 1000 Hz; usually derived from power line frequency
 Used to provide delays and timeouts
 The ISR for a clock tick calls a kernel service to signal a tick.
This may well cause a context switch
 A higher priority task may have become ready to run in the interim
 In “round robin” scheduling, tasks of equal priority get a fixed number of
ticks’ CPU time than go to the back of the queue
 The clock interrupt has higher priority than all tasks (because it
is an interrupt) but lower priority than other interrupts.
56= special interrupt
Periodical
= RTOS heartbeat

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
The RTOS Tick 57
Delaying a task: “n” clock ticks

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Shared Data between Tasks
58
how does the consumer know that (new) data is available?
Data is shared between several tasks and, in
order to keep the data in a consistent state,
we need to protect it from concurrent
access. In other words: access to the data
must be serialized.
This use case is mainly about task synchronization:
the interplay between producer and consumer must work
smoothly. How does a consumer know that new data is
available?
how to serialize access to shared data?

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Two shared Resource Control
59
the mutex = MUTual EXclusion.
the semaphore
Resource
A resource is any entity used by a task. A resource can thus be
an I/O device such as a printer, a keyboard, a display, etc. or a
variable, a structure, an array, etc.
Shared Resource
A shared resource is a resource that can be used by more than one task. Each task should
gain exclusive access to the shared resource to prevent data corruption. This is called
Mutual Exclusion.

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
the mutex
 A critical section is a piece of code (part of a
function) from which the access to the shared
resource must be atomic. At a certain moment in
time, one and only one critical section is allowed to
access the shared data
 The mutex implements two operations:
 acquire: enter the critical section, or sleep if another
task has already acquired the mutex, and
 release: leave the critical section. Other tasks now
have the possibility to acquire the mutex.
60

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
the mutex
 The concept of ownership is very important
here: the task that acquired the mutex must release
it as well.
 techniques to address mutual exclusion include:
 disabling/enabling interrupts
 disabling scheduling
 performing test-and-set operations (indivisibly)
 using semaphores
61

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Mutual Exclusion
Disable interrupts Mechanism
 Demand: exclusive use of a resource
 Disable interrupts
 Used on critical sections of code
 disabling/enabling interrupts
 used to access a few variables or small data structures
 used when the process time is minimal
 affects interrupt latency
 you should not disable interrupts for any longer than the kernel does
 in C/OS-II:
OS_ENTER_CRITICAL( );
… // you can access shared data here
OS_EXIT_CRITICAL( ):
62
Using Test-And-Set to access a resource

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Mutual Exclusion
Disable interrupts Mechanism
63
So if a shared resource is shared
between a task and an interrupt
service routine, then the task can
disable interrupts before entering the
shared resource. This will stop the ISR
from accessing the shared resource
Disadvantages:
1. Disabling interrupt for long time
harm the system response
And the RTOS Kernel Itself

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_systemMutual Exclusion
Disable preemption (Task Switching) Mechanism
64
disabling scheduling
instead of disabling all maskable interrupts, you may just
want to disable the scheduler
an interrupted task is returned to, not necessarily
the highest priority task
implies that data is not shared with the ISRs
in C/OS-II:
OSSchedLock( );
… // you can access shared data here
OSSchedUnlock( );

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
performing test-and-set operations (indivisibly)
 perform test-and-set operations (indivisibly)
 two tasks may agree that to use a common
resource, they must first check a global
variable
 while it is being checked, and before it is set,
by one task, it must be made inaccessible by
the other
 this can be achieved by:
 disabling interrupts (above) or
 some processors now support a single TAS
instruction
 Make the following
test test-and-set variable
Set test-and-set variable to 1
Access resource
Set test-and-set variable to 0
65
Kindly Note: DPRAM test-and-set instructions can
work in many ways
When CPU 1 issues a test-and-set instruction, the
DPRAM first makes an "internal note" of this by
storing the address of the memory location in a special
place. If at this point, CPU 2 happens to issue a test-
and-set instruction for the same memory location, the
DPRAM first checks its "internal note", recognizes the
situation, and issues a BUSY interrupt, which tells CPU
2 that it must wait and retry.

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
SEMAPHORES | Operating System
(Simplified)
66
https://www.youtube.com/watch?v=PQ5aK5wLCQE

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Mutual Exclusion - semaphores
 a protocol mechanism to control
access to shared resources, signal
the occurrence of an event or allow
two tasks to synchronize
 one analogy is that in order for a
task to use a resource it must first
draw a key for it
 if the key(s) is in use, the task
suspends
 wait on (pend) & signal (post)
semaphore
 two types of semaphores:
 binary and counting (general)
67
task 2
task 1 1. pend
4. post
Printer
2. pend
6. post
5. “my name is task 2”
3. “my name is task 1”

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Mutual Exclusion - semaphores
68
 accessing shared data in C/OS-II
OS_EVENT *SharedDataSem;
SharedDataSem = OSSemCreate(1);
...
void Function (void) {
INT8U err; //read as “char *err” (string)
...
OSSemPend(SharedDataSem, 0, &err);
… //access shared data
OSSemPost(SharedDataSem);
}
binary semaphore
timeout value
{wait forever in this case}
error message code

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Encapsulated semaphores
 Principle:
 task does not have to control semaphore
 Resource controls the semaphore
 Typical: driver of the resource solves semaphores
 Release of a semaphore is done through a timeout
 eg. Network card, serial port, ...
 Advantages:
 tasks just use the driver
 programmer does not have to deal with the semaphores
69

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Deadlock
 Two tasks waiting for each others
semaphore
 most kernels allow you to specify a
timeout when acquiring a semaphore
(with error code)
70

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Synchronisation
 Synchronisation between tasks
 Synchronisation between tasks and ISR
 How ?
 Use of semaphores
 "unilateral rendezvous"
 semaphore signals an event (flag, NOT a key)
71

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Synchronization : Use of semaphores
 one task can be synchronized with another (no data transferred) by
using a semaphore
 the semaphore is a flag signaling the occurrence of an event (vice a
key for mutex)
 in this case, the semaphore is initialized to 0
72
Task 2 Task 1
2. Post 1. Pend

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
"bilateral rendezvous"
 bilateral rendezvous - two tasks can be synchronized with each other
by using two separate semaphores
73
Task 2 Task 1
1. Signal Task 2
2. wait for signal from task 2
4. wait for signal from task 1
3. Signal Task 1

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Event Flags
 When ?
 A task has to synchronise with multiple events
 Disjunctive synchronisation
 logical OR
 synchronisation if one of the events occurred
 Conjunctive synchronisation
 logical AND
 synchronisation if all
events occurred
74

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Event Flags
75

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
Intertask communication
 What ?
 ISR or task sends information to other task
 How ?
 Global variables
 sending messages
 Global variables
 Make sure you have exclusive access
 by disabling and enabling interrupts
 by use of semaphores
 more commonly, messages are sent between tasks
 usually achieved via a message mailbox or message queue
76

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
message mailbox
 message mailbox
 messages are typically pointer-sized variables
 a task or an ISR can deposit a message (pointer) into a mailbox.
 similarly, one or more tasks can retrieve the message from the mailbox
 the sending and receiving tasks must agree on what type of data the
message points to
77
Task 1 Task 2
1. Post 2. Pend
100msec

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
message mailbox
 message mailbox (cont’d)
 C/OS-II provides the following type of typical mailbox services:
initialization OSMboxCreate(...);
deposit (post) OSMboxPost(…);
wait (pend) OSMboxPend(…); //includes timeout
get (accept) OSMboxAccept(…);
query OSMboxQuery(…);
*pend will wait on message (for some timeout period, while accept will get the message
if it is there but not wait for it)
78

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
message queues
 message queues
 used to send one or more messages to tasks
 it is basically an array of mailboxes
 messages can be retrieved either FIFO or LIFO
 a kernel will normally provide the same mechanisms for a message queue as
for a message mailbox
79

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
References
 Embedded Microcomputer Systems Real Time Interfacing Third Edition
Jonathan W. Valvano University of Texas at Austin.
 MicroC/OS-II the real-time kernel second edition jean j.labrosse.
 RTOS Concepts http://www.embeddedcraft.org.
 Task Synchronization Prof. Chung-Ta King.
 Study of an operating system: FreeRTOS Nicolas Melot
 Real-Time Operating Systems Prof. Stephen A. Edwards
 Real Time Operating Systems for Networked Embedded Systems
Subhashis Banerjee Indian Institute of Technology Delhi
 USING THE FREERTOS REAL TIME KERNEL A Practical Guide
Richard Barry
 http://www.rtos.be/2013/05/mutexes-and-semaphores-two-concepts-
for-two-different-use-cases/
80

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
References
 https://www.embedded.com/design/operating-
systems/4436454/Selecting-an-operating-system-for-an-embedded-
application-
 http://free-electrons.com/training/
 CENG-336 Introduction to Embedded Systems Development
 https://nawid2012.wordpress.com/2012/11/13/real-time-systems/
 Embedded Real-Time Systems Memory management
 Unit 4 Real Time Operating System
 Real Time Operating Systems
 Real Time Operating Systems Johan Dams
81

Follow us
Press
here
#LEARN_IN DEPTH
#Be_professional_in
embedded_system
82

Embedded Systems OS Concepts

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Embedded Systems OS Concepts

Ähnlich wie Embedded Systems OS Concepts (20)

Mehr von Keroles karam khalil

Mehr von Keroles karam khalil (17)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Embedded Systems OS Concepts