0% found this document useful (0 votes)
74 views25 pages

Basic Concepts - Scheduling Criteria - Scheduling Algorithms - Scheduling in BSD UNIX

This document discusses CPU scheduling concepts and algorithms. It covers the basics of CPU bursts and scheduling criteria like utilization, throughput and waiting times. It then describes common scheduling algorithms like first-come first-served, shortest-job-first, priority scheduling, round robin and multilevel queue scheduling. The goal of scheduling is to optimize criteria like waiting times, response times and throughput.

Uploaded by

Pritesh Singh
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
74 views25 pages

Basic Concepts - Scheduling Criteria - Scheduling Algorithms - Scheduling in BSD UNIX

This document discusses CPU scheduling concepts and algorithms. It covers the basics of CPU bursts and scheduling criteria like utilization, throughput and waiting times. It then describes common scheduling algorithms like first-come first-served, shortest-job-first, priority scheduling, round robin and multilevel queue scheduling. The goal of scheduling is to optimize criteria like waiting times, response times and throughput.

Uploaded by

Pritesh Singh
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 25

CPU Scheduling

• Basic Concepts
• Scheduling Criteria
• Scheduling Algorithms
• Scheduling in BSD UNIX

Fred Kuhns ( ) 1
Basic Concepts

• 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

Fred Kuhns ( ) 2
Alternating CPU And I/O Bursts

Fred Kuhns ( ) 3
Histogram of CPU-burst Times

Fred Kuhns ( ) 4
CPU Scheduler
• Selects from the Ready processes in memory
• CPU scheduling decisions occur when 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.

Fred Kuhns ( ) 5
Dispatcher
• Dispatcher module gives control of the
CPU to the process selected by the
short-term scheduler; this involves:
– switching context
– switching to user mode
– jumping to the proper location in the user
program to restart that program
• Dispatch latency – time it takes for the
dispatcher to stop one process and
start another running.

Fred Kuhns ( ) 6
Scheduling Criteria
• CPU utilization – Percent time CPU busy
• Throughput – # of processes that
complete their execution per time unit
• Turnaround time –time to execute a
process: from start to completion.
• Waiting time –time in 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)
Fred Kuhns ( ) 7
Optimization Criteria

• Max CPU utilization


• Max throughput
• Min turnaround time
• Min waiting time
• Min response time

Fred Kuhns ( ) 8
First-Come, First-Served (FCFS)
• Example:
Process Burst Time
P1 24
P2 3
P3 3
• Assume processes arrive as: P1 , P2 , P3
The Gantt Chart for the schedule is:
P1 P2 P3

0 24 27 30

• Waiting time for P1 = 0; P2 = 24; P3 = 27


• Average waiting time: (0 + 24 + 27)/3 = 17
Fred Kuhns ( ) 9
FCFS Scheduling (Cont.)
Suppose processes arrive as: P2 , P3 , P1 .
• The Gantt chart for the schedule is:
P2 P3 P1

0 3 6 30

• Waiting time for P1 = 6; P2 = 0; P3 = 3


• Average waiting time: (6 + 0 + 3)/3 = 3
• Much better than previous case.
• Convoy effect or head-of-line blocking
– short process behind long process
Fred Kuhns ( ) 10
Shortest-Job-First (SJR) Scheduling
• Process declares its CPU burst length
• Two schemes:
– non-preemptive – once CPU assigned, process
not preempted until its CPU burst completes.
– Preemptive – if a new process with CPU burst
less than remaining time of current, preempt.
Shortest-Remaining-Time-First (SRTF).
• SJF is optimal – gives minimum average
waiting time for a given set of processes.

Fred Kuhns ( ) 11
Example of Non-Preemptive SJF
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (non-preemptive)
P1 P3 P2 P4

0 3 7 8 12 16

• Average waiting time


– = (0 + 6 + 3 + 7)/4 - 4
Fred Kuhns ( ) 12
Example of Preemptive SJF
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4

• SJF (preemptive)
P1 P2 P3 P2 P4 P1

0 2 4 5 7 11 16

• Average waiting time


– = (9 + 1 + 0 +2)/4 - 3
Fred Kuhns ( ) 13
Determining Next CPU Burst
• Can only estimate the length.
• Can be done by using the length of
previous CPU bursts, using exponential
averaging.

1. tn  actual lenght of nthCPU burst


2.  n 1  predicted value for the next CPU burst
3.  , 0    1
 n 1   tn  1    n .
4. Define :

Fred Kuhns ( ) 14
Examples of Exponential Averaging
  =0
 n+1 = n
– Recent history does not count.
  =1
– n+1 = tn
– Only the actual last CPU burst counts.
• If we expand the formula, we get:
n+1 =  tn+(1 - )  tn -1 + …
+(1 -  ) j  tn -1 + …
+(1 -  ) n=1 tn 0
  and (1 - ) are <= 1, so each successive
term has less weight than its predecessor.
Fred Kuhns ( ) 15
Priority Scheduling
• Priority associated with each process
• CPU allocated to process with highest priority
– Preemptive or non-preemptive
– Example - SJF: priority scheduling where priority
is predicted next CPU burst time.
• Problem: Starvation
– low priority processes may never execute.
• Solution: Aging
– as time progresses increase the priority of
the process.
Fred Kuhns ( ) 16
Round Robin (RR)
• Each process assigned a time quantum,
usually 10-100 milliseconds. After this
process moved to end of the Ready Q
• n processes in ready queue, time quantum =
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.
• Performance
– q large  FIFO
– q small  q must be large with respect to
context switch, otherwise overhead too high.
Fred Kuhns ( ) 17
Example: RR, Quantum = 20
Process Burst Time
P1 53
P2 17
P3 68
P4 24
• The Gantt chart is:
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162

• Typically, higher average turnaround than SJF,


but better response.
Fred Kuhns ( ) 18
Small Quantum
Increased Context Switches

Fred Kuhns ( ) 19
Turnaround Time Versus Quantum

Fred Kuhns ( ) 20
Multilevel Queue
• Ready queue partitioned into separate
queues:
– foreground (interactive) and background (batch)
• Each queue has its own scheduling algorithm,

foreground – RR, background – FCFS


• Scheduling between queues.
– Fixed priority scheduling; Possible starvation.
– Time slice: i.e., 80% to foreground in RR, 20% to
background in FCFS
Fred Kuhns ( ) 21
Multilevel Queue Scheduling

Fred Kuhns ( ) 22
Multilevel Feedback Queue
• A process can move between the various
queues; aging can be implemented this way.
• Multilevel-feedback-queue scheduler defined
by:
– number of queues
– scheduling algorithms for each queue
– method used to select when upgrade process
– method used to select when demote process
– method used to determine which queue a process
will enter when that process needs service

Fred Kuhns ( ) 23
Multilevel Feedback Queues

Fred Kuhns ( ) 24
Example: Multilevel Feedback Queue
• Three queues:
– Q0 – time quantum 8 milliseconds
– Q1 – time quantum 16 milliseconds
– Q2 – FCFS
• Scheduling
– A new job enters queue Q0 served by FCFS.
Then job receives 8 milliseconds. If not
finished in 8 milliseconds, moved to Q1.
– At Q1 job served by FCFS. Then receives 16
milliseconds. If not complete, preempted
and moved to Q2.
Fred Kuhns ( ) 25

You might also like