chap2 cpu scheduling

8/9/2019 Chap2 CPU Scheduling

1/55

Chapter 5: CPU Scheduling


2/55

Chapter 5: CPU Scheduling

Basic Concepts

Scheduling Criteria

Scheduling Algorithms

Thread Scheduling

Multiple-Processor Scheduling

Operating Systems Examples

Algorithm Evaluation


3/55

Objectives

To introduce CPU scheduling, which is the basis for multiprogrammed

operating systems

To describe various CPU-scheduling algorithms

To discuss evaluation criteria for selecting a CPU-scheduling algorithmfor a particular system


4/55

Basic Concepts

Maximum CPU utilization obtained with multiprogramming

CPU–I/O Burst Cycle – Process execution consists of acycle of CPUexecution and I/O wait

CPU burstdistribution


5/55

Histogram of CPU-burst imes


6/55

!lternating Se"uence of CPU !nd #$O Bursts


7/55

CPU Scheduler

Selects from among the processes in memory that are ready to

execute, and allocates the CPU to one of them

CPU scheduling decisions may take place when a process:

1.Switches from running to waiting state

2.Switches from running to ready state

3.Switches from waiting to ready

4.Terminates

Scheduling under 1 and 4 isnonpreemptive

All other scheduling ispreemptive


8/55

%ispatcher

Dispatcher module gives control of the CPU to the process selectedby the short-term scheduler; this involves:

switching context

switching to user mode

jumping to the proper location in the user program to restart that

program

Dispatch latency– time it takes for the dispatcher to stop oneprocess and start another running


9/55

Scheduling Criteria

CPU utilization– keep the CPU as busy as possible

Throughput – # of processes that complete their execution per timeunit

Turnaround time– amount of time to execute a particular process

Waiting time– amount of time a process has been waiting in theready queue

Response time– amount of time it takes from when a request wassubmitted until the first response is produced, not output (for time-sharing environment)


10/55

Scheduling !lgorithm Optimi&ation Criteria

Max CPU utilization

Max throughput

Min turnaround time

Min waiting time

Min response time


11/55

'irst-Come( 'irst-Served )'C'S* Scheduling

Process Burst Time P1 24

P 2 3

P3 3

Suppose that the processes arrive in the order:P1 ,P 2 ,P3

The Gantt Chart for the schedule is:

Waiting time forP1 = 0;P 2 = 24;P3= 27

Average waiting time: (0 + 24 + 27)/3 = 17

P1 P2 P3

24 27 300


12/55

'C'S Scheduling )Cont+*

Suppose that the processes arrive in the order:

P 2 ,P3 ,P1

The Gantt chart for the schedule is:

Waiting time forP1= 6;P 2 = 0;P3=3

Average waiting time: (6 + 0 + 3)/3 = 3

Much better than previous case

Convoy effect short process behind long process

P1P3P2

63 300


13/55

Shortest-,ob-'irst )S,'* Scheduling

Associate with each process the length of its next CPU burst. Use

these lengths to schedule the process with the shortest time

SJF is optimal – gives minimum average waiting time for a given set ofprocesses

The difficulty is knowing the length of the next CPU request


14/55

.ample of S,'

Process Arrival Time Burst Time

P1 0.0 6

P 2 2.0 8

P3 4.0 7

P4 5.0 3

SJF scheduling chart

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

P4 P3P1

3 160

9

P2

24


15/55

%etermining /ength of 0e.t CPU Burst

Can only estimate the length

Can be done by using the length of previous CPU bursts, usingexponential averaging

:Define 4.

10, 3.

burst CPUnextthefor valuepredicted 2.

burst CPUof lenth actual 1.

≤≤

=

=

+

α α

τ 1n

th

n nt

( ) .11 nnn

t τ α α τ −+==


16/55

Prediction of the /ength of the 0e.t CPU Burst


17/55

.amples of .ponential !veraging

α =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 successiveterm has less weight than its predecessor


18/55

Priorit1 Scheduling

A priority number (integer) is associated with each process

The CPU is allocated to the process with the highest priority (smallestinteger≡ highest priority)

Preemptive

Nonpreemptive

SJF is a priority scheduling where priority is the predicted next CPUburst time

Problem≡ Starvation– low priority processes may never execute

Solution≡ Aging– as time progresses increase the priority of theprocess


19/55

2ound 2obin )22*

Each process gets a small unit of CPU time (time quantum), usually10-100 milliseconds. After this time has elapsed, the process ispreempted and added to the end of the ready queue.

If there aren processes in the ready queue and the time quantum isq, then each process gets 1/n of the CPU time in chunks of at most

q time units at once. No process waits more than (n-1)qtime units.

Performance

q large⇒ FIFO

qsmall⇒ qmust be large with respect to context switch,

otherwise overhead is too high


20/55

.ample of 22 3ith ime 4uantum 6

Process Burst Time

P1 24

P 2 3

P3 3

The Gantt chart is:

Typically, higher average turnaround than SJF, but betterresponse

P1 P2 P3 P1 P1 P1 P1 P1

0 4 7 10 14 18 22 26 30


21/55

ime 4uantum and Conte.t S3itch ime

rnaro nd ime 7aries 8ith


22/55

urnaround ime 7aries 8ith

he ime 4uantum


23/55

9ultilevel 4ueue

Ready queue is partitioned into separate queues:

foreground (interactive)background (batch)

Each queue has its own scheduling algorithm

foreground – RR

background – FCFS

Scheduling must be done between the queues

Fixed priority scheduling; (i.e., serve all from foreground then frombackground). Possibility of starvation.

Time slice – each queue gets a certain amount of CPU time whichit can schedule amongst its processes; i.e., 80% to foreground inRR

20% to background in FCFS


24/55

9ultilevel 4ueue Scheduling


25/55

9ultilevel 'eedbac 4ueue

A process can move between the various queues; aging can beimplemented this way

Multilevel-feedback-queue scheduler defined by the followingparameters:

number of queues

scheduling algorithms for each queue

method used to determine when to upgrade a process

method used to determine when to demote a process

method used to determine which queue a process will enter when

that process needs service


26/55

.ample of 9ultilevel 'eedbac 4ueue

Three queues:

Q0 – RR with time quantum 8 milliseconds

Q1 – RR time quantum 16 milliseconds

Q2 – FCFS

Scheduling

A new job enters queueQ0 which is served FCFS. When it gains

CPU, job receives 8 milliseconds. If it does not finish in 8milliseconds, job is moved to queueQ1.

AtQ1 job is again served FCFS and receives 16 additional

milliseconds. If it still does not complete, it is preempted andmoved to queueQ2.


27/55

9ultilevel 'eedbac 4ueues


28/55

hread Scheduling

Distinction between user-level and kernel-level threads

Many-to-one and many-to-many models, thread library schedules user-level threads to run on LWP

Known asprocess-contention scope (PCS)since scheduling

competition is within the process

Kernel thread scheduled onto available CPU issystem-contention

scope (SCS)– competition among all threads in system


29/55

Pthread Scheduling

API allows specifying either PCS or SCS during thread creation

PTHREAD SCOPE PROCESS schedules threads using PCS

scheduling

PTHREAD SCOPE SYSTEM schedules threads using SCSscheduling.


30/55

Pthread Scheduling !P#

#include

#include #defne NUM THREADS 5

int ain!int ar"c char $ar"%&'(

)

int i*

pthread t tid&NUM THREADS'*

pthread attr t attr*

+$ "et the de,ault attri-utes $+

pthread attr init!attr(*

+$ set the schedulin" al"orith to /R01ESS or S2STEM $+

pthread attr setscope!attr /THREAD S10/E S2STEM(*

+$ set the schedulin" polic3 4 60 RT or 0THER $+

pthread attr setschedpolic3!attr S1HED 0THER(*

+$ create the threads $+

,or !i 7 8* i < NUM THREADS* i99(

pthread create!tid&i'attrrunnerNU::(*


31/55

Pthread Scheduling !P#

+$ no; oin on each thread $+

,or !i 7 8* i < NUM THREADS* i99(

pthread oin!tid&i' NU::(*

=

+$ Each thread ;ill -e"in control in this ,unction $+

%oid $runner!%oid $para(

)

print,!6 a a thread?n(*

pthread e@it!8(*

=


32/55

9ultiple-Processor Scheduling

CPU scheduling more complex when multiple CPUs are available

Homogeneous processorswithin a multiprocessor

Asymmetric multiprocessing– only one processor accesses thesystem 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 itsown private queue of ready processes

Processor affinity– process has affinity for processor on which it is

currently running soft affinity

hard affinity


33/55

0U9! and CPU Scheduling


34/55

9ulticore 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


35/55

9ultithreaded 9ulticore S1stem


36/55

Operating S1stem .amples

Solaris scheduling

Windows XP scheduling

Linux scheduling


37/55

Solaris %ispatch able


38/55

Solaris Scheduling


39/55

8indo3s ;P Priorities


40/55

/inu. Scheduling

Constant orderO(1) scheduling time

Two priority ranges: time-sharing and real-time

Real-timerange from 0 to 99 andnicevalue from 100 to 140

(figure 5.15)


41/55

Priorities and ime-slice length


42/55

/ist of ass #nde.ed !ccording to Priorities


43/55

!lgorithm valuation

Deterministic modeling – takes a particular predetermined workloadand defines the performance of each algorithm for that workload

Queueing models

Implementation


44/55

valuation of CPU schedulers b1 Simulation


45/55

nd of Chapter 5

5


46/55

5+


47/55

#n-5+>

# 5 =


48/55

#n-5+=

# 5 ?


49/55

#n-5+?

%i t h / t


50/55

%ispatch /atenc1

, h d S h d li


51/55

,ava hread Scheduling

JVM Uses a Preemptive, Priority-Based Scheduling Algorithm

FIFO Queue is Used if There Are Multiple Threads With the SamePriority

, h d S h d li )C t *


52/55

,ava hread Scheduling )Cont+*

JVM Schedules a Thread to Run When:

1.The Currently Running Thread Exits the Runnable State

2.A Higher Priority Thread Enters the Runnable State

* Note – the JVM Does Not Specify Whether Threads are Time-Sliced orNot

i Sli i


53/55

ime-Slicing

Since the JVM Doesn’t Ensure Time-Slicing, the yield() Method May Be

Used:

while (true) {

// perform CPU-intensive task

. . .Thread.yield();

}

This Yields Control to Another Thread of Equal Priority

hread Priorities


54/55

hread Priorities

Priority Comment

Thread.MIN_PRIORITY Minimum Thread Priority

Thread.MAX_PRIORITY Maximum Thread Priority

Thread.NORM_PRIORITY Default Thread Priority

Priorities May Be Set Using setPriority() method:

setPriority(Thread.NORM_PRIORITY + 2);

Solaris @ Scheduling


55/55

Solaris @ Scheduling

chap2 cpu scheduling

Documents