CSS430 CPU Scheduling
Textbook Ch5
These slides were compiled from the Applied OSC textbook slides (Silberschatz,
Galvin, and Gagne) and the instructor’s class materials.
CSS430 CPU Scheduling 1
Histogram of CPU-burst Times
CSS430 CPU Scheduling 2
CPU-I/O Burst Cycle
Process A Process B
CSS430 CPU Scheduling 3
CPU Scheduler
Selects from among the processes in memory that are
ready to execute, and allocates the CPU to one of
them. (Short-term scheduler)
CPU scheduling decisions may take place when a
process:
1.Switches from running to waiting state (by sleep).
2.Switches from running to ready state (by yield).
3.Switches from waiting to ready (by an interrupt).
4.Terminates (by exit).
Scheduling under 1 and 4 is nonpreemptive.
All other scheduling is preemptive.
CSS430 CPU Scheduling 4
Scheduling Criteria
CPU utilization – keep the CPU as busy as possible
Throughput – # of processes that complete their execution
per time unit
Turnaround time (TAT) – 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)
CSS430 CPU Scheduling 5
Discussions 1
Can OS satisfy all those metrics: CPU
utilization, throughput, TAT, waiting
time, and response time?
CSS430 CPU Scheduling 6
First Come First Served
Scheduling
Example: Process Burst Time
P1 24
P2 3
P3 3
Suppose that the processes arrive in the order: P1 , P2 , P3
P1 P2 P3 Waiting time for P1 = 0; P2 = 24; P3 = 27
0 24 27 30 Average waiting time: (0 + 24 + 27)/3 = 17
Suppose that the processes arrive in the order: P2 , P3 , P1 .
P2 P3 P1 Waiting time for P1 = 6; P2 = 0; P3 = 3
0 3 6 scheduling
Non-preemptive 30 Average waiting time: (6 + 0 + 3)/3 = 3
Troublesome for time-sharing systems
Convoy effect short process behind long process
CSS430 CPU Scheduling 7
Shortest Job First Scheduling
Example: Process Arrival Time Burst Time
P1 0 7
P2 2 4
P3 4 1
P4 5 4
Non preemptive SJF Average waiting time = (0 + 6 + 3 + 7)/4 = 4
P1 P3 P2 P4
0 2 4 5 7 8 12 16 P1‘s wating time = 0
P1(7)
P2‘s wating time = 6
P2(4)
P3(1) P3‘s wating time = 3
P4‘s wating time = 7
P4(4)
CSS430 CPU Scheduling 8
Shortest Job First Scheduling
Cont’d
Example: Process Arrival Time Burst Time
P1 0 7
P2 2 4
P3 4 1
P4 5 4
Average waiting time = (9 + 1 + 0 +2)/4 = 3
Preemptive SJF
P1 P2 P 3 P2 P4 P1
0 2 4 5 7 11 16 P1‘s wating time = 9
P1(5)
P1(7)
P2‘s wating time = 1
P2(4) P2(2)
P3(1) P3‘s wating time = 0
P4‘s wating time = 2
P4(4)
CSS430 CPU Scheduling 9
Shortest Job First Scheduling
Cont’d
Optimal scheduling
Preemptive SJF is superior to non preemptive SJF.
However, there are no accurate estimations to know
the length of the next CPU burst
Estimation introduced in Textbook:
1. t n actual length of n th CPU burst
2. n 1 predicted value for the next CPU burst
3. , 0 1
4. Define : n 1 t n 1 n .
CSS430 CPU Scheduling 10
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 in Unix but lowest in Java).
Preemptive
Non-preemptive
SJF is a priority scheduling where priority is the predicted next
CPU burst time.
Problem Starvation – low priority processes may never
execute.
Solution Aging – as time progresses increase the priority of
the process.
CSS430 CPU Scheduling 11
Round Robin Scheduling
Each process is given CPU time in turn, (i.e. time quantum: usually 10-100
milliseconds), and thus waits no longer than ( n – 1 ) * time quantum
time quantum = 20
Process Burst Time Wait Time
P1 53 57 +24 = 81
P2 17 20
P3 68 37 + 40 + 17= 94
P4 24 57 + 40 = 97
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162
P1(53) 57
P1(33) 24P1(13)
P2(17) 20
P3(48) P3(28) P3(8)
P3(68) 37 40 17
P4(24) 57 40 P4(4)
Average wait time = (81+20+94+97)/4 = 73
CSS430 CPU Scheduling 12
Round Robin Scheduling
Typically, higher average turnaround than SJF, but better response.
Performance
q large FCFS
q small q must be large with respect to context switch,
otherwise overhead is too high.
CSS430 CPU Scheduling 13
Turnaround Time Varies With
The Time Quantum
TAT can be improved if most processes
finish their next CPU burst in a single
time quantum.
CSS430 CPU Scheduling 14
Multilevel Queue Scheduling
Each queue has its
own scheduling
algorithm,
foreground
(interactive) –
RR, 80% CPU
time
background
(batch) –
FCFS, 20%
CPU time
CSS430 CPU Scheduling 15
Multilevel Feedback-Queue
Scheduling
A new job enters queue Q0 which is
served FCFS. When it gains CPU, job
receives 8 milliseconds. If it does not
finish in 8 milliseconds, job is moved
to queue Q1.
At Q1 job is again served FCFS and
receives 16 additional milliseconds. If
it still does not complete, it is
preempted and moved to queue Q2.
CSS430 CPU Scheduling 16
Discussions 2
What is the main problem in MFQS?
How can you address this problem?
Briefly think about your own scheduling
algorithm?
CSS430 CPU Scheduling 17
Cooperative multithreading in
Java
A thread voluntary yielding control of the CPU is called cooperative
multitasking.
public void run( ) {
while ( true ) {
// perform a CPU-intensive task
…
// now yield control of the CPU
Thread.yield( );
}
}
Thread.yield( ) is OS-dependent.
Linux does not care about it.
Solaris allows a thread to yield its execution when the
corresponding LWP exhausts a given time quantum.
Conclusion: Don’t write a program based on yield( ).
CSS430 CPU Scheduling 18
Java-Based Round-Robin
Scheduler (Naïve Example)
public class Scheduler extends Thread public void run( ) {
{ Thread current;
public Scheduler( ) { this.setPriority( 6 );
timeSlice = DEFAULTSLICE; while ( true ) {
queue = new CircularList( ); // get the next thread
} current = ( Thread )queue.getNext( );
public Scheduler( int quantum ) { if ( ( current != null ) && ( current.isAlive( ) ) {
timeSlice = quantum; current.setPriority( 4 );
queue = new CircularList( ); schedulerSleep( );
} current.setPriority( 2 );
public void addThread( Thread t ) { }
t.setPriority( 2 ); }
queue.addItem( t ); }
}
private void schedulerSleep( ) { private CircularList queue;
try { private int timeSlice;
Thread.sleep( timeSlice ); private static final int DEFAULT_TIME_SLICE=1000;
} catch ( InterruptedException e ) { }; }
}
CSS430 CPU Scheduling 19
Test program
public class TestScheduler
{
public static void main( String args[] ) {
Thread.currentThread( ).setPriority( Thread.MAX_PRIORITY );
Scheduler CPUScheduler = new Scheduler( );
CPUScheduler.start( );
// uses TestThread, although this could be any Thread object.
TestThread t1 = new TestThread( “Thread 1” );
t1.start( );
CPUScheduler.addThread( t1 );
TestThread t2 = new TestThread( “Thread 2” );
t2.start( );
CPUScheduler.addThread( t2 );
TestThread t3 = new TestThread( “Thread 3” );
t3.start( );
CPUScheduler.addThread( t3 );
}
}
CSS430 CPU Scheduling 20
Why not work?
Java: runs threads with a higher priority until they are blocked.
(Threads with a lower priority cannot run concurrently.)
This may cause starvation or deadlock.
Java’s strict priority scheduling was implemented in Java green
thread.
In Java 2, thread’s priority is typically mapped to the underlying
OS-native thread’s priority.
OS: gives more CPU time to threads with a higher priority.
(Threads with a lower priority can still run concurrently.)
If we do not want to depend on OS scheduling, we have to use:
Thread.suspend( )
Thread.resume( )
CSS430 CPU Scheduling 21
Multiprocessor Scheduling
OS code and user process mapping:
Asymmetric multiprocessing
Symmetric multiprocessing (SMP)
Scheduling criteria:
Processor affinity
Load balancing
Thread context switch:
Coarse-grained software thread
Fine-grained hardware thread
CSS430 CPU Scheduling 22
Exercises
Programming Assignment 2:
Check the syllabus for its due date.
No-turn-in problems:
1. Solve Exercise 5.5
2. Solve Exercise 5.12
3. Solve Exercise 5.14
CSS430 CPU Scheduling 23
