Dynamic Storage-Allocation Problem
How to satisfy a request of size n from a list of
free holes?
First-fit: Allocate the first hole that is big
enough
Best-fit: Allocate the smallest hole that is
big enough; must search entire list, unless
ordered by size
Produces the smallest leftover hole
Worst-fit: Allocate the largest hole; must
First-fit
and best-fit
also
search
entirebetter
list than worst-fit in terms
Produces
the largest
leftover
hole
of
speed and
storage
utilization
Data Structures:
Free list & allocation list
First Fit :
i/p:- required memory?? 50
First-fit: Allocate the first hole that is
big enough
After first fit
Best Fit :
i/p:- required memory?? 90
Best-fit: Allocate the smallest hole
that is big enough; must search entire
list, unless ordered by size
After Best Fit
Worst Fit :
i/p:- required memory?? 90
Worst-fit: Allocate the largest hole;
must also search entire list
After Worst Fit
De allocation
De allocates the requested process
from allocation list to free list
i/p:- process no
Eg: p1
After de allocation
Process
a program in execution, which forms
the basis of all computation
process execution must progress in
sequential fashion
Program is passive entity, process is
active
Program becomes process when
executable file loaded into memory
Process Scheduling
Maximize CPU use, quickly switch processes
onto CPU for time sharing
Process scheduler selects among available
processes for next execution on CPU
Maintains scheduling queues of processes
Job queue set of all processes in the system
Ready queue set of all processes residing in
main memory, ready and waiting to execute
Device queues set of processes waiting for an
I/O device
Processes migrate among the various queues
CPU Scheduler
Selects from among the processes in ready queue,
and allocates the CPU to one of them
Queue may be ordered in various ways
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 nonpreemptive
All other scheduling is preemptive
.Consider access to shared data
.Consider preemption while in kernel mode
.Consider interrupts occurring during crucial OS activities
Nonpreemptive scheduling
Under nonpreemptive scheduling,
once the CPU has been allocated to a
process,
the process keeps the CPU until it
releases the CPU either by terminating
or by switching to the waiting state.
Scheduling Criteria
CPU utilization keep the CPU as busy as possible
Throughput # of processes that complete their
execution per time unit
Turnaround time amount of time to execute a
particular process
Waiting time amount of time a process has been
waiting in the ready queue
Response time amount of time it takes from
when a request was submitted until the first
response is produced, not output (for time-sharing
environment)
Scheduling Algorithm Optimization
Criteria
Max CPU utilization
Max throughput
Min turnaround time
Min waiting time
Min response time
First-Come, First-Served (FCFS)
Scheduling
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:
P1
P2
24
P3
27
30
Waiting time for P1 = 0; P2 = 24; P3 = 27
Average waiting time: (0 + 24 + 27)/3 = 17
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order:
P2 , P3 , P1
The Gantt chart for the schedule is:
P2
P3
P1
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
30
Shortest-Job-First (SJF) Scheduling
Associate with each process the
length of its next CPU burst
Use these lengths to schedule the
process with the shortest time
SJF is optimal gives minimum
average waiting time for a given set
of processes
The difficulty is knowing the length of the
next CPU request
Could ask the user
Example of SJF
P1
P2
P3
P4
SJF
ProcessArr
0.0 6
2.0 8
4.0 7
5.0 3
scheduling chart
P4
iva eBurst Time
P3
P1
3
P2
16
24
Average waiting time = (3 + 16 + 9 + 0) / 4 = 7
Determining Length of Next CPU Burst
Can only estimate the length
should be similar to the previous
one
Then pick process with shortest
predicted next CPU burst
Preemptive version called
shortest-remaining-time-first
Example of Shortest-remainingtime-first
Now we add the concepts of varying arrival times and
preemption to the analysis
ProcessA arri Arrival TimeT Burst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
Preemptive SJF Gantt Chart
P1
P4
P2
P1
10
Average waiting time = 6.5 msec
P3
17
26
Example of Shortest-remainingtime-first
ProcessA
arri Arrival TimeT Burst Time
P1 0
P2 1
P3 2
P4 3
Repeat the following until clk < sumburst
For process 1 to n
Check P[i].atime<clk and p[i].rtime>0
Copy the process p[i] into ready queue rq[j]
Select min from ready queue.( for sjf min(burst) for
priority min(pri)
If preempting the process in execution print gantt
chart
Do process scheduling
Decrement rq[j].rtime of processing process
Increment rq[<>j]. wtime of other processes in rq
Increment clk
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)
Preemptive
Nonpreemptive
Equal priority processes are scheduled in FCFS order
Problem Starvation low priority processes may
never execute
Solution Aging as time progresses increase the
priority of the process
Example of Priority Scheduling
ProcessA arri Burst TimeT Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2
Priority scheduling Gantt Chart
P1
P5
P2
1
P3
16
Average waiting time = 8.2 msec
P4
18
19
Round Robin (RR)
Each process gets a small unit of CPU time (time
quantum q), usually 10-100 milliseconds. After
this time has elapsed, the process is preempted
and added to the end of the ready queue.
If there are n processes in the ready queue and
the time quantum is q, then each process gets
1/n of the CPU time in chunks of at most q time
units at once. No process waits more than (n-1)q
time units.
Timer interrupts every quantum to schedule next
process
Performance
q large FIFO
q small q must be large with respect to
context switch, otherwise overhead is too high
Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
The Gantt chart is:
P1
0
P2
4
P3
7
P1
10
P1
14
P1
18
22
P1
P1
26
30
Typically, higher average turnaround than SJF, but better
response
q should be large compared to context switch time
q usually 10ms to 100ms, context switch < 10 usec
