process scheduling 1 chapter 5. process scheduling clock interrupt handling scheduler goal...

Process Scheduling 1

Chapter 5. Process Scheduling

• Clock interrupt handling

• Scheduler goal

• Traditional UNIX scheduling

• SVR4 scheduler

• Solaris 2.x scheduling enhancements

• Scheduling in Mach

• Other scheduling implementation


Clock Interrupt Handling

• H/W clock interrupts the system at fixed time intervals

• The clock interrupt handler is second priority only to that of power-failure interrupt

• The clock interrupt handler performs

– rearms the h/w clock if necessary

– updates CPU usage statistics for the current process


Clock Interrupt Handling (cont)– performs scheduler-related functions, such as

• priority recomputation• time-slice expiration handling

– sends a SIGXCPU signal to the current process if it has exceeded its CPU usage quota

– updates the time-of-day clock and other related clocks

– handle callouts

– wakes up system processes such as the swapper and pagedaemon when appropriate

– handle alarm


Callouts• A callout records a function that the kernel

must invoke at a later time– e.g. SVR4– int to_ID = timeout(void (*fn( )), caddr_t arg, long delta);

• In system context

• Used for periodic tasks– retransmission of network packets– scheduler and memory management functions– monitoring devices to avoid losing interrupts– polling devices that do not support interrupts


Callouts (cont)• Callout implementation in BSD UNIX

Calloutlisthead

t = 2roundrobin

t = 1schedcpu

t = 4f1

t = 0f2

time left to fire 2 3 7 7

(a) Callout queue at on instant of time

Calloutlisthead

t = 1roundrobin

t = 1schedcpu

t = 4f1

t = 0f2

time left to fire 1 2 6 6

(b) Callout queue one tick later


Alarms• A process requests the kernel to send it a

signal after a specific amount of time

• three types of alarms– real-time alarm

• relates to the actual elapsed time, via a SIGALARM signal• high resolution high accuracy

– profiling alarm• measures the amount of time the process has been

executing, via SIGPROF signal

– virtual time alarm• monitors only the time spent by the process in user

mode, via SIGVTALARM signal


Scheduler Goals• Deliver acceptable performance to each Ap.

• Categories of applications– interactive

• spend a lot of time waiting user input• system needs to reduce the average time and variance

btw user action and application response• acceptable delay is about 50 ~ 150ms

– batch• do not require user interaction, as background jobs• criteria: task’s completion time

– real-time• time-critical with guaranteed bounds on response time


Traditional Scheduling

• SVR3, 4.3 BSD

• Scheduling target– time-sharing, interactive environment with

several batch and foreground processes simultaneously

• Scheduling policy– improve response time of interactive users,

while ensuring that low priority, background jobs do not starve


Traditional Scheduling (cont)• Priority-based– priority changes with time– preemptive time-slicing

• Kernel is nonpreemptible

• Process priority– 0 ~ 49: kernel, 50 ~ 127: process in user mode

• proc structure– p_pri current scheduling priority– p_usrpri user mode priority– p_cpu measure of recent CPU usage– p_nice user-controllable nice factor


Traditional Scheduling (cont)• Sleep priority

– kernel value (0 ~ 49)

– e.g. terminal input: 28, disk I/O: 20

• Priority calculation: schedcpu( )

– every tick, clock handler increments p_cpu for the current process

– every second, p_cpu = p_cpu - decay factor;

– p_usrpri = PUSER + p_cpu/4 + 2*p_nice;

– PUSER is the baseline priority of 50


Traditional Scheduling (cont)• Scheduler implementation

0 00 ~ 34 ~ 7

8 ~ 1112 ~ 1516 ~ 1920 ~23

. . .

P

whichqs

P P

P P

0 1 10qs

. . .


Traditional Scheduling (cont)

• Situations for context switch

– current process blocks on a resource, or exits

– priority recomputation procedure results in the priority of another process becoming greater than that of of the current one

– current process, or an interrupt handler, wakes up a higher-priority process


Traditional Scheduling (cont)

• Analysis

– simple and effective

– favor I/O-bound jobs

– not scale well

– no guarantee of CPU usage and response time

– kernel is non-preemptive: priority inversion


SVR4 Scheduler

• Scheduling class

– time sharing and real-time

• class-independent routines

– common services such as context switching,

run queue manipulation, and preemption

• class-dependent routines

– priority computation and inheritance


SVR4 Scheduler (cont)• SVR4 dispatch queues

0 0160159158157156155

. . .

P

dqactmap

P P

P P

1 0 10dispq

. . .


SVR4 Scheduler (cont)

• SVR4 kernel defines several preemption points– places in the kernel code where all kernel data

structures are in a stable state, and the kernel is about to embark on a length computation

• Three ranges of 160 priorities

– 0 ~ 59: time-sharing class

– 60 ~ 99: system priorities

– 100 ~ 159: real-time class


SVR4 Scheduler (cont)• interface to the scheduling class

real-time

time-sharing

system

rt_classfuncsrt-init

sys_classfuncs

ts_classfuncs

Global class table

sys-init

ts-init

p_cidp_clfuncsp_clproc. . .




class-dependentdata

class-dependentdata

class-dependentdata

class-dependentdata

proc structures


SVR4 Scheduler (cont)

• Time-sharing class

– changes process priorities dynamically

– round-robin scheduling with the same priority

– event driven scheduling

• reduces process priority each time it uses up its time

slice

• boosts the priority of the process if it blocks on an

event or resource, or if it takes a long time to use up

it quantum


SVR4 Scheduler (cont)• Real-time class– scheduled before any kernel process– fixed priority and time quantum– requires bounded dispatch latency and

response time

Interrupt processing

nonpreemptive kernelprocessing

context switch

application code

event occurs

process made runnable

context switch initiated

process is scheduled to run

process responds to event

tim e

disp

atch

la

tenc

y

resp

onse

tim

e


SVR4 Scheduler (cont)• Analysis

– allows the addition of scheduling class

– time-sharing class changes priorities based on events related to that process

– favor I/O-bound and interactive jobs over CPU-bound ones

– code path btw preemption points is too long for time-critical applications

– difficult to tune the system properly for a mixed set of jobs


Solaris 2.x Scheduling Enhancement

• Preemptive kernel

– most global kernel data structures must be protected by synchronization objects

– implementation of interrupts using special kernel threads

• Multiprocessor support

– single dispatch queue for all processors


MP Scheduling in Solaris 2.x

• Initial situation

P1 P2 P3 P4 P5

T1pri120

T2pri130

T3pri100

T4pri132

T5pri135

T6pri130

T7pri115


MP Scheduling in Solaris (cont)• After T6 and T7 become runnable

P1 P2 P3 P4 P5

T1pri120

T2pri130

T3pri100

T4pri132

T5pri135

about to beswitched out

CPU_chosen_level = 130

T6pri130

T7pri115

dispatcher queues

about to bescheduled on P3


Priority Inversion

• Lower priority process holds a resource needed by a higher priority process, thereby blocking that higher priority process

• Solved by priority inheritance

– when a high-priority thread blocks on a resource, it temporarily transfer its priority to the lower priority thread that owns the resource


Priority Inversion (cont)T1pri100

currentlyrunning

holds blocks T2pri130

T3pri110

becomesrunnable

(a) Initial situation

(b) Without priority inheritance

(c) With priority inheritance

T1pri100

runnable holds blocks T2pri130

T3pri110

currentlyrunning

dispatcher queues

T1pri100

runnableholds blocks T2pri130

T3pri110

dispatcher queues

currentlyrunning

inh pri = 130

R

R

R


Priority Inversion (cont)• Transitive priority inheritance

T6pri100

currently running


R1

(a) Initial situation


R2

T7pri122

becomesrunnable

T6pri100

currently running


R1

(b) Transitive priority inheritance


R2

T7pri122

runnable

inh pri = 135 inh pri = 135 dispatcherqueues


Priority Inheritance• Traversing the synchronization chain

currentlyrunning

T4gp 100

runnable

blocked threads

R1

T5gp 80

R2

R3

R4

T1gp 60ip 100

T6gp 110

T2gp 90ip 100

T3gp 70

holdsowner

holds

holds

wants

owner

holds

owner

owner

gp = global priorityip = inherited priority


Priority Inheritance (cont)

currentlyrunning

T4gp 100

blocked threads

blocked threads

R1

T5gp 80ip 110

R2

R3

R4

T1gp 60ip 110

T6gp 110

T2gp 90ip 100

T3gp 70

holdsowner

holds

holds

owner

holds

owner

owner

gp = global priorityip = inherited priority


Priority Inheritance (cont)• Limitations

– is not used for semaphores and condition variables since the owner is usually indeterminate

• Turnstiles– reduce information maintained by kernel for

hundreds of synchronization objects

TurnstilepoolT

T

T

T TT

active

Blocked threads

Synchronization objects

active

active


Scheduling in Mach

• Schedules threads regardless of the task to which they belong

• Handoff scheduling– a thread can directly yield the processor to

another thread w/o searching the run queue– improves the performance of the IPC calls

• Multiprocessor support– processor allocation can be handled by a

user-lever server program– gang scheduling


Other Scheduling

• Deadline-driven scheduling

• Three-level scheduler

– isochronous class

– real-time class

– general-purpose class

– admission control

process scheduling 1 chapter 5. process scheduling clock interrupt handling scheduler goal...

Documents

time alarmrelates

lot of time

average time

clock handler

actual elapsed time

day clock

cpu usage quotaupdates

user action