COMPUTER SYSTEMS

An Integrated Approach to Architecture and Operating Systems

Chapter 6
Processor Scheduling

©Copyright 2009Umakishore Ramachandran and William D. Leahy Jr.

 6.1 Introduction
• Things to Do
– Laundry
– Study for Test
– Cook and eat dinner
– Call Mom for her birthday
• How would you do it?
 6.2 Programs and Processes
• What is an operating system?

• What are resources?

• How do we create programs?

 6.2 Programs and Processes
• What is the memory footprint of
a user program?
Low memory
Use by the OS
Program code Program 1
Memory footprint
Program global data
of
Program heap User program
Program 2
Program stack
Use by the OS .
High memory
.

.
Program n

• What is the overall view of OS Data

Structures

OS routines
memory?
• Why?
 6.2 Programs and Processes
• What resources are required to run:
Hello, World!
• What is a scheduler?
Program Properties Process/System Properies
Expected running time Available system memory
Expected memory usage Arrival time of a program
Expected I/O requirements Instantaneous memory requirements

Process 1

Process 2
scheduler Processor
.
. winner
.

Process n
 6.2 Programs and Processes
Program Process
• On disk • In memory (and disk)
• Static • Dynamic – changing
• No state • State
– No PC – PC
– No register usage – Registers
• Fixed size • May grow or shrink
• Fundamental unit of
scheduling
One program may
yield many processes
 6.2 Programs and Processes
Name Usual Connotation Use in this chapter
Job Unit of scheduling Synonymous with process
Process Program in Synonymous with job
execution; unit of
scheduling
Thread Unit of scheduling Not used in the scheduling algorithms
and/or execution; described in this chapter
contained within a
process

Task Unit of work; unit of Not used in the scheduling algorithms

scheduling described in this chapter, except in
describing the scheduling algorithm of
Linux
6.3 Scheduling Environments
 6.3 Scheduling Environments
Name Environment Role
Long term scheduler Batch oriented OS Control the job mix in
memory to balance use of
system resources (CPU,
memory, I/O)
Loader In every OS Load user program from
disk into memory
Medium term scheduler Every modern OS (time- Balance the mix of
shared, interactive) processes in memory to
avoid thrashing
Short term scheduler Every modern OS (time- Schedule the memory
shared, interactive) resident processes on the
CPU
Dispatcher In every OS Populate the CPU registers
with the state of the process
selected for running by the
short-term scheduler
 6.3 Scheduling Environments
Process States

New Halted
Admitted Exit
Interrupt

Ready Running

Scheduler Dispatch

I/O or Event Completion Waiting I/O or Event Wait

6.4 Scheduling Basics
 6.4 Scheduling Basics
• Schedulers come in two basic flavors
– Preemptive
– Non-preemptive
• Basic scheduler steps
1. Grab the attention of the processor.
2. Save the state of the currently running process.
3. Select a new process to run.
4. Dispatch the newly selected process to run on the
processor.
 6.4 Scheduling Basics
• What information is important to know about
a process?
 6.4 Scheduling Basics
• Process Control Block
enum state_type {new, ready, running, waiting, halted};
 
typedef struct control_block_type {
struct control_block *next_pcb; /* list ptr */
enum state_type state; /* current state */
address PC; /* where to resume */
int reg_file[NUMREGS]; /* contents of GPRs */

int priority; /* extrinsic property */

address address_space; /* where in memory */
…
…
} control_block; next_pcb
info…
 6.4 Scheduling Basics
Partially Executed
Swapped Out Processes

Ready Queue CPU

I/O I/O Queue I/O Request

Time Slice Expired

Child Executes Fork a Child

Wait for an
Interrupt Occurs
Interrupt
 6.4 Scheduling Basics
Name Description
CPU burst Continuous CPU activity by a process before requiring an I/O
operation
I/O burst Activity initiated by the CPU on an I/O device
PCB Process context block that holds the state of a process (i.e.,
program in execution)
Ready queue Queue of PCBs that represent the set of memory resident processes
that are ready to run on the CPU
I/O queue Queue of PCBs that represent the set of memory resident processes
that are waiting for some I/O operation either to be initiated or
completed
Non-Preemptive Algorithm that allows the currently scheduled process on the CPU
algorithm to voluntarily relinquish the processor (either by terminating or
making an I/O system call)
Preemptive Algorithm that forcibly takes the processor away from the currently
algorithm scheduled process in response to an external event (e.g. I/O
completion interrupt, timer interrupt)
Thrashing A phenomenon wherein the dynamic memory usage of the
processes currently in the ready queue exceed the total memory
capacity of the system
 6.5 Performance Metrics
• System Centric.
– CPU Utilization: Percentage of time the processor is
busy.
– Throughput: Number of jobs executed per unit time.
– Average turnaround time: Average elapsed time for
jobs entering and leaving the system.
– Average waiting time: Average of amount of time
each job waits while in system
• User Centric
– Response time: Time until system responds to user.
 6.5 Performance Metrics
• Two other qualitative issues
– Starvation: The scheduling algorithm prevents a
process from ever completing
– Convoy Effect: The scheduling algorithm allows
long-running jobs to dominate the CPU
 6.5 Performance Metrics
P1 P2 P3

w1 e1 e2 e3

t1
w2
t2
w3
t3

wi, ei, and ti, are respectively the wait time, execution time,
and the elapsed time for a job ji
 6.5 Performance Metrics
P1 P2 P3

2 3 4 3 2 5

5
9
12
14
19

Assume times are in ms

 6.5 Performance Metrics
• System Centric.
– CPU Utilization:
– Throughput:
– Average turnaround time:
– Average waiting time
• User Centric
– Response time:
 6.5 Performance Metrics
• Assumptions for following slides
– Context switch time is negligible
– Single I/O queue
– Simple model (first-come-first-served) for
scheduling I/O requests.
6.6 Non-preemptive Scheduling Algorithms

• Non-preemptive means that once a process is

running it will continue to do so until it
relinquishes control of the CPU. This would be
because it terminates, voluntarily yields the
CPU to some other process (waits) or requests
some service from the operating system.
6.6.1 First-Come First-Served (FCFS)
• Intrinsic property: Arrival time
• May exhibit convoy effect
• No starvation
• High variability of average waiting time
 6.6.2 Shortest Job First (SJF)
• Uses anticipated burst time
• No convoy effect
• Provably optimal for best average waiting time
• May suffer from starvation
– May be addressed with aging rules
 6.6.3 Priority
• Each process is assigned a priority
• May have additional policy such as FCFS for all
jobs with same priority
• Attractive for environments where different
users will pay more for preferential treatment
• SJF is a special case with Priority=1/burst time
• FCFS is a special case with Priority = arrival time
 6.7 Preemptive Scheduling Algorithms

• Two simultaneously implications.

– Scheduler is able to assume control of the
processor anytime unbeknownst to the currently
running process.
– Scheduler is able to save the state of the currently
running process for proper resumption from the
point of preemption.
• Any of the Non-preemptive algorithms can be
made Preemptive
 6.7.1 Round Robin Scheduler
• Appropriate for time-sharing environments
• Need to determine time quantum q: Amount of time a
process gets before being context switched out (also
called timeslice)
– Context switching time becomes important
• FCFS is a special case with q = ∞
• If n processes are running under round robin they will
have the illusion they have exclusive use of a
processor running at 1/n times the actual processor
speed
 6.7.1.1 Details of Round Robin Algorithm

• What do we mean by context?

• How does the dispatcher get run?

• How does the dispatcher switch contexts?

 6.7.1.1 Details of Round Robin Algorithm
• Dispatcher:
get head of ready queue;
set timer; Round Robin
dispatch;
• Timer interrupt handler: Scheduling Algorithm
save context in PCB;
move PCB to the end of the ready queue;
upcall to dispatcher;
• I/O request trap:
save context in PCB;
move PCB to I/O queue;
upcall to dispatcher;
• I/O completion interrupt handler:
save context in PCB;
move PCB of I/O completed process to ready queue;
upcall to dispatcher;
• Process termination trap handler:
Free PCB;
upcall to dispatcher;
6.8 Combining Priority and Preemption

• Modern general purpose operating systems

such as Windows NT/XP/Vista and Unix/Linux
use multi-level feedback queues
• System consists of a number of different
queues each with a different expected
quantum time
• Each individual queue uses FCFS except base
queue which uses Round Robin
 6.8 Combining Priority and Preemption
New process
q1 enters here
A process that doesn’t
finish before qi drops Note:
down 1 level q1<q2<q3<q4
q2
A process that does
finish before qi goes
up 1 level
q3

Multi-
Level
Feedback
q4
Queue
 6.9 Meta Schedulers
Meta
scheduler
Time slices
IJ/BJ

ready_q
PCB1 PCB2 … PCBn
Q Q

Scheduler for Scheduler for

Interactive jobs batch jobs
(Round Robin) Priority FCFS

ready_q
PCB1 PCB2 … PCBn
 6.10 Evaluation
• Evaluate considering domain of application
– Desktop: Personal computing.
– Servers: Mail servers, file servers, and web servers.
– Business: E-commerce and Wall Street style applications.
– High-Performance Computing (HPC): Solving scientific and
engineering problems.
– Grid: HPC with geographically distribution
– Embedded: Low-end devices such as cell phones, PDA’s and hybrid
combinations as well as sophisticated computing systems found in
automobiles and aircraft.
– Pervasive: Emerging domain combining elements of HPC and
embedded computing.
 6.10 Evaluation
Domains Environment Workload Types of schedulers
characteristics
Desktop Timeshared, interactive, I/O bound Medium-term, short-
multiprogrammed term, dispatcher
Servers Timeshared, Computation bound Medium-term, short-
multiprogrammed term, dispatcher
Business Timeshared, I/O bound Medium-term, short-
multiprogrammed term, dispatcher
HPC Timeshared, Computation bound Medium-term, short-
multiprogrammed term, dispatcher
Grid Batch-oriented, Computation bound Long-term, Medium-
timeshared, term, short-term,
multiprogrammed dispatcher
Embedded Timeshared, interactive, I/O bounds Medium-term, short-
multiprogrammed term, dispatcher
Pervasive Timeshared, interactive, Combination of I/O Medium-term, short-
multiprogrammed bound and term, dispatcher
computation bound
 6.11 Summary and a Look ahead
Name Property Scheduling criterion Pros Cons
FCFS Intrinsically non- Arrival time Fair; no starvation; high variance in
preemptive; could (intrinsic property) response time;
accommodate preemption convoy effect
at time of I/O completion
events
SJF Intrinsically non- Expected execution Preference for short jobs; Potential for
preemptive; could time of jobs provably optimal for starvation; bias
accommodate preemption (intrinsic property) response time; low variance against long running
at time of new job arrival in response times computations
and/or I/O completion
events
Priority Could be either non- Priority assigned to Highly flexible since priority Potential for
preemptive or preemptive jobs (extrinsic is not an intrinsic property, starvation
property) its assignment to jobs could
be chosen commensurate
with the needs of the
scheduling environment

SRTF Similar to SJF but uses Expected remaining Similar to SJF Similar to SJF
preemption execution time of
jobs
Round Preemptive allowing equal Time quantum Equal opportunity for all Overhead for context
Robin share of the processor for jobs; switching among
all jobs jobs
6.12 Linux Scheduler – A case study
• Scheduler designed to match personal computing and
server domains
• Goals
– High efficiency
• Spending as little time as possible in scheduler, important goal for
server environment
– Support for interactivity
• Important for the interactive workload of the desktop environment
– Avoid starvation
• Ensure that computational workload do not suffer as a result of
interactive workloads
– Support for soft real-time scheduling
• Meet the demands of interactive applications with real-time
constraints
6.12 Linux Scheduler – A case study
• Linux scheduler recognizes three classes of
tasks:
– Real-time FCFS
– Real-time round robin
– Timeshared
• Scheduler has 140 priority levels.
– Levels 0-99 for real-time tasks
– Remaining levels for timeshared tasks.
6.12 Linux Scheduler – A case study
 6.12 Linux Scheduler – Algorithm
• Pick first task with highest priority from active array and
run it.
• If task blocks (due to I/O) put it aside and pick next
highest one to run.
• If time quantum runs out (does not apply to FCFS tasks)
for currently scheduled task then place it in expired array.
• If a task completes its I/O then place it in active array at
right priority level adjusting its remaining time quantum.
• If there are no more tasks to schedule in active array,
simply flip active and expired array pointers and continue
with scheduling algorithm (i.e., expired array becomes the
active array and vice versa).
 6.13 Historical Perspective
• Babbage
• ENIAC
• FORTRAN/FMS
• IBSYS /IBM 7094/JCL
• Scientific/Business Users…IBM S/360
• Timesharing/MULTICS
• Unix
• Personal Computing/Windows/Linux
Questions?