CPU SCHEDULING

CIS 505: Software Systems

OS Overview -- CPU Scheduling  How can OS schedule the allocation of CPU cycles to
processes/threads to achieve “good performance”?

 Overview of topics
o Issues in scheduling
o Basic scheduling algorithms

First-come First-served
Insup Lee
Round Robin

Shortest Job First
Department of Computer and Information Science

Priority based
University of Pennsylvania o Scheduling in Unix
o Real-time scheduling (Priority Inheritance)
CIS 505, Spring 2007

1 CIS 505, Spring 2007 CPU Scheduling 2

Scheduling Issues Scheduling Issues

 Application Profile:  Is preemption allowed?
o Non-preemptive scheduler does not use clock interrupts to stop a
o A program alternates between CPU usage and I/O process
o Relevant question for scheduling: is a program compute-bound
(mostly CPU usage) or I/O-bound (mostly I/O wait)  What should be optimized?
o CPU utilization: Fraction of time CPU is in use
 Multi-level scheduling (e.g., 2-level in Unix)
o Throughput: Average number of jobs completed per time unit
o Swapper decides which processes should reside in memory
o Turnaround Time: Average time between job submission (or command
o Scheduler decides which ready process gets the CPU next issue) and completion
 When to schedule o Waiting Time: Average amount of time a process is ready but waiting
o When a process is created o Response Time: in interactive systems, time until the system responds
o When a process terminates to a command
o When a process issues a blocking call (I/O, semaphores) o Response Ratio: (Turnaround Time)/(Execution Time) -- long jobs
o On a clock interrupt should wait longer
o On I/O interrupt (e.g., disk transfer finished, mouse click)
o System calls for IPC (e.g., up on semaphore, signal, etc.)

CIS 505, Spring 2007 CPU Scheduling 3 CIS 505, Spring 2007 CPU Scheduling 4

Scheduling Issues Basic Scheduling Algorithm: FCFS

 Different applications require different optimization
 FCFS - First-Come, First-Served
criteria
o Non-preemptive
o Batch systems (throughput, turnaround time)
o Ready queue is a FIFO queue
o Interactive system (response time, fairness, user
expectation) o Jobs arriving are placed at the end of queue
o Real-time systems (meeting deadlines) o Dispatcher selects first job in queue and this job
runs to completion of CPU burst
 Overhead of scheduling
 Advantages: simple, low overhead
o Context switching is expensive (minimize context switches)
o Data structures and book-keeping used by scheduler  Disadvantages: inappropriate for interactive
systems, large fluctuations in average
 What’s being scheduled by OS?
turnaround time are possible.
o Processes in Unix, but Threads in Linux or Solaris
CIS 505, Spring 2007 CPU Scheduling 5 CIS 505, Spring 2007 CPU Scheduling 6

1
Example of FCFS SJF - Shortest Job First

Non-preemptive

Workload (Batch system)

Ready queue treated as a priority queue based on smallest CPU-
Job 1: 24 units, Job 2: 3 units, Job 3: 3 units time requirement
• arriving jobs inserted at proper position in queue

FCFS schedule: • dispatcher selects shortest job (1st in queue) and runs to completion
| Job 1 | Job 2 | Job 3 |
0 24 27 30
Advantages: provably optimal w.r.t. average turnaround time

Disadvantages: in general, cannot be implemented. Also,
starvation possible!

Total waiting time: 0 + 24 + 27 = 51
Can do it approximately: use exponential averaging to predict

Average waiting time: 51/3 = 17 length of next CPU burst
==> pick shortest predicted burst next!

Total turnaround time: 24 + 27 + 30 = 81

Average turnaround time: 81/3 = 27

CIS 505, Spring 2007 CPU Scheduling 7 CIS 505, Spring 2007 CPU Scheduling 8

Example of SJF Exponential Averaging

Workload (Batch system)
Job 1: 24 units, Job 2: 3 units, Job 3: 3 units  n+1 =
tn + (1

) n

SJF schedule:
n+1 : predicted length of next CPU burst

| Job 2 | Job 3 | Job 1 |

tn : actual length of last CPU burst
0 3 6 30

n : previous prediction

Total waiting time: 6 + 0 + 3 = 9

Average waiting time: 3


= 0 implies make no use of recent history

Total turnaround time: 30 + 3 + 6 = 39
(n+1 = n )

Average turnaround time: 39/3 = 13


= 1 implies n+1 = tn (past prediction not used).

SJF always gives minimum waiting time and turnaround
time

= 1/2 implies weighted (older bursts get less and
less weight).
CIS 505, Spring 2007 CPU Scheduling 9 CIS 505, Spring 2007 CPU Scheduling 10

RR - Round Robin Example of RR

Workload (Batch system)

Preemptive version of FCFS Job 1: 24 units, Job 2: 3 units, Job 3: 3 units

Treat ready queue as circular
RR schedule with time quantum=3:

o arriving jobs are placed at end | Job 1 | Job 2 | Job 3 | Job 1 |
o dispatcher selects first job in queue and runs until 0 3 6 9 30
completion of CPU burst, or until time quantum
Total waiting time: 6 + 3 + 6 = 15
expires
Average waiting time: 5
o if quantum expires, job is again placed at end
Total turnaround time: 30 + 6 + 9 = 45

Average turnaround time: 15

RR gives intermediate wait and turnaround time
(compared to SJF and FCFS)

CIS 505, Spring 2007 CPU Scheduling 11 CIS 505, Spring 2007 CPU Scheduling 12

2
 Properties of RR HPF - Highest Priority First

Advantages: simple, low overhead, works for interactive

systems

Disadvantages:
General class of algorithms ==> priority
o if quantum is too small, too much time wasted in context switching scheduling
o if too large (i.e., longer than mean CPU burst), approaches FCFS

Each job assigned a priority which may change

Typical value: 20 – 40 msec
dynamically

Rule of thumb: Choose quantum so that large majority
(80 – 90%) of jobs finish CPU burst in one quantum
May be preemptive or non-preemptive

RR makes the assumption that all processes are equally
important

Key Design Issue: how to compute priorities?

CIS 505, Spring 2007 CPU Scheduling 13 CIS 505, Spring 2007 CPU Scheduling 14

Multi-Level Feedback (FB) FB Discussion

I/O-bound processes tend to congregate in higher-level queues. (Why?)

This implies greater device utilization

CPU-bound processes will sink deeper (lower) into the queues.

Large quantum occasionally versus small quanta often

Quantum in top queue should be large enough to satisfy majority of I/O-
bound processes

Can assign a process a lower priority by starting it at a lower-level queue

Can raise priority by moving process to a higher queue, thus can use in
conjunction with aging

To adjust priority of a process changing from CPU-bound to I/O-bound,
can move process to a higher queue each time it voluntarily relinquishes

Each priority level has a ready queue, and a time quantum CPU.

process enters highest priority queue initially, and (next) lower queue with each timer
interrupt (penalized for long CPU usage)

bottom queue is standard Round Robin

process in a given queue are not scheduled until all higher queues are empty

CIS 505, Spring 2007 CPU Scheduling 15 CIS 505, Spring 2007 CPU Scheduling 16

UNIX Scheduler Process Scheduling in Unix

Based on multi-level feedback queues

Priorities range from -64 to 63 (lower number means higher
priority)

Negative numbers reserved for processes waiting in kernel mode
o (that is, just woken up by interrupt handlers)
o (why do they have a higher priority?)

Time quantum = 1/10 sec (empirically found to be the longest
quantum that could be used without loss of the desired response
for interactive jobs such as editors)
o short time quantum means better interactive response
o long time quantum means higher overall system throughput since
less context switch overhead and less processor cache flush.

Priority dynamically adjusted to reflect
o resource requirement (e.g., blocked awaiting an event)
o resource consumption (e.g., CPU time)

CIS 505, Spring 2007 CPU Scheduling 17 CIS 505, Spring 2007 CPU Scheduling 18

3
Unix CPU Scheduler Example (exercise)

Suppose p_nice is 0, clock ticks every 10msec, time quantum is 100msec, and

Two values in the PCB p_cpu adjustment every sec
o p_cpu: an estimate of the recent CPU use
Suppose initial base value is 4. Initially, p_cpu is 0
o p_nice: a user/OS settable weighting factor (-20..20) for flexibility;
Initial priority is 4.
default = 0; negative increases priority; positive decreases priority
Suppose scheduler selects this process at some point, and it uses all of its

A process' priority calculated periodically quantum without blocking. Then, p_cpu will be 10, priority recalculated to 10, as
new base is 0.
priority = base + p_cpu + p_nice
At the end of a second, p_cpu, as well as priority, becomes 5 (more likely to
and the process is moved to appropriate ready queue scheduled)

CPU utilization, p_cpu, is incremented each time the system clock
Suppose again scheduler picks this process, and it blocks (say, for disk read)
after 30 msec. p_cpu is 8
ticks and the process is found to be executing.

Process is now in waiting queue for disk transfer

p_cpu is adjusted once every second (time decay)
At the end of next second, p_cpu is updated to 4
o Possible adjustment: divide by 2 (that is, shift right)
When disk transfer is complete, disk interrupt handler computes priority using a
negative base value, say, -10. New priority is -6
o Motivation: Recent usage penalizes more than past usage

Process again gets scheduled, and runs for its entire time quantum. p_cpu will
o Precise details differ in different versions (e.g. 4.3 BSD uses current be updated to 14
load (number of ready processes) also in the adjustment formula)

CIS 505, Spring 2007 CPU Scheduling 19 CIS 505, Spring 2007 CPU Scheduling 20

Summary of Unix Scheduler

Commonly used implementation with multiple priority

queues

Priority computed using 3 factors
o PUSER used as a base (changed dynamically)
o CPU utilization (time decayed)
o Value specified at process creation (nice)

Processes with short CPU bursts are favored

Processes just woken up from blocked states are
favored even more

Weighted averaging of CPU utilization

Details vary in different versions of Unix

CIS 505, Spring 2007 CPU Scheduling 21