Scheduling
Announcements
CS CPU 4410 was due two days ago!
CS 4411 projects due next Wednesday, September 17th
Everyone should have access to CMS
(http://cms3.csuglab.cornell.edu)
Check and contact me ([e-mail]) or Bill Hogan
([e-mail]) today if you do not have access to CMS
Also, everyone should have CSUGLab account
Contact Bill or I if you do not
Review: Threads
Each thread has its own PC, registers, and stack pointer
But shares code, data, accounting info (address space)
Pthreads (POSIX - Portable Operating System Interface for uniX)
A POSIX standard (IEEE 1003.1c) API for thread creation and
synchronization
API specifies behavior of the thread library, implementation is up to
development of the library
Common in UNIX operating systems (Solaris, Linux, Mac OS X)
Windows XP Threads
Implements the one-to-one mapping
Each thread contains
A thread id
Register set
Separate user and kernel stacks
Private data storage area
The register set, stacks, and private storage area are
Review Threads
Linux Threads
Linux refers to them as tasks rather than threads
Thread creation is done through clone() system call
clone() allows a child task to share the address space of the
parent task (process)
Java Threads
Java threads are managed by the JVM
Java threads may be created by:
Extending Thread class
Implementing the Runnable interface
Goals for Today
CPU Schedulers
Scheduling Algorithms
Algorithm Evaluation Metrics
Algorithm details
Thread Scheduling
Multiple-Processor Scheduling
Real-Time Scheduling
Schedulers
Process migrates among several queues
Device queue, job queue, ready queue
Scheduler selects a process to run from these queues
Long-term scheduler:
load a job in memory
Runs infrequently
Short-term scheduler:
Select ready process to run on CPU
Should be fast
Middle-term scheduler (aka swapper)
Reduce multiprogramming or memory consumption
Process Scheduling
process and thread used interchangeably
Which process to run next
Many processes in ready state
Which ready process to pick to run on the CPU?
0 ready processes: run idle loop
1 ready process: easy!
> 1 ready process: what to do?
New
Ready
Running
Waiting
Exit
When does scheduler run?
Non-preemptive minimum
Process runs until voluntarily relinquish CPU
process blocks on an event (e.g., I/O or synchronization)
process terminates
process yields
Preemptive minimum
All of the above, plus:
Event completes: process moves from blocked to ready
Timer interrupts
Implementation: process can be interrupted in favor of another
New
Running
Ready
Waiting
Exit
Process Model
Process alternates between CPU and I/O bursts
CPU-bound jobs: Long CPU bursts
Matrix multiply
I/O-bound: Short CPU bursts
emacs
emacs
I/O burst = process idle, switch to another for free
Problem: dont know jobs type before running
Presidential debates in 2 weeks
Why watch?
Want to see what hype is about
Very entertaining
See either first woman elected VP or first African-american
elected president
What does the presidential debates have to do with
scheduling?!
Also, want to watch Football, 24 reruns, Law & Order, etc
But, have to finish Project and Homework!
What criteria to use to schedule events?
Scheduling Evaluation Metrics
Many quantitative criteria for evaluating sched algorithm:
CPU utilization: percentage of time the CPU is not idle
Throughput: completed processes per time unit
Turnaround time: submission to completion
Waiting time: time spent on the ready queue
Response time: response latency
Predictability: variance in any of these measures
The right metric depends on the context
An underlying assumption:
response time most important for interactive jobs (I/O bound)
The perfect CPU scheduler
Minimize latency: response or job completion time
Maximize throughput: Maximize jobs / time.
Maximize utilization: keep I/O devices busy.
Recurring theme with OS scheduling
Fairness: everyone makes progress, no one starves
Problem Cases
Blindness about job types
I/O goes idle
Optimization involves favoring jobs of type A over B.
Lots of As? Bs starve
Interactive process trapped behind others.
Response time sucks for no reason
Priority Inversion: A depends on B. As priority > Bs.
B never runs
Scheduling Algorithms FCFS
First-come First-served (FCFS) (FIFO)
Jobs are scheduled in order of arrival
Non-preemptive
Problem:
Average waiting time depends on arrival order
P1
P2
0
16
P2
0
P3
4
P3
time
20
24
P1
8
Advantage: really simple!
24
Convoy Effect
A CPU bound job will hold CPU until done,
or it causes an I/O burst
rare occurrence, since the thread is CPU-bound
long periods where no I/O requests issued, and CPU held
Result: poor I/O device utilization
Example: one CPU bound job, many I/O bound
CPU bound runs (I/O devices idle)
CPU bound blocks
I/O bound job(s) run, quickly block on I/O
CPU bound runs again
I/O completes
CPU bound still runs while I/O devices idle (continues)
Simple hack: run process whose I/O completed?
What is a potential problem?
Scheduling Algorithms LIFO
Last-In First-out (LIFO)
Newly arrived jobs are placed at head of ready queue
Improves response time for newly created threads
Problem:
May lead to starvation early processes may never get
CPU
Problem
You work as a short-order cook
Customers come in and specify which dish they want
Each dish takes a different amount of time to prepare
Your goal:
minimize average time the customers wait for their food
What strategy would you use ?
Note: most restaurants use FCFS.
Scheduling Algorithms: SJF
Shortest Job First (SJF)
Choose the job with the shortest next CPU burst
Provably optimal for minimizing average waiting time
P1
P3
0
15
PP2
2
0
PP3
3
3
P2
21 24
P1
9
24
Problem:
Impossible to know the length of the next CPU burst
Scheduling Algorithms SRTF
SJF can be either preemptive or non-preemptive
New, short job arrives; current process has long time to execute
Preemptive SJF is called shortest remaining time first
P2
P3
0
P1
6
P3
0
P1
6
21
10
P2
10 13
P1
24
Shortest Job First Prediction
Approximate next CPU-burst duration
from the durations of the previous bursts
The past can be a good predictor the of future
No need to remember entire past history
Use exponential average:
tn duration of the nth CPU burst
n+1 predicted duration of the (n+1)st CPU burst
n+1 = tn + (1- ) n
where 0 1
determines the weight placed on past behavior
Prediction of the Length of the
Next CPU Burst
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 -j +
+ ( 1 - )n + 1 0
Since both and (1 - ) are less than or equal to 1, each
successive term has less weight than its predecessor
Priority Scheduling
Priority Scheduling
Choose next job based on priority
For SJF, priority = expected CPU burst
Can be either preemptive or non-preemptive
Problem:
Starvation: jobs can wait indefinitely
Solution to starvation
Age processes: increase priority as a function of waiting time
Round Robin
Round Robin (RR)
Often used for timesharing
Ready queue is treated as a circular queue (FIFO)
Each process is given a time slice called a quantum
It is run for the quantum or until it blocks
RR allocates the CPU uniformly (fairly) across participants.
If average queue length is n, each participant gets 1/n
RR with Time Quantum = 20
Process
P1
P2
P3
P4
The Gantt chart is:
P1
0
P2
20
P3
37
P4
57
Burst Time
53
17
68
24
P1
77
P3
P4
P1
P3
P3
97 117 121 134 154 162
Higher average turnaround than SJF,
But better response time
Turnaround Time w/ Time Quanta
RR: Choice of Time Quantum
Performance depends on length of the timeslice
Context switching isnt a free operation.
If timeslice time is set too high
attempting to amortize context switch cost, you get FCFS.
i.e. processes will finish or block before their slice is up anyway
If its set too low
youre spending all of your time context switching between threads.
Timeslice frequently set to ~100 milliseconds
Context switches typically cost < 1 millisecond
Moral:
Context switch is usually negligible (< 1% per timeslice)
otherwise you context switch too frequently and lose all
productivity
Scheduling Algorithms
Multi-level Queue Scheduling
Implement multiple ready queues based on job type
interactive processes
CPU-bound processes
batch jobs
system processes
student programs
Different queues may be scheduled using different
algorithms
Intra-queue CPU allocation is either strict or proportional
Problem: Classifying jobs into queues is difficult
A process may have CPU-bound phases as well as interactive ones
Multilevel Queue Scheduling
Highest priority
System Processes
Interactive Processes
Batch Processes
Student Processes
Lowest priority
Scheduling Algorithms
Multi-level Feedback Queues
Implement multiple ready queues
Different queues may be scheduled using different algorithms
Just like multilevel queue scheduling, but assignments are not static
Jobs move from queue to queue based on feedback
Feedback = The behavior of the job,
e.g. does it require the full quantum for computation, or
does it perform frequent I/O ?
Very general algorithm
Need to select parameters for:
Number of queues
Scheduling algorithm within each queue
When to upgrade and downgrade a job
Multilevel Feedback Queues
Highest priority
Quantum = 2
Quantum = 4
Quantum = 8
FCFS
Lowest priority
A Multi-level System
high
I/Oboundjobs
priority
CPUboundjobs
low
timeslice
high
Multiple-Processor Scheduling
CPU scheduling more complex when multiple CPUs are
available
Homogeneous processors within a multiprocessor
Asymmetric multiprocessing only one processor
accesses the system data structures, alleviating the need
for data sharing
Symmetric multiprocessing (SMP) each processor is
self-scheduling, all processes in common ready queue,
or each has its own private queue of ready processes
Processor affinity process has affinity for processor
on which it is currently running
soft affinity
hard affinity
NUMA and CPU Scheduling
Multicore Processors
Recent trend to place multiple processor cores
on same physical chip
Faster and consume less power
Multiple threads per core also growing
Takes advantage of memory stall to make progress
on another thread while memory retrieve happens
Multithreaded Multicore System
Thread Scheduling
Since all threads share code & data segments
Option 1: Ignore this fact
Option 2: Gang scheduling
run all threads belonging to a process together (multiprocessor only)
if a thread needs to synchronize with another thread
the other one is available and active
Option 3: Two-level scheduling:
Medium level scheduler
schedule processes, and within each process, schedule threads
reduce context switching overhead and improve cache hit ratio
Option 4: Space-based affinity:
assign threads to processors (multiprocessor only)
improve cache hit ratio, but can bite under low-load condition
Real-time Scheduling
Real-time processes have timing constraints
Expressed as deadlines or rate requirements
Common RT scheduling policies
Rate monotonic
Just one scalar priority related to the periodicity of the job
Priority = 1/rate
Static
Earliest deadline first (EDF)
Dynamic but more complex
Priority = deadline
Both require admission control to provide guarantees
Operating System Examples
Solaris scheduling
Windows XP scheduling
Linux scheduling
Solaris Dispatch Table
Solaris Scheduling
Windows XP Priorities
Linux Scheduling
Constant order O(1) scheduling time
Two priority ranges: time-sharing and
real-time
Real-time range from 0 to 99 and
nice value from 100 to 140
(figure 5.15)
Priorities and Time-slice length
List of Tasks Indexed According to Priorities
Summary
Scheduling problem
Given a set of processes that are ready to run
Which one to select next
Scheduling criteria
CPU utilization, Throughput, Turnaround, Waiting, Response
Predictability: variance in any of these measures
Scheduling algorithms
FCFS, SJF, SRTF, RR
Multilevel (Feedback-)Queue Scheduling
The best schemes are adaptive.
To do absolutely best wed have to predict the future.
Most current algorithms give highest priority to those that need the
least!
Scheduling become increasingly ad hoc over the years.
1960s papers very math heavy, now mostly tweak and see