Operating S
ystem C
onceptsPROCESS CONCEPT
Process – a program in execution; process execution must progress in sequential fashion.
Two types of processes are running concurrently in the system
i. Operating system processes—executing system code
ii. User processes—executing user code
PROCESS CONCEPT
A process includes: text section—program code program counter—value representing current
activity and contents of processor’s registers data section—contains global variables heap—memory that is dynamically allocated
during process run time. stack--the process stack is to store temporary
data such as function parameters, return address, and temporary variables.
PROCESS IN MEMORY
Operating S
ystem C
onceptsPROGRAM VS. PROCESS
PROGRAM PROCESS
Consist of Instruction in any Programming Language
Instruction Executions in machine code
Is Static Object Dynamic Object
Reside In Secondary Storage Main Memory
Span of Time Unlimited Limited
Entity Passive Active
Type Executable File Executable file loaded into memory
Operating S
ystem C
onceptsPROCESS STATE
As a process executes, it changes state new: The process is being created. running: The Process is 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.
Operating S
ystem C
onceptsPROCESS STATE
Operating S
ystem C
onceptsPROCESS STATE
New Ready The OS creates a process and prepare the process to
be executed, then the process moved the process in to “ Ready” Queue.
Ready Running When it is time to select a process to run, the OS
selects one of the jobs from the ready queue and move the process from ready state to running state.
Running Terminated When the execution of a process has completed, the
OS terminates that process from running state. Sometimes OS terminates the process due to some
other reason for e.g Time limit exceeded, memory unavailable, access violation, protection error, I/O failure, data misuse etc.
Operating S
ystem C
onceptsPROCESS STATE
Running Ready When the time slot of the processor expired If the processor received any interrupt signal
Running Waiting A process is put into the waiting state, if the process
need an event to occur, or it requires event from an i/o device.
Waiting Ready A process in the blocked state is moved to the ready
state when the event for which it was waiting, is completed.
PROCESS CONTROL BLOCK(PCB)
PROCESS CONTROL BLOCK(PCB) Each process is represented in the operating system by
a process control block:i. Process State—represents the state of processii. Program Counter—indicates the address of next
instruction to be executediii. CPU registers—includes contents of all process-
centric registersiv. CPU scheduling algorithms—includes process
priority and pointers to scheduling queuesv. Memory management information—memory
allocated to the processvi. Accounting information—CPU used, clock time
elapsed since start, time limitsvii. I/O status information—I/O devices allocated to
process, list of open files
PROCESS CREATION When a user initiates to execute a program, the OS
creates a process to represent the execution of this program.
The source code is translated in to object code(machine code) with the help of translator (compiler).
The relocatable object codes are converted to absolute programs(i.e. executable programs) by linker.
The absolute programs are converted to executable programs running in memory by loaders.
Then the processor executes this program. The program executed by the processor is said to be a
process. The process consist of the machine code image of the
program in memory plus PCB (Process Control Block).
Opera
ting S
yste
m C
once
pts
CREATING A PROCESS Initialize the process control block
Process ID, parent ID Set program counter and stack pointer to appropriate
value State is usually set to Ready
Assign a unique process ID Allocate memory for the process
Can use defaults for amount of memory May get values from creating process Link to shared memory (clipboard)
Set links so it is in the appropriate queue Create other data structures
Memory, files, accounting
Opera
ting S
yste
m C
once
pts
SPAWNING A process creating a new process is named as parent
process. While the created process is called child process. The method of creating a new process from parent
process is said to be a “Spawning”. A child process could itself spawn a process resulting
in a tree of a process. Most operating systems identify processes according
to a unique process identifier(or pid), which is typically an integer number.
Opera
ting S
yste
m C
once
pts
PROCESS TERMINATION The process terminate from the running state include
so many reasons as follows: Time slot expired Memory boundary violation I/O Failure Parent termination Parent request Invalid instruction
Opera
ting S
yste
m C
once
pts
When an interrupt occurs, the system needs to save the current context of the process running on the CPU so that it can restore that context when its processing is done, essentially suspending the process and then resuming it.
The context is represented in the PCB of the process; it includes the value of the CPU registers, the process state and memory management.
Thus, we perform state save of current process and state restore for another process to perform context switch.
CONTEXT SWITCH
CONTEXT SWITCH Steps to take to switch processes
Save context (registers, etc.) Update state of current process
Change Running to Blocked/Ready/Exit Move the control block to the appropriate queue Select another process to execute Move the control block from the appropriate queue Update the control block of the selected process to
Running Update necessary memory-management structures Restore the context (registers, etc.) of the newly selected
process
Opera
ting S
yste
m C
once
pts
Operating S
ystem C
oncepts
CPU SWITCHES FROM PROCESS TO PROCESS
INTERPROCESS COMMUNICATION Processes executing concurrently in the OS
may be either:i. Independent Processes—which cannot
affect or be affected by other processes executing in the system and it does not share any data
ii. Cooperating Processes—which can affect or be affected by the other processes executing in the system and also shares the data.
Cooperating processes require an interprocess communication(IPC) mechanism that will allow them to exchange data and information.
WHY ARE COOPERATING PROCESSES REQUIRED?
i. Information sharing—when users are interested in same piece of information(e.g. shared file)
ii. Computation speedup—a single task is broken into several subtasks and each of them are executing in parallel for better speed
iii. Modularity—dividing the system functions into separate process or threads
iv. Convenience—Even an individual user may work on many tasks at the same time. For instance, a user may be editing, printing and compiling in parallel
COMMUNICATION MODELS
(a) Message passing. (b) shared memory.
SHARED MEMORY
It requires the communicating processes to establish a region of shared memory.
Different processes share same address space
The processes are also responsible for ensuring that they are not writing to the same location simultaneously.
MESSAGE PASSING
In this mechanism the processes communicate and synchronize without sharing the same address space
They communicate via passing messages to each other.
This mechanism is used in distributed environment where the communicating processes may reside on different computers connected by a network.
Example: chat program used on World Wide Web
THREAD A process is divided into number of light
weight process, each light weight process is said to be a thread.
The thread has a program counter that keeps the tracks of which instructions to execute next.
It has registers which hold its current working variables.
It has stack which contains the execution history.
If a process has multiple threads of control, it can perform more than one task at a time.
THREAD EXAMPLE
A web browser might have one thread which display image or text while another thread retrieves data from the network.
In word processor, programmer may open a file, responding to keystrokes(one thread), text is automatically formatting (another thread), the text is automatically saved in the disk (another thread).
Opera
ting S
yste
m C
once
pts
THREAD
HEAVY WEIGHTED THREAD LIGHT WEIGHTED THREAD
THE THREAD MODEL
Items shared by all threads in a process Items private to each thread
26
THREADSTHE THREAD MODEL (1)
(a) Three processes each with one thread(b) One process with three threads 27
WORD DOCUMENT
A word processor with three threads28
WEB SERVER EXAMPLE
A multithreaded Web server 29
BENEFITS Responsiveness:
Multi threading in an interactive application may allow a program to continue running even if part of it is blocked or is performing a lengthy operation thereby increasing the responsiveness to user.
For e.g a multi threaded web browser could still allow user interaction in one thread while an image is being loaded in another thread.
Resource Sharing: Threads share memory and the resources of the process
to which they belong which allows several different threads of activity all within same address space.
Opera
ting S
yste
m C
once
pts
BENEFITS Economy:
Allocating a memory and resources for process creation may be costly. Threads share same resources of the process to which they belong, it is more economical to create and context switch threads.
Utilization of multiprocessor architectures: Implementations of thread can be greatly increased in a
multiprocessor architecture, where each thread may be running in parallel on a different processor.
Opera
ting S
yste
m C
once
pts
THREADTwo level threads:
User level threadKernel level thread
Opera
ting S
yste
m C
once
pts
USER LEVEL THREAD User threads are supported above the kernel and
are implemented by thread library at the user level. The library support for thread creation, scheduling,
management is without support of kernel. Kernel is unaware of user level threads, all threads
creation and scheduling are done in user space without the need for kernel intervention.
User Level threads are fast to create and manage. It has drawbacks for e.g. if the kernel is single
threaded, then any user level thread that blocks system call will cause the entire process to block even if other threads are available to run within the application.
Opera
ting S
yste
m C
once
pts
KERNEL LEVEL THREAD Kernel level threads are supported directly by
the operating system. The kernel performs thread creation,
scheduling, and management in kernel space. Kernel threads are generally slower to create
and manage as compared to user threads. Since the kernel is managing the threads, if a
thread performs a blocking a system call, the kernel can schedule another thread in the application for execution.
In multiprocessor environment, the kernel can schedule threads on different processors..
Opera
ting S
yste
m C
once
pts
Operating S
ystem C
onceptsMULTITHREADING MODELS
Many-to-One
One-to-One
Many-to-Many
MANY TO ONE MODEL
The many-to-one model maps many user level threads to one kernel level thread.
Thread management is done in user space, it is efficient.
But if the thread makes blocking a system call, the entire process will be blocked.
Only one thread can access kernel at a time, multiple threads are unable to run in parallel on multiprocessors.
MANY TO ONE MODELO
pera
ting S
yste
m C
once
pts
ONE TO ONE MODEL
The one-to-one model maps each user thread to a kernel thread.
It provides concurrency than many to one model by allowing another thread to run when a thread makes a blocking system call.
It also allows multiple threads to run in parallel multiprocessors.
The only drawback of this type of model is that creating a user thread requires creating the corresponding kernel thread which creates a burden on the performance of the application.
Operating S
ystem C
onceptsONE TO ONE MODELS
MANY TO MANY MODEL
The many to many model multiplexes many user level threads to a smaller or equal number of kernel level threads.
The number of kernel level threads may be specific to either a particular application or a particular machine.
True concurrency is not gained because the kernel can schedule only one thread at a time.
Developer can create as many user threads as necessary, and the corresponding kernel threads can run in parallel on multiprocessor.
Operating S
ystem C
onceptsMANY-TO-MANY MODEL
CPU SCHEDULER There are three main schedulers:
Long Term scheduler Short Term scheduler Medium Term scheduler
Opera
ting S
yste
m C
once
pts
CPU SCHEDULERO
pera
ting S
yste
m C
once
pts
New Ready Running
Blocked Exit
Long Term Scheduler
Short Term Scheduler
Medium Term Scheduler
I/O Wait
LONG TERM SCHEDULER The function of the long term scheduler is to select
the job from the pool of jobs and load this job into main memory.
So, it is also called a long term scheduler. The long term scheduler selects the job from the
spool disk and load these jobs into a ready queue in the main memory.
A ready queue is a queue, which is one type of data structure.
In a ready queue jobs are loaded through front and deleted from rear.
Opera
ting S
yste
m C
once
pts
P1
P2
P6
P0
P9
P7
P8
Rear
Deletion
Front
Insertion
SHORT TERM SCHEDULER The function of the short term scheduler is to select
a job from the ready queue and gives the control of the CPU to that processor with the help of dispatcher.
Short term scheduler is some times known as a CPU scheduler.
The method of selecting a process from ready queue depends on CPU scheduling algorithm.
Opera
ting S
yste
m C
once
pts
The primary distinction between these two scheduler lies in frequency of execution.
The short term scheduler must select new process from CPU frequently(in milliseconds).
If it takes 10 milliseconds to decide to execute a process for 100 milliseconds, then 10/(100+10) = 9 percent of the CPU is being used(wasted) just for scheduling.
The long term scheduler executes much less frequently; minutes may separate the creation of one new process and the next.
The long term scheduler controls the number of processes in memory .
The long term scheduler may only be invoked when the process leaves the system.
MEDIUM TERM SCHEDULER If process request an I/O in the middle of the
execution, then the process swapped out from the main memory and loaded into waiting queue.
When the I/O operation completed, then the job swapped in from waiting queue to ready queue(swapping).
These two jobs are performed by medium term scheduler.
Opera
ting S
yste
m C
once
pts
NEED OF CPU SCHEDULING Maximum CPU utilization obtained with
multiprogramming CPU–I/O Burst Cycle – Process execution consists of a
cycle of CPU execution and I/O wait. CPU burst distribution
Opera
ting S
yste
m C
once
pts
CPU SCHEDULINGO
pera
ting S
yste
m C
once
pts
CPU SCHEDULING To select the processes in memory that are ready to
execute, and allocates the CPU to one of them. CPU scheduling decisions may take place when a
process:1.Switches from running to waiting state.2.Switches from running to ready state.3.Switches from waiting to ready.4.Terminates.
Scheduling under 1 and 4 is non preemptive. All other scheduling is preemptive. In Non- Preemptive scheduling, once the CPU is
assigned to a process, the processor do not release it until the completion of that process.
In Preemptive Scheduling, CPU can release the process in the middle of the execution also(incurs cost while sharing data).
Opera
ting S
yste
m C
once
pts
CPU SCHEDULERO
pera
ting S
yste
m C
once
pts
Pool of
jobs in a
diskx
Dispatcher
I/O
CPULong TermScheduler
Short Term Scheduler
END
Medium TermScheduler
I/O waiting Queues
Medium Term Scheduler
DISPATCHER A dispatcher is a module, it connects the CPU to the
process selected by the short term scheduler. The main function of the dispatcher is switching, it
means switching the CPU from one process to another process.
The another function of the dispatcher is “jumping to the proper location in the user program and ready to start execution.
The dispatcher should be fast, because it is invoked during each and every process switch.
The time taken by dispatcher to stop one process and start another process is known as “dispatch latency”.
The degree of multiprogramming is depend on the dispatch latency. If the dispatch latency is increasing, then the degree of multiprogramming decreases.
Opera
ting S
yste
m C
once
pts
CPU SCHEDULING CRITERIA Through put:
How many jobs are completed by the CPU with in a time period.
For Long Process Process/Hour For Short Process Process/Minute
CPU Utilization: This is the percentage of time that the processor is busy
in CPU utilization. In single user and real time system, this criteria is less
important the time sharing system.
Opera
ting S
yste
m C
once
pts
CPU SCHEDULING CRITERIA Waiting Time:-
Waiting is the sum of the periods spent waiting by a process in the ready queue.
CPU scheduling algorithm having least average waiting time, it is said to be the best algorithm.
Response Time: Response time is the time duration between the
submission and first response.
Turn Around Time: The time interval between the submission of the process
and time of the completion is the turnaround time. Turn around time is the sum of the periods spent waiting
to get into memory, waiting in the ready queue executing on the CPU, and doing I/O.
Turn around Time= Waiting Time in ready queue + executing Time + Waiting time in waiting queue for I/O
Opera
ting S
yste
m C
once
pts
CPU SCHEDULING ALGORITHMS CPU scheduling algorithms decides which of
the processes in the ready queue is to be allocated to the CPU.
There are many different CPU scheduling algorithms, Out of them, which algorithms maximize the CPU utilization and throughput and minimize turn around time, waiting time, and response time are the best of all algorithms.
Opera
ting S
yste
m C
once
pts
CPU SCHEDULING ALGORITHMS Non Preemptive CPU scheduling algorithms:
First Come First Serve (FCFS) Shortest Job First Scheduling Priority Scheduling Shortest Remaining Time First(SRTF) Round Robin Scheduling (RR) Multilevel Queue Scheduling Multi level feedback queues
Opera
ting S
yste
m C
once
pts
FIRST COME FIRST SERVE (FCFS)
“The Process that requests the CPU first holds the CPU first”.
“ The process that enters in the ready queue first is served first”. O
pera
ting S
yste
m C
once
pts
Process Burst Time P1 24
P2 3
P3 3
Suppose that the processes arrive in the order: P1 , P2 , P3
The Gantt Chart for the schedule is:
Waiting time for P1 = 0; P2 = 24; P3 = 27 Average waiting time: (0 + 24 + 27)/3 = 17
P P P1 2 3
0 24 3027
FIRST COME FIRST SERVE (FCFS)
Suppose that the processes arrive in the order: P2 , P3 , P1
The Gantt chart for the schedule is:
Waiting time for P1 = 6; P2 = 0; P3 = 3 Average waiting time: (6 + 0 + 3)/3 = 3 Much better than previous case Convoy effect - short process behind long
process Consider one CPU-bound and many I/O-bound
processes
FIRST COME FIRST SERVE (FCFS)
P 1
0 3 6 30
P 2 P 3
Average Turn Around Time: Turn Around Time= Finish Time – Arrival Time
Average Waiting Time: Waiting Time= Starting Time- Arrival Time
Average Response Time: Response Time= First Response-Arrival Time
SHORTEST JOB FIRST(SJF) “The Process having the smallest CPU burst,
CPU is assigned to that process next”. If two process have same burst time, FCFS is
used to break the tie. Example: O
pera
ting S
yste
m C
once
pts
Process Burst Time (in Milliseconds)
P1 5
P2 24
P3 16
P4 10
P5 3
SHORTEST JOB FIRST (SJF)
Average Turn Around Time: Turn Around Time= Finish Time – Arrival Time P1 = 8 – 0 = 8 P2 = 58 – 0 = 58 P3 = 34 – 0 = 34 P4 = 18 – 0 = 18 P5 = 3 – 0 = 3
= ( 8 + 58 + 34 + 18 + 3 ) / 5
= 123 / 5
= 24.2 milliseconds
Opera
ting S
yste
m C
once
pts
P5 P1 P4 P3 P2
0 3 8 18 34 58
SHORTEST JOB FIRST (SJF)
Average Waiting Time: Waiting Time= Starting Time- Arrival Time P1 = 3 – 0 = 3 P2 = 34 – 0 = 34 P3 = 18 – 0 = 18 P4 = 8 – 0 = 8 P5 = 0– 0 = 0
= ( 3 + 34 + 18 + 8 + 0) / 5
= 63 / 5
= 12.6 milliseconds
Opera
ting S
yste
m C
once
pts
P5 P1 P4 P3 P2
0 3 8 18 34 58
SHORTEST JOB FIRST (SJF)
Average Response Time: Response Time= First Response Time- Arrival Time P1 = 3 – 0 = 3 P2 = 34 – 0 = 34 P3 = 18 – 0 = 18 P4 = 8 – 0 = 8 P5 = 0– 0 = 0
= ( 3 + 34 + 18 + 8 + 0) / 5
= 63 / 5
= 12.6 milliseconds
Opera
ting S
yste
m C
once
pts
P5 P1 P4 P3 P2
0 3 8 18 34 58
SHORTEST JOB FIRSTSJF is non preemptive algorithm.It is having least average waiting time,
average turn around time and average response time.
Issues:Knowing the length of the next CPU burst time, it is difficult .
It is optimal algorithm, it can not be implemented at the level of short term CPU scheduling.
‘Aging’ is the another problem. Big jobs are waiting so much time for the CPU.
Opera
ting S
yste
m C
once
pts
SHORTEST REMAINING TIME FIRST(SRTF)
It is a preemptive scheduling algorithm.Chooses the process that has the shortest
remaining processing time.When new process joins a ready queue, the
short term scheduler compare the remaining time of executing process and new process. If the new process has the least CPU burst time, the scheduler select that job and connect to CPU, otherwise continue the old process .
Opera
ting S
yste
m C
once
pts
Now we add the concepts of varying arrival times and preemption to the analysis
ProcessA Arrival TimeTBurst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5 Preemptive SJF Gantt Chart
Average waiting time = [(10-1-0)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5 msec
P 4
0 1 26
P 1 P 2
10
P 3P 1
5 17
SHORTEST REMAINING TIME FIRST (SRTF)O
pera
ting S
yste
m C
once
pts
Process Arrival Time CPU Burst Time
P1 0 7
P2 2 4
P3 4 1
P4 5 4
P1 P2 P3 P2 P4 P1
0 2 4 5 7 11 16
Preemptive SJF Gantt Chart
Average waiting time = [(11-2-0)+(5-2-2)+(4-4)+(7-5)]/4 = [9+1+0+2]/4 = 3 msec
SHORTEST REMAINING TIME FIRST (SRTF)O
pera
ting S
yste
m C
once
pts
Process Arrival Time Burst Time
P1 0 3
P2 2 6
P3 4 4
P4 6 5
P5 8 2
P1 P2 P3 P5 P2 P4
0 3 4 8 10 15 20
Average waiting time = [(0-0)+(10-1-2)+(4-4)+(15-6)+(8-8)]/5 = [0+7+0+9+0]/5 = 3.2 msec
Opera
ting S
yste
m C
once
pts
P1 P2 P3 P5 P2 P4
0 3 4 8 10 15 20
Average Turn Around Time: Turn Around Time= Finish Time – Arrival Time P1 = 3 – 0 = 3P2 = 15 – 2 = 13P3 = 8 – 4 = 4P4 = 20 – 6 = 14P5 = 10 – 8 = 2= ( 3 + 13 + 4 + 14 + 2) / 5= 36 / 5= 7.2 milliseconds
SHORTEST REMAINING TIME FIRST (SRTF)
SHORTEST REMAINING TIME FIRST (SRTF)O
pera
ting S
yste
m C
once
pts
Process Arrival Time CPU Burst Time
P1 0 10
P2 0 3
P3 2 3
P4 3 4
P2 P3 P4 P1
0 3 6 10 20
PRIORITY SCHEDULING A priority number (integer) is associated with each
process The CPU is allocated to the process with the highest
priority (smallest integer highest priority). SJF is a special case of priority scheduling where
priority is the predicted next CPU burst time. Equal priority processes are scheduled in FCFS order. Two types of priorities:
Internal-time limits, memory requirements, no. of open files
External (external to OS)-importance of process, the type and amount of funds being paid for computer use, etc
Opera
ting S
yste
m C
once
pts
It can be preemptive or non preemptive. When the process arrives in ready queue, the
priority is compared with the running process. Problem Starvation – low priority processes
may never execute.It may run when the computer is lightly
loaded or lose all unfinished low-priority processes.
Solution Aging - as time progresses increase the priority of the process.
Example : If priorities range from 127(low) to 0(high), we could increase the priority of a waiting process by 1 every 15 minutes.
PRIORITY SCHEDULING
PRIORITY SCHEDULINGO
pera
ting S
yste
m C
once
pts
Process CPU Burst Time
Priority
P1 6 2
P2 12 4
P3 1 5
P4 3 1
P5 4 3
P4 P1 P5 P2 P3
0 3 9 13 25 26
Average Turn Around Time : (P1+P2+P3+P4+P5)/5 = (9+25+26+3+13)/5
= 76/5 = 15.2 milliseconds
PRIORITY SCHEDULINGO
pera
ting S
yste
m C
once
pts
P4 P1 P5 P2 P3
0 3 9 13 25 26
Average Waiting Time : (P1+P2+P3+P4+P5)/5 = (3+13+25+0+9)/5
= 50/5 = 10 milliseconds
PRIORITY SCHEDULINGO
pera
ting S
yste
m C
once
pts
Process CPU Burst Time
Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2
ROUND ROBIN SCHEDULING ALGORITHM Preemptive in nature Preemption based on time slices or time quantum Time quantum between 10 and 100 milliseconds All user processes treated to be at the same priority Ready queue treated as a circular queue New processes added to the rear of the ready queue Preempted processes added to the rear of the ready
queue Scheduler picks up a process from the head of the queue
and dispatches it with a timer interrupt set after the time quantum If (CPU burst < 1 quantum ) process releases CPU
voluntarily Timer interrupt results in context switch and the process
is put at the rear of the ready queue
Opera
ting S
yste
m C
once
pts
ROUND ROBIN Example: Time quantum = 5 milliseconds
Opera
ting S
yste
m C
once
pts
Process Burst Time (in Milliseconds)
P1 30
P2 6
P3 8
P1 P2 P3 P1 P2 P3 P1 P1 P1 P1
0 5 10 15 20 21 24 29 34 39 44
Average Turn Around Time: Turn Around Time= Finish Time – Arrival Time P1 = 44 – 0 = 44P2 = 21 – 0 = 21P3 = 24 – 0 = 24 = (44+21+24)/3 = 89/3 = 29.66 milliseconds
ROUND ROBIN SCHEDULING ALGORITHM
Average Waiting Time: Waiting time = start time – arrival time
P1 = 0 + (15-5) + (24-20) = 14 P2 = 5 + (20-10) = 15 P3 = 10 + (21-15) = 16 = (14+15+16)/3 = 45/3 = 15 milliseconds
Opera
ting S
yste
m C
once
pts
P1 P2 P3 P1 P2 P3 P1 P1 P1 P1
0 5 10 15 20 21 24 29 34 39 44
ROUND ROBIN SCHEDULING ALGORITHM
Average Response Time:Response Time= First Response Time- Arrival Time
P1 = 0 P2 = 5 P3 = 10 = (0+5+10)/3 = 15/3 = 5 milliseconds
Opera
ting S
yste
m C
once
pts
P1 P2 P3 P1 P2 P3 P1 P1 P1 P1
0 5 10 15 20 21 24 29 34 39 44
Operating S
ystem C
onceptsTIME QUANTUM AND CONTEXT SWITCH TIME
Operating S
ystem C
onceptsMULTILEVEL QUEUE
Ready queue is partitioned into separate queues:foreground (interactive)background (batch)
Each queue has its own scheduling algorithm, foreground – RRbackground – FCFS
The process are permanently assigned to one queue, generally based on some property of the process, such as memory size, process priority, or process type.
Scheduling must be done between the queues. Fixed priority scheduling; (i.e., serve all from foreground
then from background). Possibility of starvation. Time slice – each queue gets a certain amount of CPU time
which it can schedule amongst its processes; i.e., 80% to foreground in RR
20% to background in FCFS
Operating S
ystem C
onceptsMULTILEVEL QUEUE SCHEDULING
No process in the batch queue, could run unless the queues for the system processes, interactive processes and interactive editing processes were all empty.
If an interactive editing process entered the ready queue while a batch process was running, the batch process would be preempted.
MULTILEVEL QUEUE
Operating S
ystem C
onceptsMULTILEVEL FEEDBACK QUEUE
When the multilevel queue scheduling algorithm is used, processes are permanently assigned to a queue when they enter the system.
For eg. :If there are separate queues for foreground and background processes, then processes do not move from one queue to the other, since processes do not change their foreground or background nature.
This setup has the advantage of low scheduling overhead, but it is inflexible.
Operating S
ystem C
onceptsMULTILEVEL FEEDBACK QUEUE
The multilevel feedback queue algorithm allows a process to move between the queues.
Used to separate process with different CPU – Burst characteristics.
If a process uses too much CPU time, it will be moved to next low priority queue.
A process that waits too long in a lower queue may be moved to a higher priority queue.
Used to prevent starvation.
MULTILEVEL FEEDBACK QUEUERQ0
RQ1
RQ2
MULTILEVEL FEEDBACK QUEUE The scheduler first executes all processes in RQ0. Only when RQ0 is empty, it will execute the process
of RQ1. Similarly, the process of RQ2 is executed when RQ0
and RQ1 is empty. A process arrives for RQ1 will preempts a process in
RQ2. A process in RQ1 will be preempted by a process
arriving for RQ0. A process in RQ0 is given time quantum 8
milliseconds, if it does not finish with in 8 milliseconds, it is moved to the tail of the RQ1 and the process in RQ1 execute only if the RQ0 has no process..
MULTILEVEL FEEDBACK QUEUE A process at the head of a the RQ1 is given a time
quantum of 16 milliseconds. If it does not complete with in the time quantum, it is moved to the tail of the RQ2.
The process in RQ2 are run on FCFS basis. The process in the RQ2 will execute only if the RQ0
and RQ1 are empty. The main advantage of this algorithm is , shorter
process will complete quickly and a longer process need not to wait much time in the ready queue and will gradually draft downward.
MULTILEVEL FEEDBACK QUEUE In general, a multilevel feedback queue scheduler is
defined by the following parameters:1. The number of queues.2. The scheduling algorithm for each queue.3. The method used to determine when to upgrade a
process to a higher-priority queue4. The method used to determine when to demote a
process to a lower-priority queue5. The method used to determine which queue a
process will enter when that process needs service.
CONCURRENCY In a single processor multi programming system,
processes are inter leaved in time to yield the appearance of simultaneous execution.
Actual parallel processing is not achieved. Though Certain amount of overhead involved in
switching back and forth between processes, interleaved execution provides major benefits in processing efficiency and in program structuring.
In a multiprocessor system, it is possible not only to interleave processes but to overlap them.
EVALUATION OF ALGORITHM Deterministic modeling – takes a particular
predetermined workload and defines the performance of each algorithm for that workload.
Queuing models Simulators
EVALUATION OF CPU SCHEDULERS BY SIMULATION
MULTILEVEL FEEDBACK QUEUE Interleaving
Interleaving and Overlapping
P1P2P3
P1P2P3
PROCESS SYNCHRONIZATION
PROCESS COORDINATION
Cooperating process Shared memory Two or more processes access the same
address space simultaneously. The processes are also responsible for
ensuring that they are not writing to the same location simultaneously.
PRODUCER CONSUMER PROBLEM
A producer process produces information that is consumed by a consumer process.
Eg : a compiler may produce assembly code, which is consumed by an assembler. The assembler, in turn, may produce object modules, which are consumed by the loader.
Eg: in client server paradigm, a Web Server produces HTML files and images, which are consumed(read) by the client Web Browser.
So for the producer and consumer process to run concurrently we must have a buffer of items that can be filled by the producer and emptied by the consumer.
This buffer is resided in the region of memory that is shared by producer and consumer processes.
The producer and consumer process must be synchronized, so that the consumer does not try to consume an item that has not yet been produced.
PRODUCER CONSUMER PROBLEM
Two types of buffer can be used:1. Unbounded buffer—no limit for size. The
consumer has to wait for new items, but the producer can always produce new items.
2. Bounded buffer—fixed size buffer. The consumer must wait if the buffer is empty, and the producer must wait if the buffer is full.
#define BUFFER_SIZE 10typedef struct {. . .
} item;
item buffer[BUFFER_SIZE];int in = 0;int out = 0;
BOUNDED BUFFER – PRODUCER
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;
}
BOUNDED BUFFER - CONSUMER
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 */
}
CRITICAL SECTION PROBLEM
Consider system of n processes {p0, p1, … pn-1} Each process has critical section segment of
code Process may be changing common variables,
updating table, writing file, etc When one process in critical section, no other may
be in its critical section Critical section problem is to design protocol
to solve this Each process must ask permission to enter
critical section in entry section, may follow critical section with exit section, then remainder section
General structure of process Pi
CRITICAL SECTION PROBLEM
SOLUTION REQUIREMENTS
1. Mutual Exclusion - If process Pi is executing in its critical section, then no other processes can be executing in their critical sections
2. Progress - If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely
3. Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is grantedAssume that each process executes at a nonzero speed No assumption concerning relative speed of the n
processes
RACE CONDITION
At a given time, many kernel-mode processes may be active in the operating system.
Eg. : consider a kernel data structure which maintains the list of all open files in the system. This list must be modified when a new file is opened or closed. If two processes were to open files simultaneously, the separate updates to this list could result in race condition.
Other kernel data structures can be for maintaining memory allocation, for maintaining process lists and for interrupt handelling.
RACE CONDITION
Two general approaches are used to handle critical sections in operating systems
1. Preemptive kernels—allows process to be preempted while it is running in kernel mode.
2. Non preemptive kernels—does not allow a process running in kernel mode to be preempted.
Non preemptive mode will be free form race conditions.
CONCURRENCY Issues in single processor multiprogramming system: The sharing of global resources is fraught with peril.
For e.g if two processes both make use of the same global variable, and both perform reads and writes on that variable, then the order in which the various reads and writes are executed is critical.
It is difficult for the operating system to manage the allocation of resources optimally. For e.g. process A may request use of a particular I/O
channel and then be suspended before using that channel.
If the OS locks the channel and prevents its use by other processes, inefficiency results.
It becomes difficult to locate programming error because results are typically reproducible.
CONCURRENCY Single processor multi programming system:-
Procedure echo; var out,in: character; begin
input (in, keyboard)out:=in;output (out, display)
end;
SINGLE PROCESSOR MULTIPROGRAMMING SYSTEM
Process P1 invokes the echo procedure and is interrupted immediately after the conclusion of the input function. At this point, the most recently entered character x, is stored in variable in.
Process P2 is activated and invokes the echo procedure, which runs to conclusion, inputting, and then displaying a single character y on the screen.
Process P1 is resumed. By this time, the value x has overwritten in in and therefore lost, Instead, in contains y, which is transferred to out and displayed.
Reason: Shared global variable in
Solution: Process P1 invokes the echo procedure and is
interrupted immediately after the conclusion of the input function. At this point, the most recently entered character x is stored in variable in.
Process P2 is activated and invokes the echo procedure. Because P1 is still inside the echo procedure, although currently suspended, P2 is blocked from entering the procedure. Therefore, P2 is suspended while awaiting the availability of the echo procedure.
At some later time, process P1 is resumed and completes execution of echo. The proper character x is displayed.
When P1 exists echo, this removes the block on P2. When P2 is later resumed, the echo procedure is successfully invoked.
SINGLE PROCESSOR MULTIPROGRAMMING SYSTEM
CONCURRENCY
Process P1Input (in, keyboard)..Out:=inOutput(out, keyboard)..
Process P2..Input(in, keyboard)Out:= in
Output(out, keyboard)
Multiprocessor System
OS CONCERNS The OS must be able to keep track of the various
active processes. It can be done by PCB. The OS must allocate and deallocate various
resources to each process. These resource can be: Processor time Memory Files I/O devices
The OS must protect the data and physical resources of each process against unintended interference by other process.
The results of a process must be independent of the speed at which the execution is carried out relative to the speed of other concurrent processes.
PROCESS INTERACTION Processes unaware of each other.
Processes are not working together, the OS needs to be concerned about Competition for resources. For e.g. two independent applications may both want process to the same disk or file or printer. The Os must regulate these accesses.
Process indirectly aware of each other. These are processes that are not necessarily aware of
each other by name but that share access to some object, such as an I/O buffer. Such processes exhibit cooperation in sharing the common object.
Process directly aware of each other. These are processes that are able to communicate with
each other by name and that are designed to work jointly on some activity. Such Processes exhibit cooperation.
PROCESS INTERACTIONDegree of Awareness
Relationship Influence that One process has on the other
Potential Control
Problems
Process Unaware of each other.
Competition •Results of one process independent of the action of others.•Timing of Process may be affected.
•Mutual Exclusion•Deadlock•Starvation
Process indirectly aware of each other (Shared Object)
Cooperation by sharing
•Results of one process may depend on information obtained from others.•Timing of Process may be affected.
•Mutual Exclusion•Deadlock•Starvation
Process directly aware of each other (have communication primitives available to them)
Cooperation by communication
•Results of one process may depend on information obtained from others.•Timing of Process may be affected.
•Deadlock•Starvation
REQUIREMENTS FOR MUTUAL EXCLUSION
To satisfy mutual exclusion
Software Apporach-Dekker’s Algorithm- Peterson’s Algorithm
Hardware Approach-Disable Interrupts-Machine Instructions
Support by OS-Semaphore - Counting - Binary-Monitors.
DEKKER’S ALGORITHM- FIRST APPROACH
Critical Section
Turn=1
P0 P1
FIRST APPROACH
P0 P1while (turn != 0) /**/; while (turn != 1) /**/;critical section critical sectionturn = 1; turn = 0;Shared variable turn indicates who is
allowed to enter next, can enter if turn = me
On exit, point variable to other processDeadlock if other process never enters
FIRST APPROACHIssues: Processes must strictly alternate in their use of their
critical section; the speed of execution is decided by the slower of two processes.
If P0 uses its critical section only once per hour, but p1 would like to use its critical section at a rate of 1000 times per hour, p1 is forced to adopt the speed of P0.
If one process is failed inside its critical section, the other process is permanently blocked.
DEKKER’S ALGORITHM- SECOND APPROACH
Critical Section
1
Turn
P0 P1
Flag[0]
Flag[1]
SECOND ATTEMPT
P0 P1while (flag[1]) /**/; while (flag[0]) /**/;flag[0] = true; flag[1] = true; <critical section> <critical section>flag[0] = false; flag[1] = false;Each process has a flag to indicate it is in
the critical sectionFails mutual exclusion if processes are in
lockstep
/* i is the process; j is the other process */
while (true)
{
while (state[j] == inside); /* is the other one inside? */
state[i] = inside; /* get in and flip state */
<<< critical section >>>
state[i] = outside; /* revert state */
<<< code outside critical section >>>
}
Consider the following trace:
1. P0 finds (state[1] == outside)
2. The scheduler forces a context-switch
3. P1 finds (state[0]==outside)
4. P1 sets (state[1] = inside)
5. P1 enters the critical section
6. The scheduler forces a context-switch
7. P0 sets (state[0] = inside)
8. P0 enters the critical section
9. Both P0 and P1 are now in the critical section
With both processes in the critical section, the mutual exclusion criteria has been violated.
P0 P1while (state[1]==outside); while (state[0]==outside);state[0] = inside; state[1] = inside; <critical section> <critical section>state[0] = outside; state[1] =
outside;
SECOND ATTEMPT Each process can examine the other’s blackboard
but can not alter it. When a process wishes to enter its critical section, it
periodically check’s the blackboard until it finds “false” written on it, indicating that the other process is not in its critical section.
It then quickly goes to its own igloo, and writes “true” on the blackboard.
The process may now proceed to its critical section. When it leaves its critical section, it alters its
blackboard to “false”.
2ND ATTEMPT Issues:
If a process is fails inside its critical section, or after setting its flag to true just before entering its critical section, then the other process is permanently blocked.
Proposed solution is not independent of relative speeds of process execution.
THIRD ATTEMPT Busy Flag Modified
P0 P1flag[0] = true; flag[1] = true;while (flag[1]==true) /**/; while (flag[0]==true) /**/;critical section critical sectionflag[0] = false; flag[1] = false;
/* i is this process; j is the other process */
while (true)
{
state[i] = interested; /* declare interest */
while (state[j] == interested); /* wait while other
process is using the resource */
<<< critical section >>>
state[i] = not interested; /* we're done */
<<< code outside critical section >>>
}
P0 P1state[0] = interested; state[1] = interested;while (state[1]==interested) /**/; while (state[0]==interested) /**/; critical section critical sectionstate[0] = not interested; state[1] = not interested;
Consider the following trace:
1. P0 sets state[0] to interested
2. A context-switch occurs
3. P1 sets state[1] to interested
4. P1 loops in while
5. A context-switch occurs
6. P0 loops in while
7. Both P0 and P1 loop forever. This is the Deadlock.
THIRD ATTEMPT Once P0 has set flag[0] to “true”, P1 can not enter
its critical section until after P0 has entered and left its critical section.
It could be that P1 is already in its critical section when P0 sets its flag. In that case, P0 will be blocked by the while statement until P1 has left its critical section.
The same reasoning applies from the point of view of P1.
It guarantees mutual exclusion. Issue:
If both processes set their flags to “true” before either has executed the while statement, then each will think that other has entered its critical section.
The result is deadlock.
4TH ATTEMPT Same as attempt 3, but now we periodically clear and reset our
own flag while waiting for other one, to avoid deadlock. Sets flag to false for small periods of time to yield control Both process could set flags to same values at same time Would require both process to execute in sequence (unlikely but
possible) Deadlock occurs when both processes simultaneously insist on
entering their CS We can solve the problem by requiring a process to give up its
intention to enter its CS if it discovers that it is contending with the other process
flag[0] = true; flag[1] = true;while ( flag[1] ) while ( flag[0] ){ {
flag[0] = false; flag[1] = false;delay delayflag[0] = True; flag[1] = true;
} }critical section critical sectionflag[0] = false; flag[1] = false;
/* i is this process; j is the other process */
while (true)
{
state[i] = interested; /* declare interest */
while (state[j] == interested) /* wait while other process is using the resource */
{
state[i] = not interested;
delay
state[i] = interested;
}
<<< critical section >>>
state[i] = not interested; /* we're done */
<<< code outside critical section >>>
}
Consider the following trace:
1. P0 sets state[0] to interested
2. A context-switch occurs
3. P1 sets state[1] to interested
4. P1 loops in while
5. A context-switch occurs
6. P0 loops in while
7. P0 executes in the critical section
8. P1 executes in the critical section
P0 P1state[0] = interested; state[1] = interested;while (state[1]==interested) /**/; while (state[0]== interested) /**/; { { state[0] = not interested; state[1] = not interested; delay delay state[0] = interested; state[1] = interested;} } critical section critical sectionstate[0] = not interested; state [1] = not interested;
4TH ATTEMPT- P0 sets flag[0] to true.- P1 sets flag[1] to true.- P0 checks flag[1].- P1 checks flag[0]- P0 sets flag[0] to false- P1 sets flag[1] to false- P0 sets flag[0] to true- P1 sets flag[1] to true This sequence could be extended indefinitely, and neither
process could enter its critical section. It is not deadlock because any alteration in the relative
speed of the two processes will break this cycle and allow one to enter into critical section.
The deadlock is solved, but there is still the possibility of starvation, in the case of perfect interleaving in executing while
DEKKER’S ALGORITHM-CORRECT SOLUTION
Critical Section
1
Turn
P0 P1Flag[0] Flag[1
]
Turn
CORRECT SOLUTIONProcedure P0
Begin
Repeat
flag[0]= True
While flag[1] do if turn=1 then
begin
flag[0]=false
while turn=1
{do nothing}
flag[0]=true
end
<critical section>
turn=1
flag[0]=False
<remainder>
Forever
End
Procedure P1
Begin
Repeat
flag[1]=true
while flag[0] do if turn=0 then
begin
flag[1]=false
while turn=0
{do nothing}
flag[1]=true
end
<critical section>
turn=0
flag[1]=false
<remainder>
Forever
End
while (true)
{
state[i] = interested; /* declare interest */
while (state[j]) /* If the other one's interested */
{
if (turn == j) /* and it is its turn */
{
state[i] = not interested; /* we stay uninterested */
while (turn == j); /* ...until our turn */
state[i] = interested;
}
}
<<< critical section >>>
turn = j; /* forces alternation if both are interested */
state[i] = not interested; /* Need to ask again if I want again */
<<< code outside critical section >>>
}
Mutual exclusion is not violated. Consider the case where one process enters the critical section before the other. This process sets its flag to true. The other process will loop in the while loop until the other process sets its own flag in its exit section. So the second process can't enter until the first exits.
Progress isn't violated. The turn variable and the inner while loop will be sure that one of the two process gets into the critical section.
Bounded waiting is satisfied, because as a process exits, it gives the other process the turn. The other process can immediately enter. And since the other process's flag is set, the first process can't re-enter first.
PETERSON’S ALGORITHMProcedure P0
Begin
Repeat
Flag[0]=true
Turn=1
while (flag[1] and turn=1)
{do nothing}
<critical section>
flag[0]= False
<remainder>
Forever
End
Procedure P1
Begin
Repeat
Flag[1]=true
Turn=0
while (flag[0] and turn=0)
{ do nothing}
<critical section>
flag[1]=false
<remainder>
Forever
End
/* i is the process; j is the other process */ while (true) {
state[i] = interested; /* declare interest */ turn = j; /* give chance to other */
while (state[j] == interested && turn == j); <<< critical section >>>
state[i] = not interested; /* we're done */
<<< code outside critical section >>> }
1) Mutual exclusion - state[0] and state[1] can both be true, but turn can only be 0 or 1. Therefore only one of the two critical sections can be executed. The other will spin wait.
2) Progress - If process 0 is in the critical section, then turn = 0 and state[0] is true. Once it has completed it's critical section (even if something catastrophic happens), it must set state[0] to false. If process 1 was spin waiting, it will now free as state[0] != true.
3) Bound-waiting - If Process 1 is waiting, Process 0 can only enter it's critical section once, before process 1 is given the green light, as explained in #2.
EXAMPLE 1Process 0 Process 1
i = 0, j = 1 i = 1, j = 0state[0] = interestedturn = 1check (state[1] = TRUE and turn = 1)- Condition is false because state [1] = FALSE- Since condition is false, no waiting in while loop- Enter the critical section- Process 0 happens to lose the processor
state [1] = TRUEturn = 0check (state[0] = TRUE and turn = 0)- Since condition is true, it keeps busy waiting until it
loses the processor-Process 0 resumes and continues until it finishes in the critical section- Leave critical sectionstate[0] = FALSE-Start executing the remainder - Process 0 happens to lose the processor check (state[0] = TRUE and turn = 0)
- This condition fails because state [0] = FALSE- No more busy waiting- Enter the critical section
EXAMPLE 2Process 0 Process 1i=0, j=1 i=1, j=0state [0] = TRUEturn = 1- Lose processor here
state [1] = TRUEturn = 0check (state[0] = TRUE and
turn = 0)- Condition is true so
Process 1 busy waits until it loses the processor
check (state[1] = TRUE and turn = 1)- This condition is false because turn = 0- No waiting in loop- Enters critical section
EXAMPLE 3Process 0 Process 1i=0, j=1 i=1, j=0state[0] = TRUE- Lose processor here
state[1] = TRUEturn = 0check (state[0] = TRUE and turn = 0)- Condition is true so, Process 1 busy waits until it loses the processor
turn = 1check (state[1] = TRUE and turn = 1)- Condition is true so Process 0 busy waits until it loses the processor
check (state[0] = TRUE and turn = 0)- The condition is false so, Process 1 enters the
critical section
HARDWARE SUPPORT• Disable Interrupts
– Only works for uni processors– Prevent Process from being interrupted– Primitives are defined by kernel to enable and disable the interrupts.– Mutual exclusion in guaranteed.– Delays response to external events <disable interrupts>
<critical section> <enable interrupts> <remainder>
Issues-- The efficiency of execution could be degraded because
the processor is limited in in its ability to interleave the programs.
-- Do not work on multiprocessor architecture.
HARDWARE SUPPORT• Special Instructions
• Access to a memory location excludes any other access to the same location.
• Machine instructions to carry out two actions automatically.• Read• Write
• When instruction exchanges the contents of a register with that of a memory location, access to a memory location is blocked for any other instruction referencing that location.
• Advantages:• Applicable to any number of processors.• Simple and easy to verify• Can be used to support multiple critical sections where each critical
section can be defined by its own variable.
HARDWARE SUPPORT• Disadvantages
• Busy waiting is employed, while a process is waiting for access to a critical section, it continues to consume processor time.
• Starvation is possible. When a process leaves a critical section and more than one process is waiting, the selection of a waiting process is arbitrary. So some process could indefinitely be denied access.
• Deadlock is possible.• For e. g P1 executes the special instruction (testset, exchange) and enter into
critical section. • P1 is then interrupted to give the processor to P2 which has higher priority.• If P2 now attempts to use the same resources as P1, it will be denied access
because of the mutual exclusion mechanism. Thus, it will go into a busy waiting loop.
• However, P1 will never be dispatched because it is of lower priority than another ready process, P2.
SEMAPHORE• A semaphore is a higher level mechanism for
controlling concurrent access to a shared resources.• Instead of using operations to read and write a
shared variable, a semaphore encapsulates the necessary shared data, and allows access only by a restricted set of operations.
• A semaphore S is an integer variable that, apart from initialization, is accessed only through two standard atomic operations: wait() and signal()
TYPES OF SEMAPHORE 2 types:1. Binary Semaphore—It allows only one process at a time
to access the shared resource. It have states full and empty. They are called mutex locks as they provide mutual exclusion.
do{
wait(mutex);//critical section
signal(mutex);//remainder section
}while(TRUE);
2. Counting Semaphore—it allows N>1 processes to access the shared resource. It uses the counter variable S. The counter is initialized to N, with S = 0 corresponding to the full state i.e. all the resources are in use.
SEMAPHORE Wait(): a process performs a wait operation to tell the
semaphore that it wants exclusive access to the shared resource.
If the semaphore is empty, then the semaphore enters the full state and allows the process to continue its execution immediately.
If the semaphore is full, then the semaphore suspends the process (and remembers that the process is suspended).
The wait() operation decrements the semaphore value. If the value becomes negative, then the process which needs to use resource is blocked until the count becomes greater than 0.
wait(S){ while (s <=0); //no operation
S--;}
SEMAPHORE Signal(): a process performs a signal operation to
inform the semaphore that it is finished using the shared resource.
If there are processes suspended on the semaphore, the semaphore wakes one of the up.
If there are no processes suspended on the semaphore, the semaphore goes into the empty state.
The signal() operation increments the semaphore value. If the value is 0 or negative, then the process is blocked by a wait() operation is unblocked.
signal(S){ S++;}
SEMAPHORE EXAMPLEProcess P1 Process P2Statement1; wait(synch);signal(synch); Statement2;
Suppose we require statement2 to be executed only after statement1 has completed. Then we can allow P1 and P2 to share a common semaphore synch, initialized to 0.
Because synch is initialized to 0, P2 will execute statement2 only after P1 has invoked signal(synch), which is after statement1 hase been executed.
SPINLOCK SEMAPHORE Removes busy waiting and the waste of CPU cycles is reduced. When a process executes the wait() operation and finds that the
semaphore value is not positive, it must wait. However, rather engaging in busy waiting, the process can block itself using block() operation.
It goes to waiting state and another process is selected for execution.
When signal() operation occurs the process is again restarted by wakeup() operation.
It goes from waiting state to ready state. If the semaphore value is negative, its magnitude is the number of
processes waiting on that semaphore.
SEMAPHOREtypedef struct
{int value;struct process *list;
} semaphore; void wait(semaphore *S)
{S.value--;if(S.value<0){
add this process to S.list;block();
}}void signal(semaphore *S){
S.value++;if (S.value <= 0){
remove process P from S.L;wakeup(P);
}}
SEMAPHORE• The block operation suspends the process that
invokes it.• The wakeup(P) operations resumes the execution of a blocked
process.• These 2 operations are provided by OS as a system call.• The critical aspect of semaphores is that they are executed
atomically. We must guarantee that no two processes can execute wait and signal operations on the same semaphores at the same time.
• In a uniprocessor system, we can simply inhibit interrrupts during the time the wait and signal operations are executing.
• In a multiprocessor system, inhibiting interrupts does not work.• It is not completely eliminating busy waiting with semaphores, but
it occurs rarely and it it occurs, it is for short time.
DEADLOCK AND STARVATION Deadlock – two or more processes are waiting
indefinitely for an event that can be caused by only one of the waiting processes
Let S and Q be two semaphores initialized to 1 P0 P1
wait(S); wait(Q);
wait(Q); wait(S);
... ...
signal(S); signal(Q);
signal(Q); signal(S);
Starvation – indefinite blocking A process may never be removed from the semaphore queue in which it is
suspended
CLASSICAL SYNCHRONIZATION PROBLEMS
• The Readers and Writers Problem• Producer/Consumer Problem or Bounded Buffer Problem• The dining philosopher problem
PRODUCER-CONSUMER PROBLEMn buffers, each can hold one item Semaphore mutex initialized to the value 1 Semaphore full initialized to the value 0 Semaphore empty initialized to the value n The full and empty semaphores count the number
of empty and full buffers.
PRODUCER-CONSUMER PROBLEM The structure of the producer process
do {
... /* produce an item in next_produced */
...
/* wait for an empty space */ wait(empty);
/* store the item */ wait(mutex);
/*lock the item*/
... /* add next produced to the buffer */
...
/* report the new full slot */ signal(mutex);
signal(full);
} while (true);
PRODUCER-CONSUMER PROBLEM The structure of the consumer process
Do {
/* wait for a stored item */ wait(full);
/* remove the item */ wait(mutex);
... /* remove an item from buffer to next_consumed */
...
/* report the new empty slot */ signal(mutex);
/* consume it */ signal(empty);
... /* consume the item in next consumed */
... } while (true);
READER-WRITER PROBLEM A data set is shared among a number of concurrent
processes Readers – only read the data set; they do not perform any
updates Writers – can both read and write
Problem – allow multiple readers to read at the same time Only one single writer can access the shared data at the
same time Several variations of how readers and writers are
considered – all involve some form of priorities Shared Data
Data set Semaphore rw_mutex initialized to 1 Semaphore mutex initialized to 1 Integer read_count initialized to 0
READER-WRITER PROBLEM The structure of a writer process do { wait(rw_mutex);
... /* writing is performed */
...
signal(rw_mutex);
} while (true);
READER-WRITER PROBLEM The structure of a reader process do {
wait(mutex); read_count++; if (read_count == 1)
wait(rw_mutex);
signal(mutex);
... /* reading is performed */
...
wait(mutex); read count--; if (read_count == 0)
signal(rw_mutex);
signal(mutex);
} while (true); We must check when leaving the reading routine whether we were the
last to leave. It does not stand to reason that the same reader that locked the database is the one to unlock it. We may be the first reader but other readers join while we are reading, and they are still reading after we leave.
THE DINING-PHILOSOPHER PROBLEM
Philosophers spend their lives alternating thinking and eating Don’t interact with their neighbors, occasionally try to pick up 2 chopsticks (one
at a time) to eat from bowl Need both to eat, then release both when done
In the case of 5 philosophers Shared data
Bowl of rice (data set) Semaphore chopstick [5] initialized to 1
THE DINING-PHILOSOPHER PROBLEM The structure of Philosopher i:
do { wait (chopstick[i]);
wait (chopStick[(i + 1) % 5]);
// eat
signal (chopstick[i]); signal (chopstick[(i + 1) % 5]);
// think
} while (TRUE);
THE DINING-PHILOSOPHER PROBLEM Incorrect use of semaphore operations:
signal (mutex) …. wait (mutex)
wait (mutex) … wait (mutex)
Omitting of wait (mutex) or signal (mutex) (or both)
Deadlock and starvation are possible.
MONITOR• Semaphores tend to require Wait/Signal operations
spread throughout the code• Monitor
– Local data variables only accessible within the monitor’s procedures– Enter by invoking one of the defined procedures– Only one process may be in the monitor at a time
• If two processes try to enter, one is forced to wait– A process may enter the monitor, then wait for a event to happen.
• While waiting, other processes can enter• Internal routines wait and signal
MONITORS High-level synchronization construct that allows the safe
sharing of an abstract data type among concurrent processes.
monitor monitor-name{
shared variable declarationsprocedure body P1 (…) {
. . .}procedure body P2 (…) {
. . .} procedure body Pn (…) {
. . .} {
initialization code}
}
MONITORS Suppose signal() operation is invoked by a process P, there exists a
suspended process Q. If suspended process Q is allowed to resume its execution, the
signaling process P must wait. Else P and Q would be active simultaneously within the monitor.
But process will continue its execution so two possibilities exists1. Signal and Wait—P either waits until Q leaves the monitor or
waits for another condition.2. Signal and continue—Q either waits until P leaves the monitor or
waits for another condition. The compromised solution is that when process P executes the
signal operation, it immediately leaves the monitor. And Q is immediately resumed.
MONITORS
DEADLOCK
DEADLOCK Definition
A process request the resources, the resources are not available at that time, so the process enter into the waiting state. The requesting resources are held by another waiting process, both are in waiting state, this situation is said to be a “deadlock”.
• Conditions for deadlock• Deadlock prevention• Deadlock avoidance• Deadlock detection• Recovery from deadlock
SYSTEM MODEL
System consists of resources Resource types R1, R2, . . ., Rm
CPU cycles, memory space, I/O devices
Each resource type Ri has Wi instances. Each process utilizes a resource as follows:
request use release
A process must request a resource before using it and must release the resource after using it. A process can request as many resource as required to carry out the task but the number of resource should be less than or equal to the available resources.
CONDITIONS FOR DEADLOCK(1) Mutual Exclusion
- It means resources are in non-sharable mode only.- It means only one process at a time can use a resource.- If some other process request the resource, the requesting process
must wait until the resources has been released.- For e.g Line Printer.
(2) Hold and Wait
- A process must holding at least one resource and is waiting to accquire additional resource that are currently being held by other processes.
(3) No preemption
- It means resources are not released in the middle of the work.
- They are released only after the process has completed its task.
CONDITIONS FOR DEADLOCK(4) Circular Wait
- P1 is waiting for R1is held by P2, P2 is waiting for R2 held by
P3, P3 is waiting for R4 held by P2, P2 waiting for resource R3
held by P1. It is said to be a circular wait.
P1R1P2R2P3R4P2R3
DEADLOCK PREVENTION• Deadlock prevention to take preventive methods before attacking
the deadlock.
(1) Mutual Exclusion- Sharable resources do not require mutual exclusive access so deadlock
can never occur. Eg. Read-Only files- Non-sharable resources does require mutual exclusion. - We can apply this condition by:
- “Convert all non sharable resources to sharable resource.”
- We can not apply this condition to all resources. For e. g printer.- We can not convert printer to sharable mode.
DEADLOCK PREVENTION(2) Hold and Wait
- Hold and wait condition is satisfied when a process requests a resource, it does not hold any other resource.
- We can apply the condition: “ Each process to request and allocate all its resources before it begins
execution”.
“ A process request the resources only when the process has none.”
- for e.g. a process wants to copy the data from a
tape drive to a disk file, and then take a printout.
- In first approach resource utilization is low.
- In second approach the process consists of tape drive and disk file. So It will first copy data from tape drive to disk file. Then it should release tape drive and demand for printer. So it is very time consuming.
- Another example, P1 to P100 are 100 processes. Each requires a printer
to complete their jobs. According to 1st protocol, system must consist
of 100 printers. So it is very difficult to implement.
DEADLOCK PREVENTION(3) No preemption
- “No preemption means resources are not released in the middle
of the processing of a resource.”
- A process request some resources, first check whether they are
available or not.
- If they are available, we allocate them.
- If they are not available, we check whether they are allocated to
some other process that is waiting for additional resources.
- If so, we preempt the desired resources from the waiting process
and allocate them to requesting process.
- If resources are not either available or held by a waiting process,
then the requesting process must wait.
-While it is waiting, some of its resources may be preempted, but only if another process requests them.
-A process can be restarted only when it is allocated the new resource it is requesting and recovers any resources that were preempted while it was waiting.
DEADLOCK PREVENTION(4) Circular wait
- Circular wait must not happen if we apply this solution:
- Numbering of all resources type should be done.
- Each process can request resources in an increasing order of the
enumeration.
- A process can initially request any number of instances of
resource type, say Ri. After that, the process can request the
instances of resource type Rj, if and only if F(Rj)>F(Ri).
- A process requests an instance of resource type Rj, it has
released any resource Ri such that F(Ri)>F(Rj).
- If these two protocols are used, then the circular wait can not
happen.
RESOURCE ALLOCATION GRAPH
A resource allocation graph is directed graph. It is used to represent the deadlock. It consist set of vertices V and edges E. Set V is partitioned into 2 types of
nodes: P={P1,P2…Pn}—set of active processes and R={R1,R2…Rn}—set of all resources
It has 2 edges:
request edge – directed edge Pi Rj
assignment edge – directed edge Rj Pi
Graph cycle: (P1R1P2R2P1) is deadlock. If the system is in the deadlock state then the resource allocation graph must
consist of cycles.
P1 P2
R1
R2
EXAMPLE OF A RESOURCE ALLOCATION GRAPH
RESOURCE ALLOCATION GRAPH WITH A DEADLOCK
GRAPH WITH A CYCLE BUT NO DEADLOCK
DEADLOCK AVOIDANCE Safe State—when the system consist of safe sequence <p1,p2,..pn> where for
every Pi and Pj , i<j.
Example : The system has 12 magnetic tape drives
Maximum Needs Current Needs
P1 10 5
P2 4 2
P3 9 2 Follow the sequence <P2,P1,P3> What if we first allocate 1 more resource to P3?
DEADLOCK AVOIDANCE
In this scheme, if a process request for resources the avoidance algorithm checks before the allocation of resources about the state of the system.
If the state is safe, the system allocate the resources to the requesting process otherwise do not allocate the resources. So taking care before allocation is said to be a deadlock avoidance.
Safe state means “No dead lock will occur”. Unsafe state means “Deadlock may or may not occur”.
Deadlock
Unsafe
Safe
AVOIDANCE ALGORITHMS
Single instance of a resource type Use a resource-allocation graph
Multiple instances of a resource type Use the banker’s algorithm
RESOURCE-ALLOCATION-GRAPH ALGORITHM Claim edge Pi Rj indicated that process Pj may request resource Rj;
represented by a dashed line Claim edge converts to request edge when a process requests a
resource Request edge converted to an assignment edge when the resource is
allocated to the process When a resource is released by a process, assignment edge reconverts
to a claim edge Resources must be claimed prior in the system If there is no cycle, safe state exists otherwise unsafe state exists.
BANKER’S ALGORITHM
Multiple instances
Each process must at prior claim maximum use
When a process requests a resource it may have to wait
When a process gets all its resources it must return them in a finite amount of time
DATA STRUCTURES FOR THE BANKER’S ALGORITHM
Available: Vector of length m indicates the number of available resources of each type. If available [j] = k, there are k instances of resource type Rj available
Max: n × m matrix, number of resources of each type currently allocated to each process. If Max [i,j] = k, then process Pi may request at most k instances of resource type Rj
Allocation: n × m matrix, number of resources of each type currently allocated to each process. If Allocation[i,j] = k then Pi is currently allocated k instances of Rj
Need: n × m matrix, remaining resources need of each process. If Need[i,j] = k, then Pi may need k more instances of Rj to complete its task
Need [i,j] = Max[i,j] – Allocation [i,j]
Let n = number of processes, and m = number of resources types.
SAFETY ALGORITHM1. Let Work and Finish be vectors of length m
and n, respectively. Initialize:Work = AvailableFinish [i] = false for i = 0, 1, …, n- 1
2. Find an i such that both: (a) Finish [i] = false(b) Needi WorkIf no such i exists, go to step 4
3. Work = Work + Allocationi
Finish[i] = truego to step 2
4. If Finish [i] == true for all i, then the system is in a safe state
RESOURCE-REQUEST ALGORITHM FOR PROCESS PI
Requesti = request vector for process Pi. If Requesti [j] = k then process Pi wants k instances of resource type Rj
1.If Requesti Needi go to step 2. Otherwise, raise error condition, since process has exceeded its maximum claim
2.If Requesti Available, go to step 3. Otherwise Pi must wait, since resources are not available
3.Pretend to allocate requested resources to Pi by modifying the state as follows:
Available = Available – Requesti;Allocationi = Allocationi + Requesti;Needi = Needi – Requesti;
If safe the resources are allocated to Pi
If unsafe Pi must wait, and the old resource-allocation state is restored
EXAMPLE OF BANKER’S ALGORITHM 5 processes P0 through P4;
3 resource types: A (10 instances), B (5instances), and C (7
instances) Snapshot at time T0:
Allocation Max AvailableA B C A B C A B C
P0 0 1 0 7 5 3 3 3 2
P1 2 0 0 3 2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3
EXAMPLE (CONT.)
The content of the matrix Need is defined to be Max – Allocation
NeedA B C
P0 7 4 3
P1 1 2 2
P2 6 0 0
P3 0 1 1
P4 4 3 1
The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria
EXAMPLE: P1 REQUEST (1,0,2)
Check that Request Available (that is, (1,0,2) (3,3,2) true
Allocation Need AvailableA B C A B C A B C
P0 0 1 0 7 4 3 2 3 0
P1 3 0 2 0 2 0
P2 3 0 2 6 0 0
P3 2 1 1 0 1 1
P4 0 0 2 4 3 1
Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2> satisfies safety requirement
Can request for (3,3,0) by P4 be granted?
Can request for (0,2,0) by P0 be granted?
DEADLOCK DETECTION When deadlock prevention and deadlock avoidance, both fails
then deadlock may occur. In such case :
1. We require an algorithm to determine whether the deadlock has occurred.
2. An algorithm to recover from deadlock.
DEADLOCK DETECTION- Detection mechanism of deadlocks for single instance of resource
type and multiple instance of resource type is different.- We can detect deadlock for single resource type by using wait-for-
graph.- Deadlock for multiple instance of resource is detected by
detection algorithm.- For a single instance of resource:
- A system is in deadlock state, if and only if the wait for graph contains cycles, so we can detect the deadlocks with cycles.
P1
P2
R1
R3
R2
R4
P3
DEADLOCK DETECTION
Wait-for Graph.
P1 P2 P3
P1R1P2
P2R3P1
P2R2P3
P3R4P2
RECOVERY FROM DEADLOCK1. Process Termination
1. Abort all deadlocked process.- Release all processes in the deadlock state, and start the allocation from the starting
point.- It is an expensive method.
2. Abort one by one process until the deadlock cycle is eliminated.- First abort the one of the processes in the deadlocked state, and allocate resources to
some other process to check whether the deadlock is broken or not..- If not then abort another process from the deadlocked state.- Continue this process until we recover form deadlock.
2. Resource Preemption1. Select Victim
- Select a victim resource form the deadlock state, and preempt that one.2. Rollback
- Rollback the processes and resources upto some safe state.3. Starvation
- A process or a resource can be picked as a victim only a finite number of times, it is
said to be starvation. The most common solution is to include the number of
rollbacks in the cost factor.