EMBEDDED AND REAL

TIME SYSTEMS

1
Example of Real Time
Operating Systems

2
 Example of RTOS

 POSIX

 Windows CE

3
 POSIX
 POSIX - Portable Operating System Interface
 POSIX.1 – Core services
 POSIX.1b – Real-time extensions
 POSIX.1c – Thread extensions
 The POSIX standard is written in terms of the C
programming language. POSIX supports two
programming environments.
 One is based on the Traditional C language.
 The other is based on the Standard C language
defined by American National Standard for Information
Systems.
 Since Standard C was developed by the American
National Standards Institute (ANSI), some people call
it ANSI C
4
 POSIX is based on UNIX operating system.
 Usually UNIX was not originally designed as a real
time operating system, POSIX has been extended to
support real time requirements.
 POSIX defines a standard way for an application to
interface to the operating system.
 The original POSIX standard defines interfaces to
core functions such as file operations, process
management, signals, and devices.

5
POSIX

6
 The POSIX process model
• POSIX does not implement lightweight
processes.

• Each POSIX process runs in its own address

space and cannot directly access the data or
code of other processes

7
 Processes in POSIX
 In POSIX, a new process is created by making a copy
of an existing process

 The copying process creates two different processes

both running the same code

 The complication comes in ensuring that one process

runs the code intended for the new process.

 While the other process continues the work of the old

process.

8
 A process makes a copy of itself by calling fork()
function
 It creates a new child process which is exact copy
of parent process
 The both have the same code and the same data
values with one exceptions the return value of fork()
– Parent Process: returns the process ID of the
child process
– Child process: returns 0
 We can Test the return value of fork() to determine
which process is the child.

9
 execv() function –> It takes the list of arguments to
the process in the form of array.
 perror() & exit() function –> To perform call
functions.
 parent_stuff() function –> To perform the work of
parent function.
 wait() function –> It make wait the child process

10
 Real time scheduling in POSIX
• POSIX supports real time scheduling in the
_POSIX_PRIORITY_SCHEDULING resource
• The sched_setscheduler() function is used to determine a
process’s scheduling policy and other parameters
Ex: i = sched_setscheduler (process_id, SCHED_FIFO,
&sched_params)
 It tells POSIX to use the SCHED_FIFO policy for this process
along with some other scheduling parameters.
 sched_getparams() function returns the current parameter values
for a process
 sched_setparams() function changes the parameter values
11
 SCHED_FIFO scheduling

• POSIX supports rate-monotonic scheduling in the

SCHED_FIFO scheduling policy.
• It is a strict priority-based
• scheduling scheme in which a process runs until it is
preempted or terminates
• The term FIFO simply refers to the fact that, within a
priority, processes run in first-come first-served
order.

12
 SCHED_RR
• SCHED_RR is a combination of real-time and
interactive scheduling techniques:
• within a priority level, the processes are timesliced.
Interactive systems must ensure
• that all processes get a chance to run, so time is
divided into quanta. Processes get the
• CPU in multiple of quanta

13
 SCHED_OTHER
• The SCHED_OTHER is defined to allow non-real-
time processes to intermix with realtime processes.
• The precise scheduling mechanism used by this
policy is not defined.
• It is used to indicate that the process does not need a
real-time scheduling policy.

14
 POSIX

• POSIX supports

Semaphores

Shared memory mechanism

Message Queues

15
 POSIX semaphores
 POSIX supports Counting semaphores in the
_POSIX_SEMAPHORES option

 A Counting semaphore allows more than one

process to access a resource at a time

 If a semaphore allows up to N resources, then it will

not block until N process have simultaneously passed
the semaphore

16
 semaphores
• At that point, the blocked process can resume only
after one of the processes has given up its semaphore.
• The simplest way to think about counting semaphores
is that they count down to 0- when the semaphore
value is 0-,
• the process must wait until another process gives
up the semaphore and increments the count.

17
 POSIX semaphores

 Names for the semaphore start with “/”

• sem_open() – To create a semaphore

• sem_close () – To destroy a semaphore

• sem_wait() – To wait for Getting a semaphore

• sem_post() – To Releasing a semaphore

18
 POSIX Shared Memory
 POSIX shared memory is supported under the
_POSIX_SHARED_MEMORY_OBJECTS option.
 Shared memory functions create blocks of memory
that can be used by several processes
• shm_open() – To open a shared memory

• close() – To close a shared memory

• mmap() – For memory mapping

• objdesc = shm_open(“/memobj1”,O_RDWR);
19
• Before using the shared memory object, we must
map it into the process memory
• space using the mmap() function. POSIX assumes
that shared memory objects
• fundamentally reside in a backing store such as a disk
and are then mapped into the address space of the
process.

20
 POSIX pipes
• The pipe is very familiar to Unix users from its shell syntax:

if (pipe(pipe_ends) <0) { /* create the pipe, check for errors */

perror(“pipe”);
break;

• A parent process uses the pipe() function to create a pipe to

talk to a child.
• It must do so before the child itself is created or it will not
have any way to pass a pointer to the pipe to the child.

21
• Each end of a pipe appears to the programs as a filed
the process at the head of the pipe writes to one file
descriptor while the tail process reads from another
file descriptor.
• The pipe() function returns an array of file
descriptors,
• The first for the write end and the second for the read
end.

22
 POSIX Message Queues
 POSIX supports message queues under the
_POSIX_MESSAGE_PASSING option.
 Message queues starts with “/”
 No need to create a queue before creating a process

• mq_open() – to create named queue

• mq_close() – to destroy named queue

• mq_send() – to transmit a message

• mq_receive() – to receive a message

• mq_maxmsg() – Maximum number of messages

• mq_msgsize() – Maximum size of a message
23
• The advantage of a queue over a pipe is that,
because queues have names,

• we do not have to create the pipe descriptor before

creating the other process using it, as with pipes.

• The name of a queue follows the same rules as for

semaphores and shared memory: it starts with a “/”
and contains no other “/” characters

24