10EC65 Operating Systems - Process Management

Operating Systems
10EC65
Unit 3
Process Management
Reference Book:
Operating Systems - A Concept based Approach
D. M. Dhamdhare, TMH, 3rd Edition, 2010
Shrishail Bhat, AITM Bhatkal
Introduction Process Concept
A process is an execution of a program

A programmer uses processes to achieve execution of programs in
a sequential or concurrent manner as desired
An OS uses processes to organize execution of programs
In programmer view, we discuss how concurrent processes are
created and how they interact with one another to meet a common
goal
In OS view, we discuss how an OS creates processes, how it keeps
track of process states, and how it uses the process state
information to organize execution of programs
A thread is an execution of a program that uses the environment of
a process, i.e., its code, data and resources
Processes and Programs
A program is a passive entity that does not perform any action

by itself; it has to be executed to realize the actions specified in
it
A process is an execution of a program; it actually performs the
actions specified in a program

Processes and Programs (continued)

Relationships between Processes and Programs
The program consists of a main program and a set of functions

The OS is not aware of the existence of functions. Hence
execution of the program constitutes a single process

Child Processes
The OS initiates an execution of a program by creating a

process for it Main process
The main process may make system calls to create other
processes, which become its child processes
A child process may itself create other processes, and so on.
Child processes and parents create a process tree
Typically, a process creates one or more child processes and
delegates some of its work to each
Multitasking within an application
Child Processes (continued)
5.7
Example: Child Processes in a Real-Time Application

Programmer View of Processes
Processes are a means to achieve concurrent execution of a

program
The main process of a concurrent program creates child
processes
It assigns appropriate priorities to them
The main process and the child processes interact to achieve
their common goal
This interaction may involve exchange of data or may require
the processes to coordinate their activities with one another
Programmer View of Processes (continued)
An OS provides the following operations to implement

programmer view of processes:
Creating child processes and assigning priorities to them
Terminating child processes
Determining the status of child processes
Sharing, communication and synchronization between processes

Sharing, Communication and Synchronization Between Processes
Processes of an application need to interact with one another

because they work towards a common goal

Concurrency and Parallelism
Parallelism: quality of occurring at the same time

Two tasks are parallel if they are performed at the same time
Obtained by using multiple CPUs
As in a multiprocessor system
Concurrency is an illusion of parallelism
Two tasks are concurrent if there is an illusion that they are being
performed in parallel whereas only one of them may be performed at any
time
In an OS, obtained by interleaving operation of processes on the CPU
Both concurrency and parallelism can provide better throughput

OS View of Processes
In the OS view, a process is an execution of a program

The OS creates processes, schedules them for use of the CPU,
and terminates them
To realize this, the OS uses the process state to keep a track of
what a process is doing at any moment
Whether executing on the CPU
Waiting for the CPU to be allocated to it
Waiting for an I/O operation to complete
Waiting to be swapped into memory

Background Execution of Programs
When a process is scheduled, the CPU executes instructions in

the program
When CPU is to be switched to some other process, the kernel
saves the CPU state
This state is loaded back into the CPU when the process is
scheduled again

Process Definition
Accordingly, a process comprises six components:

(id, code, data, stack, resources, CPU state)
where
id is the unique id assigned by the OS
code is the code of the program (it is also called the text of a program)
data is the data used in the execution of the program, including data from files
stack contains parameters of functions and procedures called during execution of
the program, and their return addresses
resources is the set of resources allocated by the OS
CPU state is composed of contents of the PSW and the general-purpose registers
(GPRs) of the CPU (we assume that the stack pointer is maintained in a GPR)

Controlling Processes
The OS view of a process consists of two parts:

Code and data of the process, including its stack and resources
allocated to it
Information concerning program execution

Process Environment
Also called process context

It contains the address space of a process and all the
information necessary for accessing and controlling resources.
The OS creates a process environment by
allocating memory to the process
loading the process code in the allocated memory
setting up its data space

Process Environment (continued)

Process Control Block (PCB)
A PCB is a kernel data structure that contains information

concerning process id and CPU state

Controlling Processes (continued)
The kernel uses four fundamental functions to

control processes:
1. Context save: Saving CPU state and information
concerning resources of the process whose
operation is interrupted
2. Event handling: Analyzing the condition that led
to an interrupt, or the request by a process that
led to a system call, and taking appropriate
actions
3. Scheduling: Selecting the process to be executed
next on the CPU
4. Dispatching: Setting up access to resources of
the scheduled process and loading its saved CPU
state in the CPU to begin or resume its operation

Process States and Transitions

Process States and Transitions (continued)
A state transition for a process is a change in its state

Caused by the occurrence of some event such as the start or end of
an I/O operation



Example: State Transition in a Time Sharing System
A system contains two processes P1 and P2

Suspended Processes
OS needs additional states to describe processes suspended

due to swapping
The process in suspended state is not considered for scheduling
Two typical causes of suspension
A process is moved out of memory, i.e., it is swapped out
The user who initiates a process specifies that a process should not
be scheduled until some condition is satisfied

Suspended Processes (continued)

Process Control Block (PCB) (continued)
The PCB contains all information pertaining to a process that is

used in controlling its operation, accessing resources and
implementing communication with other processes

Process Control Block (PCB) (continued)

Context Save, Scheduling and Dispatching
Context save function:

Saves CPU state in PCB, and saves information concerning process
environment
Changes process state from running to ready
Scheduling function:
Uses process state information from PCBs to select a ready process
for execution and passes its id to dispatching function
Dispatching function:
Sets up environment of the selected process, changes its state to
running, and loads saved CPU state from PCB into CPU

Example - Context Save, Scheduling and Dispatching
An OS contains two processes P1 and P2, with P2 having a

higher priority than P1. Let P2 be blocked on an I/O operation
and let P1 be running. The following actions take place when
the I/O completion event occurs for the I/O operation of P2:
1. The context save function is performed for P1 and its state is changed
to ready
2. Using the event information field of PCBs, the event handler finds
that the I/O operation was initiated by P2, so it changes the state of
P2 from blocked to ready
3. Scheduling is performed: P2 is selected because it is the highest-
priority ready process
4. P2s state is changed to running and it is dispatched
Process Switching
Functions 1, 3, and 4 in this example collectively perform

switching between processes P1 and P2
Switching between processes also occurs when a running
process becomes blocked as a result of a request or gets
preempted at the end of a time slice
Switching between processes involves more than saving the
CPU state of one process and loading the CPU state of another
process. The process environment needs to be switched as well.
State information of a process - all the information that needs
to be saved and restored during process switching
Events Pertaining to a Process
The following events occur during the operation of an OS:

1.Process creation event: A new process is created
2.Process termination event: A process finishes its execution
3.Timer event: The timer interrupt occurs
4.Resource request event: Process makes a resource request
5.Resource release event: A resource is released
6.I/O initiation request event: Process wishes to initiate an I/O operation

Events Pertaining to a Process (continued)
7. I/O completion event: An I/O operation completes

8. Message send event: A message is sent by one process to another
9. Message receive event: A message is received by a process
10. Signal send event: A signal is sent by one process to another
11. Signal receive event: A signal is received by a process
12. A program interrupt: An instruction executed in the running
process malfunctions
13. A hardware malfunction event: A unit in the computers hardware
malfunctions

Event Control Block (ECB)
When an event occurs, the kernel must find the process whose
state is affected by it
OSs use various schemes to speed this up
E.g., Event Control Blocks (ECBs)

Example Use of ECB for Handling I/O Completion
The actions of the kernel when process Pi requests an I/O operation

on some device d, and when the I/O operation completes, are as
follows:
1. The kernel creates an ECB, and initializes it as follows:
a) Event description := end of I/O on device d
b) Process awaiting the event := Pi
2. The newly created ECB (let us call it ECBj ) is added to a list of ECBs
3. The state of Pi is changed to blocked and the address of ECBj is put into the
Event information field of Pi s PCB
4. When the interrupt End of I/O on device d occurs, ECBj is located by
searching for an ECB with a matching event description field
5. The id of the affected process, i.e., Pi , is extracted from ECBj . The PCB of
Pi is located and its state is changed to ready.
Example Use of ECB for Handling I/O Completion (continued)
P1 initiates I/O operation on d

Summary of Event Handling

Threads
A thread is an alternative model of program execution

A process creates a thread through a system call
Thread operates within process context
Since a thread is a program execution, it has its own stack and
CPU state
Switching between threads incurs less overhead than switching
between processes
Threads of the same process share code, data and resources
with one another
Threads (continued)

Threads (continued)
Process Pi has three threads represented by wavy lines

The kernel allocates a stack and a thread control block (TCB) to
each thread
The threads execute within the environment of Pi
The OS saves only the CPU state and stack pointer while
switching between threads of the same process
Use of threads effectively splits the process state into two parts
Resource state remains with process
CPU state (Execution state) is associated with thread

Thread Control Block
A TCB is analogous to the PCB and stores the following

information:
Thread scheduling informationthread id, priority and state
CPU state, i.e., contents of the PSW and GPRs
Pointer to PCB of parent process
TCB pointer, which is used to make lists of TCBs for scheduling

Thread States and State Transitions
When a thread is created, it is put in the ready state because

its parent process already has the necessary resources
allocated to it
It enters the running state when it is scheduled
It does not enter the blocked state because of resource
requests, as it does not make any resource requests
However, it can enter the blocked state because of process
synchronization requirement

Advantages of Threads

Implementation of Threads
Kernel-Level Threads
Threads are managed by the kernel
User-Level Threads
Threads are managed by thread library
Hybrid Threads
Combination of kernel-level and user-level threads

Kernel-Level Threads
A kernel-level thread is
implemented by the kernel
Creation, termination and
checking their status is
performed through system
calls

Kernel-Level Threads (continued)
When a process makes a create_thread system call, the kernel

creates a thread, assigns an id to it, and allocates a TCB
The TCB contains a pointer to the PCB of the process
When an event occurs, the kernel saves the CPU state of the
interrupted thread in its TCB
After event handling, the scheduler selects one ready thread
The context save and load is done if the selected thread belongs to
a different process than the interrupted thread
If both threads belong to the same process, actions to save and
load process context are unnecessary. This reduces switching
overhead.
Kernel-Level Threads (continued)
Advantages
A kernel-level thread is like a process except that it has a smaller
amount of state information. This similarity is convenient for
programmers
In a multiprocessor system, kernel-level threads provide parallelism
Better computation speed-up
Disadvantages
Switching between threads is performed as a result of event
handling. Hence it incurs the overhead of event handling even if
the interrupted thread and the selected thread belong to the same
process

User-Level Threads
Implemented by a thread library which is linked

to the code of a process
User-Level Threads (continued)
The library sets up the thread implementation arrangement

without involving the kernel, and interleaves operation of
threads in the process
The kernel is not aware of presence of user-level threads; it
sees only the process
The scheduler considers PCBs and selects a ready process; the
dispatcher dispatches it

User-Level Threads (continued)
Advantages
Thread synchronization and scheduling is implemented by the
thread library. So thread switching overhead is smaller than in
kernel-level threads.
This also enables each process to use a scheduling policy that best
suits its nature
Disadvantages
Blocking a thread would block its parents process. In effect, all
threads of the process would get blocked.
User-level threads cannot provide parallelism and concurrency
Hybrid Thread Models
It has both user-level threads and kernel-level threads

Can provide a combination of low switching overhead of user-level threads
and high concurrency and parallelism of kernel-level threads
Hybrid Thread Models (continued)
The thread library creates user-level threads in a process and

associates a TCB with each user-level thread
The kernel creates kernel-level threads in a process and
associates a kernel thread control block (KTCB) with each
kernel-level thread
Three methods of association
Many-to-one
One-to-one
Many-to-many

Hybrid Thread Models (continued)
Many-to-one association
A single kernel-level thread is created in a process by the kernel and all
user level threads created in a process by the thread library are associated
with this kernel-level thread
Provides an effect similar to mere user-level threads
One-to-one association
Each user-level thread is permanently mapped into a kernel-level thread
Provides an effect similar to mere kernel-level threads
Many-to-many association
Permits a user-level thread to be mapped into different kernel-level
threads at different times
It provides parallelism and low overhead of switching
Case Studies of Processes and Threads
Processes in Unix
Threads in Solaris

Processes in Unix
Data Structures
Unix uses two data structures to hold control data about
processes
proc structure
Holds scheduling related data
Always held in memory
u area (user area)
Holds data related to resource allocation and signal handling
Needs to be in memory only when the process is executing

Processes in Unix (continued)
Types of Processes
User processes
Execute user computations
Associated with the users terminal
Daemon processes
Detached from the users terminal
Run in the background and perform functions on a system-wide basis
Vital in controlling the computational environment of the system
Kernel processes
Execute the code of the kernel
Concerned with background activities of the kernel like swapping
Process Creation and Termination
The system call fork creates a child process and sets up its
context
It allocates a proc structure for the newly created process and
marks its state as ready, and also allocates a u area for the
process
The kernel keeps track of the parentchild relationships using
the proc structure
fork returns the id of the child process

Process Creation and Termination (continued)
After booting, the system creates a process init

This process creates a child process for every terminal
connected to the system
After a sequence of exec calls, each child process starts running
the login shell
When a programmer indicates the name of a file from the
command line, the shell creates a new process that executes
an exec call for the named file, in effect becoming the primary
process of the program
Thus the primary process is a child of the shell process
Process Creation and Termination (continued)
The shell process now executes the wait system call to wait for
end of the primary process of the program
Thus it becomes blocked until the program completes, and
becomes active again to accept the next user command
If a shell process performs an exit call to terminate itself, init
creates a new process for the terminal to run the login shell

Process States
Unix permits a user process to create child processes and to

synchronize its activities w.r.t its child processes
Unix uses two distinct running states.
User running and Kernel running states
A user process executes user code while in the user running state,
and kernel code while in the kernel running state
A process Pi can wait for the termination of a child process
through the system call wait

Process States (continued)
A process Pi can terminate itself through the exit system call

exit (status_code)
The kernel saves the status code in the proc structure of Pi ,
closes all open files, releases the memory allocated to the
process, and destroys its u area
The proc structure is retained until the parent of Pi destroys it
The terminated process is dead but it exists, hence it is called a
zombie process

Processes in Unix (continued)

Threads in Solaris
Solaris is a Unix 5.4 based OS

Uses three kinds of entities to govern concurrency and
parallelism within a process:
User threads
Light weight processes (LWPs)
Provides parallelism within a process
User threads are mapped into LWPs by thread libraries
Kernel threads

Threads in Solaris (continued)

Threads in Solaris (continued)
Solaris originally provided a hybrid thread model that actually

supported all three association methods of hybrid threads
This model has been called the M N model
Solaris 8 continued to support this model and also provided an
alternative 1 : 1 implementation, which is equivalent to kernel-
level threads
Use of the 1 : 1 model led to simpler signal handling
It also eliminated the need for scheduler activations, and provided
better scalability
Hence the M N model was discontinued in Solaris 9
Interacting Processes An Advanced Programmer View of Processes
The processes of an application interact with one another to

coordinate their activities or to share some data.

Interacting Processes
Processes that do not interact are independent processes

Process synchronization is a generic term for the techniques
used to delay and resume processes to implement process
interactions

Race Condition
Uncoordinated accesses to shared data may affect consistency

of data
Consider processes Pi and Pj that update the value of ds
through operations ai and aj , respectively:
Operation ai : ds := ds + 10; Let fi(ds) represent its result
Operation aj : ds := ds + 5; Let fj(ds) represent its result
What situation could arise if they execute concurrently?

An Example of Race Condition
Race conditions
in cases 2 and 3

An Example of Race Condition (continued)

Race Condition (continued)
Race conditions are prevented by ensuring that operations ai

and aj do not execute concurrently
This is called mutual exclusion
Data access synchronization is coordination of processes to
implement mutual exclusion over shared data

Operating Systems, by Dhananjay Dhamdhere
6.73 Copyright 2008
Critical Sections
Mutual exclusion is implemented by using critical sections (CS)

of code
Using CSs causes delays in operation of processes

Process must not execute for too long inside CS
Process must not make system calls while in the CS that might put it
in blocked state
Kernel must not preempt a process that is engaged in executing a CS
We use a dashed box in the code to mark a CS
6.74 Copyright 2008
Critical Sections (continued)

6.75 Copyright 2008
Properties of a Critical Section Implementation
The progress and bounded wait properties together prevent

starvation
Control Synchronization

Interacting Processes (continued)
Message passing is implemented through system calls
The signals mechanism is implemented along the same lines as

interrupts

10EC65 Operating Systems - Process Management

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

10EC65 Operating Systems - Process Management

Încărcat de

Drepturi de autor:

Formate disponibile

Operating Systems

A process is an execution of a program

A program is a passive entity that does not perform any action

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

The program consists of a main program and a set of functions

Shrishail Bhat, AITM Bhatkal

The OS initiates an execution of a program by creating a

Shrishail Bhat, AITM Bhatkal

Processes are a means to achieve concurrent execution of a

An OS provides the following operations to implement

Shrishail Bhat, AITM Bhatkal

Processes of an application need to interact with one another

Shrishail Bhat, AITM Bhatkal

Parallelism: quality of occurring at the same time

Shrishail Bhat, AITM Bhatkal

In the OS view, a process is an execution of a program

Shrishail Bhat, AITM Bhatkal

When a process is scheduled, the CPU executes instructions in

Shrishail Bhat, AITM Bhatkal

Accordingly, a process comprises six components:

Shrishail Bhat, AITM Bhatkal

The OS view of a process consists of two parts:

Shrishail Bhat, AITM Bhatkal

Also called process context

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

A PCB is a kernel data structure that contains information

Shrishail Bhat, AITM Bhatkal

The kernel uses four fundamental functions to

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

A state transition for a process is a change in its state

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

A system contains two processes P1 and P2

Shrishail Bhat, AITM Bhatkal

OS needs additional states to describe processes suspended

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

The PCB contains all information pertaining to a process that is

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

Context save function:

Shrishail Bhat, AITM Bhatkal

An OS contains two processes P1 and P2, with P2 having a

Functions 1, 3, and 4 in this example collectively perform

The following events occur during the operation of an OS:

Shrishail Bhat, AITM Bhatkal

7. I/O completion event: An I/O operation completes

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

The actions of the kernel when process Pi requests an I/O operation

P1 initiates I/O operation on d

Shrishail Bhat, AITM Bhatkal

Shrishail Bhat, AITM Bhatkal

A thread is an alternative model of program execution

Shrishail Bhat, AITM Bhatkal

Process Pi has three threads represented by wavy lines

Shrishail Bhat, AITM Bhatkal

A TCB is analogous to the PCB and stores the following

Shrishail Bhat, AITM Bhatkal

When a thread is created, it is put in the ready state because