Module-2 presentation.ppt of embedded system

Silberschatz, Galvin and Gagne ©2018
Operating System Concepts – 10th
Edition
Chapter 3: Processes

3.2 Silberschatz, Galvin and Gagne ©2018
Edition
Chapter 3: Processes
 Process Concept
 Process Scheduling
 Operations on Processes
 Interprocess Communication
 IPC in Shared-Memory Systems
 IPC in Message-Passing Systems
 Examples of IPC Systems
 Communication in Client-Server Systems

Edition
Objectives
 Identify the separate components of a process and illustrate
how they are represented and scheduled in an operating
system.
 Describe how processes are created and terminated in an
operating system, including developing programs using the
appropriate system calls that perform these operations.
 Describe and contrast interprocess communication using
shared memory and message passing.
 Design programs that uses pipes and POSIX shared memory
to perform interprocess communication.
 Describe client-server communication using sockets and
remote procedure calls.
 Design kernel modules that interact with the Linux operating
system.

Edition
Process Concept (Cont.)
 Program is passive entity stored on disk (executable file);
process is active
 Program becomes process when executable file loaded into
memory
 Execution of program started via GUI mouse clicks, command
line entry of its name, etc
 One program can be several processes
 Consider multiple users executing the same program

Edition
Process Concept
 An operating system executes a variety of programs that run
as a process.
 Process – a program in execution; process execution must
progress in sequential fashion
 Multiple parts
 The program code, also called text section (The text
segment in a process structure primarily consists
of the executable code of the program, including
functions and instructions.)
 Current activity including program counter, processor
registers
 Stack containing temporary data
 Function parameters, return addresses, local
variables
 Data section containing global variables
 Heap containing memory dynamically allocated during
run time Process in Memory

Edition
Process in Memory

Edition
Memory Layout of a C Program

Edition
Process State
 As a process executes, it changes state
 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 processor
 Terminated: The process has finished execution

Edition
Diagram of Process State

Edition
There are several process states in operating system, they are:
• New State: When a process is first created or is initialized by the operating
system, it is in the new state. In this state, the process is being prepared to
enter the ready state.
• Ready State: When a process is ready to execute, it is in the ready state. In this
state, the process is waiting for the CPU to be allocated to it so that it can start
executing its instructions. A process can remain in the ready state for an
indeterminate period, waiting for the CPU to become available.
• Running State: When the CPU is allocated to a process, it enters the running
state. In this state, the process executes its instructions and uses system
resources such as memory, CPU, and I/O devices. Only one process can be in
the running state at a time, and the operating system determines which process
gets access to the CPU using scheduling algorithms.
• Waiting/Blocked State: Sometimes, a process needs to wait for a particular
event, such as user input or data from a disk drive. In such cases, the process
enters the blocked state. In this state, the process is not using the CPU, but it is
not ready to run either. The process remains in the blocked state until the event
it is waiting for occurs.

Edition
• Terminated State: The terminated state is reached when a process
completes its execution or terminates by the operating system. In this
state, the process no longer uses any system resources, and its
memory space is deallocated.
• Suspended State: When a process is temporarily removed from the
main memory and is stored on the disk to free up memory, it is said to
be in a suspended state. The process is not actively executing, and its
memory space is saved on the disk. When the process is needed again,
it is loaded back into the main memory and resumes execution.

Edition
Process Control Block (PCB)
• A Process Control Block (PCB) is a data structure
used by an operating system to store all the
information about a process.
• It's like a "notebook" for each process, containing
details like the process's state, program counter,
register values, memory allocation, and
scheduling information.
• The PCB is crucial for efficient process
management, scheduling, and resource
allocation.

Edition
Information associated with each process
(also called task control block)
 Process state – running, waiting, etc
 Program counter – location of instruction
to next execute
 CPU registers – contents of all process-
centric registers
 CPU scheduling information- priorities,
scheduling queue pointers
 Memory-management information –
memory allocated to the process
 Accounting information – CPU used, clock
time elapsed since start, time limits
 I/O status information – I/O devices
allocated to process, list of open files

Edition
• A Process Control Block (PCB) is a data structure
used by an operating system to store all the
information about a process.
• It's like a "notebook" for each process, containing
details like the process's state, program counter,
register values, memory allocation, and
scheduling information.
• The PCB is crucial for efficient process
management, scheduling, and resource
allocation.

Edition
Threads
 So far, process has a single thread of execution
 Consider having multiple program counters per process
 Multiple locations can execute at once
 Multiple threads of control -> threads
 Must then have storage for thread details, multiple program
counters in PCB
 Explore in detail in Chapter 4

Edition
Process Representation in Linux
Represented by the C structure task_struct
pid t_pid; /* process identifier */
long state; /* state of the process */
unsigned int time_slice /* scheduling information */
struct task_struct *parent;/* this process’s parent */
struct list_head children; /* this process’s children */
struct files_struct *files;/* list of open files */
struct mm_struct *mm; /* address space of this process */

Edition
Process Scheduling
 Maximize CPU use, quickly switch processes onto CPU core
 Process scheduler selects among available processes for
next execution on CPU core
 Maintains scheduling queues of processes
 Ready queue – set of all processes residing in main
memory, ready and waiting to execute
 Wait queues – set of processes waiting for an event (i.e.
I/O)
 Processes migrate among the various queues

Edition
Ready and Wait Queues

Edition
Representation of Process Scheduling

Edition
CPU Switch From Process to Process
A context switch occurs when the CPU
switches from one process to another.

Edition
Context Switch
 When CPU switches to another process, the system must save
the state of the old process and load the saved state for the
new process via a context switch
 Context of a process represented in the PCB
 Context-switch time is overhead; the system does no useful
work while switching
 The more complex the OS and the PCB  the longer the
context switch
 Time dependent on hardware support
 Some hardware provides multiple sets of registers per CPU
 multiple contexts loaded at once

Edition
Multitasking in Mobile Systems
 Some mobile systems (e.g., early version of iOS) allow only one
process to run, others suspended
 Due to screen real estate, user interface limits iOS provides for a
 Single foreground process- controlled via user interface
 Multiple background processes– in memory, running, but not
on the display, and with limits
 Limits include single, short task, receiving notification of events,
specific long-running tasks like audio playback
 Android runs foreground and background, with fewer limits
 Background process uses a service to perform tasks
 Service can keep running even if background process is
suspended
 Service has no user interface, small memory use

Edition
Operations on Processes
 System must provide mechanisms for:
 process creation
 process termination

Edition
Process Creation
 Parent process create children processes, which, in turn
create other processes, forming a tree of processes
 Generally, process identified and managed via a process
identifier (pid)
 Resource sharing options
 Parent and children share all resources
 Children share subset of parent’s resources
 Parent and child share no resources
 Execution options
 Parent and children execute concurrently
 Parent waits until children terminate

Edition
A Tree of Processes in Linux

Edition
Process Creation (Cont.)
 Address space
 Child duplicate of parent
 Child has a program loaded into it
 UNIX examples
 fork() system call creates new process
 exec() system call used after a fork() to replace the
process’ memory space with a new program
 Parent process calls wait() for the child to terminate

Edition
C Program Forking Separate Process

Edition
Creating a Separate Process via Windows API

Edition
Process Termination
 Process executes last statement and then asks the operating
system to delete it using the exit() system call.
 Returns status data from child to parent (via wait())
 Process’ resources are deallocated by operating system
 Parent may terminate the execution of children processes using
the abort() system call. Some reasons for doing so:
 Child has exceeded allocated resources
 Task assigned to child is no longer required
 The parent is exiting and the operating systems does not
allow a child to continue if its parent terminates

Edition
Process Termination
 Some operating systems do not allow child to exists if its parent has
terminated. If a process terminates, then all its children must also
be terminated.
 cascading termination. All children, grandchildren, etc. are
terminated.
 The termination is initiated by the operating system.
 The parent process may wait for termination of a child process by
using the wait()system call. The call returns status information
and the pid of the terminated process
pid = wait(&status);
 If no parent waiting (did not invoke wait()) process is a zombie
 If parent terminated without invoking wait , process is an orphan

Edition
Android Process Importance Hierarchy
 Mobile operating systems often have to terminate processes to reclaim
system resources such as memory. From most to least important:
o Foreground process
o Visible process
o Service process
o Background process
o Empty process
 Android will begin terminating processes that are least important.

Edition
Multiprocess Architecture – Chrome Browser
 Many web browsers ran as single process (some still do)
 If one web site causes trouble, entire browser can hang or crash
 Google Chrome Browser is multiprocess with 3 different types of
processes:
 Browser process manages user interface, disk and network I/O
 Renderer process renders web pages, deals with HTML,
Javascript. A new renderer created for each website opened
 Runs in sandbox restricting disk and network I/O, minimizing
effect of security exploits
 Plug-in process for each type of plug-in

Edition
Interprocess Communication
 Processes within a system may be independent or cooperating
 Cooperating process can affect or be affected by other processes,
including sharing data
 Reasons for cooperating processes:
 Information sharing
 Computation speedup
 Modularity
 Convenience
 Cooperating processes need interprocess communication (IPC)
 Two models of IPC
 Shared memory
 Message passing

Edition
Communications Models
(a) Shared memory. (b) Message passing.

Edition
Cooperating Processes
 Independent process cannot affect or be affected by the execution
of another process
 Cooperating process can affect or be affected by the execution of
another process
 Advantages of process cooperation
 Information sharing
 Computation speed-up
 Modularity
 Convenience

Edition
Producer-Consumer Problem
 Paradigm for cooperating processes, producer process
produces information that is consumed by a consumer
process
 unbounded-buffer places no practical limit on the size
of the buffer
 bounded-buffer assumes that there is a fixed buffer
size

Edition
Interprocess Communication – Shared Memory
 An area of memory shared among the processes that wish
to communicate
 The communication is under the control of the users
processes not the operating system.
 Major issues is to provide mechanism that will allow the
user processes to synchronize their actions when they
access shared memory.
 Synchronization is discussed in great details in Chapters 6
& 7.

Edition
Bounded-Buffer – Shared-Memory Solution
 Shared data
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
 Solution is correct, but can only use BUFFER_SIZE-1 elements

Edition
Producer Process – Shared Memory
item next_produced;
while (true) {
/* produce an item in next produced */
while (((in + 1) % BUFFER_SIZE) == out)
; /* do nothing */
buffer[in] = next_produced;
in = (in + 1) % BUFFER_SIZE;
}

Edition
Consumer Process – Shared Memory
item next_consumed;
while (true) {
while (in == out)
; /* do nothing */
next_consumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
/* consume the item in next consumed */
}

Edition
Interprocess Communication – Message Passing
 Mechanism for processes to communicate and to synchronize
their actions
 Message system – processes communicate with each other
without resorting to shared variables
 IPC facility provides two operations:
 send(message)
 receive(message)
 The message size is either fixed or variable

Edition
Message Passing (Cont.)
 If processes P and Q wish to communicate, they need to:
 Establish a communication link between them
 Exchange messages via send/receive
 Implementation issues:
 How are links established?
 Can a link be associated with more than two processes?
 How many links can there be between every pair of
communicating processes?
 What is the capacity of a link?
 Is the size of a message that the link can accommodate fixed or
variable?
 Is a link unidirectional or bi-directional?

Edition
Message Passing (Cont.)
 Implementation of communication link
 Physical:
 Shared memory
 Hardware bus
 Network
 Logical:
 Direct or indirect
 Synchronous or asynchronous
 Automatic or explicit buffering

Edition
Direct Communication
 Processes must name each other explicitly:
 send (P, message) – send a message to process P
 receive(Q, message) – receive a message from process Q
 Properties of communication link
 Links are established automatically
 A link is associated with exactly one pair of communicating
processes
 Between each pair there exists exactly one link
 The link may be unidirectional, but is usually bi-directional

Module-2 presentation.ppt of embedded system

More Related Content

Similar to Module-2 presentation.ppt of embedded system (20)

Recently uploaded (20)

Module-2 presentation.ppt of embedded system