chapter 5: cpu scheduling joe mccarthy css 430: operating systems - cpu scheduling1

Chapter 5:CPU Scheduling

Joe McCarthy

CSS 430: Operating Systems - CPU Scheduling 1

Chapter 5: CPU Scheduling

• Basic Concepts• Scheduling Criteria • Scheduling Algorithms• Thread Scheduling• Multiple-Processor Scheduling• Operating Systems Examples• Algorithm Evaluation

2CSS 430: Operating Systems - CPU Scheduling

Material derived, in part, fromOperating Systems Concepts with Java, 8th Ed.

© 2009 Silberschatz, Galvin & Gagne

CPU


[from Chapter 1: Introduction]

CPU Scheduling



CPU Scheduling



Multiprogramming

CPU Scheduling


[from Chapter 3: Processes]

CPU Scheduling


Process Control Blocks


CPU Scheduling


Can all PCBs have access to CPU simultaneously?


CPU Scheduling



CPU Queues



Process States



Basic Concepts

• Goal: Maximize CPU utilization via optimized multiprogramming

• CPU–I/O Burst Cycle:– Process execution consists of cycles

• CPU execution • I/O wait

• CPU burst durations vary– Within a process– across different processes


Histogram of CPU-burst Durations


CPU Scheduler

• Selects next process to run (i.e., to get CPU time)• Dispatches that process (allocates the CPU to it)• CPU scheduler called when a process …


CPU Scheduler

• Selects next process to run (i.e., to get CPU time)• Dispatches that process (allocates the CPU to it)• CPU scheduler called when a process:

– Running terminated– Running waiting– Running ready– Waiting ready

• Preemptive vs. non-preemptive


Dispatcher

• Activates a process (gives control of the CPU to the process) selected by the short-term scheduler

• Three steps:


Dispatcher


• Three steps:


Dispatcher


• Three steps:– Switch context– Switch to user mode– Jump to the proper location

in user program to start/resume

• Dispatch latency: time it takes for the dispatcher to stop one user process and start another one


Scheduling Milestones• Submission Time

– Time when job is submitted– E.g., when command is entered in shell

• Admission Time– Time when job is admitted to Ready queue– PCB creation & other housekeeping has to take place

• Activation Time– Time when job is first activated (Ready Running)– E.g., when first output starts appearing on console– NB: may have several CPU-I/O burst cycles

• Completion Time– Time when job finishes executing


Job (Process/Thread) Times• Response Time

– Time before job is first activated– Activation Time – Submission Time– E.g., time between entering command & first response

• Wait Time– Total amount of time job spends in Ready queue

• Execution Time– Total amount of time job spends Running– NB: may have several CPU-I/O burst cycles

• Turnaround Time– Time a job takes to complete after it is submitted– Completion Time – Submission Time


Scheduling Criteria• CPU utilization

– % of time CPU is executing user processes• Throughput

– # of processes that complete their execution per time unit• Average response time

– average amount of between when a process is submitted & first response (for time-sharing environment)

• Average waiting time– average amount of time a process waits in Ready queue

• Average turnaround time– average amount of time to execute a process


Scheduling Optimization Criteria• CPU utilization: maximize

– % of time CPU is executing user processes• Throughput: maximize

– # of processes that complete their execution per time unit• Average response time: minimize

– average amount of between when a process is submitted & first response (for time-sharing environment)

• Average waiting time: minimize– average amount of time a process waits in Ready queue

• Average turnaround time: minimize– average amount of time to execute a process


First-Come, First-Served (FCFS)• FCFS policy often implemented with FIFO queue• Example: 3 processes with the following burst times:

P1 = 24; P2 = 3; P3 = 3 • Suppose that the processes arrive at t0 in the order:

P1, P2, P3 The Gantt Chart for the schedule is:

• Waiting times• Average waiting time:


P1 P2 P3

24 27 300

First-Come, First-Served (FCFS)• FCFS policy often implemented with FIFO queue• Example: 3 processes with the following burst times:

P1 = 24; P2 = 3; P3 = 3 • Suppose that the processes arrive at t0 in the order:

P1, P2, P3 The Gantt Chart for the schedule is:

• Waiting times: P1 = 0; P2 = 24; P3 = 27• Average waiting time: (0 + 24 + 27) / 3 = 17.0


P1 P2 P3

24 27 300

FCFS Scheduling

Suppose that the processes arrive in the order: P2 , P3 , P1

• The Gantt chart for the schedule is:

• Waiting times:• Average waiting time:


P1P3P2

63 300

FCFS Scheduling

Suppose that the processes arrive in the order: P2 , P3 , P1

• The Gantt chart for the schedule is:

• Waiting times: P1 = 6; P2 = 0;; P3 = 3• Average waiting time: (6 + 0 + 3) / 3 = 3.0


P1P3P2

63 300

FCFS Scheduling

• Convoy effect: short process[es] stuck behind long process• How could we achieve minimal average waiting time?

•


P1P3P2

63 300

P1 P2 P3

24 27 300

Order: P1, P2, P3

Average wait: 17.0Order: P2, P3, P1

Average wait: 3.0

Shortest-Job-First (SJF) Scheduling

• Always schedule the shortest job first– Select process with shortest next CPU burst.

• Optimal average waiting time– For any set of processes


P1P3P2

63 300

Example of SJFProcess Arrival Time Burst Time

P1 0.0 6 P2 2.0 8 P3 4.0 7 P4 5.0 3

• SJF scheduling chart



P1 0.0 6 P2 2.0 8 P3 4.0 7 P4 5.0 3


• Average waiting time:


P4 P3P1

3 160 9

P2

24


P1 0.0 6 P2 2.0 8 P3 4.0 7 P4 5.0 3


• Average waiting time: (3 + 16 + 9 + 0) / 4 = 7.0


P4 P3P1

3 160 9

P2

24

CSS430 CPU Scheduling 33

Another SJF example

• Example: Process Arrival Time Burst TimeP1 0 7

P2 2 4 P3 4 1

P4 5 4

• Non preemptive SJFP1 P3 P2

7

P1(7)

160

P4

8 12

Average waiting time = (0 + 6 + 3 + 7)/4 = 4

2 4 5

P2(4)

P3(1)

P4(4)

P1‘s wating time = 0





Another SJF example (cont’d)• Example: Process Arrival Time Burst Time

P1 0 7 P2 2 4 P3 4 1

P4 5 4

• Preemptive SJFP1 P3P2

42 110

P4

5 7

P2 P1

16

Average waiting time = (9 + 1 + 0 +2)/4 = 3

P1(7)

P2(4)

P3(1)

P4(4)





P1(5)

P2(2)

Shortest-Job-First Scheduling



• Only one problem


P1P3P2

63 300




• Only one problem


P1P3P2

63 300

http://www.hedgeworld.com/blog/?p=3570




• Only one problem– How to know the length of the next CPU burst?


P1P3P2

63 300

http://www.hedgeworld.com/blog/?p=3570

Determining Length of Next CPU Burst

• Can only estimate length of future bursts

• Use exponential averaging of previous bursts


:Define 4.

10 , 3.

burst CPU next the for value predicted 2.

burst CPU of length actual 1.

1n

thn nt

.1 1 nnn t

Examples of Exponential Averaging• = 0

– n+1 = n

– Recent history does not count

• = 1– n+1 = tn

– Only the most recent CPU burst counts

• = 0.5 (typically)• 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


Predicting Length of Next CPU Burst


Shortest Remaining Time First

• Pre-emptive version of SJF





Average wait time?




Average wait time: [(10 – 1) + (1 – 1) + (17 – 2) + (5 – 3)] / 4 = 6.5





Non pre-emptive SJF?





Non pre-emptive SJF: [0 + (8 – 1) + (17 – 2) + (12 – 3)] / 4 = 7.75

Priority Scheduling• A priority number (integer) is associated with each process

• Based on internal and/or external factors• The CPU is allocated to the process with the highest priority

– Preemptive: new, higher priority processes take precedence– Non-preemptive: new processes wait for current process

• Textbook: low # high priority [opposite of ThreadOS]• SJF priority: • FCFS priority:





• Textbook: low # high priority (opposite of ThreadOS)• SJF priority: predicted next CPU burst time• FCFS priority: arrival time





• Textbook: low # high priority (opposite of ThreadOS)• SJF priority: predicted next CPU burst time• FCFS priority: arrival time• Problem?





• Textbook: low # high priority (opposite of ThreadOS)• SJF priority: predicted next CPU burst time• FCFS priority: arrival time• Problem Starvation – low priority processes may never

execute• Solution?





• Textbook: low # high priority (opposite of ThreadOS)• SJF priority: predicted next CPU burst time• FCFS priority: arrival time• Problem Starvation – low priority processes may never

execute• Solution Aging – as time progresses increase the priority

of the process


Priority Scheduling Example


Average wait time: (6 + 0 + 16 + 18 + 1) / 5 = 8.2




If pre-emptive & process arrival times are 0, 1, 2, 3, 4?Average wait time:




If pre-emptive & process arrival times are 0, 1, 2, 3, 4?Average wait time: [((2 – 1) + (9 – 4)) + 0 + (16 – 2) + (18 – 3) + 0] / 5 = 7.0

Round Robin (RR)

• Each process gets time quantum (q) of CPU time (typically 10-100 ms)– Selected from head of Ready queue

• If process does not block (I/O) within q ms: preempted – Added to the tail of the Ready queue (as are new

processes)• General observations:

– n processes in the Ready queue – each process gets 1/n of the CPU time (in slices of size q) – maximum waiting time: (n-1)q time units


Process Burst TimeP1 24 P2 3 P3 3

• The Gantt chart is:

Example of RR with Time Quantum = 4


Example of RR with Time Quantum = 4

Process Burst TimeP1 24 P2 3 P3 3

• The Gantt chart is:

• Compare to SJF:


P1 P2 P3 P1 P1 P1 P1 P1

0 4 7 10 14 18 22 26 30

P1P3P2

63 300


• 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 = 20Process Burst Time Wait TimeP1 53 57 +24 = 81 P2 17 20 P3 68 37 + 40 + 17= 94 P4 24 57 + 40 = 97

Another RR example

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162

Average wait time = (81+20+94+97)/4 = 73

57

20

37

57

24

40

40

17

P1(53)

P2(17)

P3(68)

P4(24)

P1(33) P1(13)

P3(48) P3(28) P3(8)

P4(4)

Time Quantum & Context Switch Time

• Performance issues:– q large – q small


Time Quantum & Context Switch Time

• Performance issues:– q large FCFS– q small context switch overhead too high


Time Quantum Turnaround Time


Multilevel Queue

• Ready queue can be partitioned into separate queues– E.g., foreground (interactive) & background (batch)

• Each queue can have its own scheduling algorithm• Scheduling must be done between the queues• Simplest: Fixed priority scheduling

– One possibility: 100% priority to foreground• Serve foreground if any; serve background only if no foreground• Problem?


Multilevel Queue



– One possibility: 100% priority to foreground• Serve foreground if any; serve background only if no foreground• Problem: possibility of starvation

– Another possibility?


Multilevel Queue



– One possibility: 100% priority to foreground• Serve foreground if any; serve background only if no foreground• Problem: possibility of starvation.

– Another possibility: 80/20 priority using time slices • 80% to foreground using RR• 20% to background using FCFS


Multilevel Queue Scheduling


Multilevel Feedback Queue

• Process can migrate among queues– Queue placement based on

past behavior (feedback)• Parameters:

– number of queues– scheduling algorithms for each queue– when to upgrade a process– when to demote a process– when to select a queue for service


Example of Multilevel Feedback Queue

• Three queues: Q0, Q1, Q2; all use FCFS• If blocked for I/O, job returned to Q0

when I/O done• New jobs enter queue Q0

– When activated (given CPU), job receives 8 ms– If not done, job is preempted, demoted to Q1

• Jobs in Q1– When activated, job receives 16 ms– If not done, job is preempted, demoted to Q2

• Jobs in Q2– When activated, job runs until terminated or

interrupted– If not done, job is preempted, returned to Q2


Java Thread Scheduling

• Priority-based• FCFS within same priority level

• May be preemptive or non-preemptive• A runnable thread executes until:

• Time quantum expires• Blocks for I/O• Exits its run() method• Yields to another thread via yield()

• “cooperative multitasking”


Java Thread Priorities

• Values: 1 .. 10– Thread.MAX_PRIORITY = 10– Thread.NORM_PRIORITY = 5– Thread.MIN_PRIORITY = 1

• Methods:– int Thread.getPriority()– Thread.setPriority( int newPriority )


Mapping Java Thread Priorities

• JVM runs on host• Java Thread priorities (user)

host kernel priorities• Example: Win32• ThreadOS Scheduler:

– Sets its priority to 6– Sets user thread priorities to 4 (running) or 2 (ready)– Goes to sleep

• effectively yields to priority 4 user thread


Program 2


http://courses.washington.edu/css430/joemcc/prog/prog2b.html



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 (master & slave processors)

• 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: policy– hard affinity: mechanism



http://hadoop.apache.org/common/docs/current/hdfs_design.html

http://hadoop.apache.org/common/docs/current/hdfs_design.html

NUMA and CPU Scheduling


NUMA = non-uniform memory access

Multicore Processors

• Multiple threads per core– Memory stall: CPU awaits instruction/data fetch– Multiple hardware threads: logical processors

• Each logical processor can run a software thread

– Enables progress to made on one thread while memory is updated

– Two approaches• Coarse-grained multithreading (latency event)• Fine-grained multithreading (per instruction)


Multithreaded Multicore System


Operating System Examples

• Solaris scheduling

• Windows XP scheduling

• Linux scheduling


Solaris Scheduling


Dispatch Table (for TS, IA)

Windows XP Scheduling


Priority classes

Rel

ativ

e pr

iorit

ies

Processes within a variable class (not real-time):• Expired time quantum reduce priority• Released from wait increase priorityForeground process gets extra boost

Linux priorities & time quanta


runqueue: active & expired


When all task lists in active array are empty,exchange active array & expired array

Algorithm Evaluation

• How can we compare scheduling algorithms?



• How can we compare scheduling algorithms?


FCFS, SJF & RR average wait times?


FCFS, SJF & RR: average wait times?


FCFS: (0 + 10 + 39 + 42 + 49) / 5 = 28



FCFS: (0 + 10 + 39 + 42 + 49) / 5 = 28

SJF: (10 + 32 + 0 + 3 + 20) / 5 = 13



FCFS: (0 + 10 + 39 + 42 + 49) / 5 = 28

SJF: (10 + 32 + 0 + 3 + 20) / 5 = 13

RR: (0 + 32 + 20 + 23 + 40) / 5 = 23



• How can we compare scheduling algorithms?– Analysis

• Deterministic models: predetermined workload




• Deterministic models: predetermined workload• Queueing models: use probability distribution

– Arrival rate– Service rate






– Simulation• ThreadOS






– Simulation• ThreadOS

– Implementation


For next time

• Readings– Chapter 6: Process Synchronization


chapter 5: cpu scheduling joe mccarthy css 430: operating systems - cpu scheduling1

Documents