process scheduling 1 chapter 5. process scheduling clock interrupt handling scheduler goal...
TRANSCRIPT
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
Process Scheduling 2
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
Process Scheduling 3
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
Process Scheduling 4
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
Process Scheduling 5
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
Process Scheduling 6
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
Process Scheduling 7
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
Process Scheduling 8
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
Process Scheduling 9
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
Process Scheduling 10
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
Process Scheduling 11
Traditional Scheduling (cont)• Scheduler implementation
0 00 ~ 34 ~ 7
8 ~ 1112 ~ 1516 ~ 1920 ~23
. . .
P
whichqs
P P
P P
0 1 10qs
. . .
Process Scheduling 12
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
Process Scheduling 13
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
Process Scheduling 14
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
Process Scheduling 15
SVR4 Scheduler (cont)• SVR4 dispatch queues
0 0160159158157156155
. . .
P
dqactmap
P P
P P
1 0 10dispq
. . .
Process Scheduling 16
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
Process Scheduling 17
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. . .
p_cidp_clfuncsp_clproc. . .
p_cidp_clfuncsp_clproc. . .
p_cidp_clfuncsp_clproc. . .
class-dependentdata
class-dependentdata
class-dependentdata
class-dependentdata
proc structures
Process Scheduling 18
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
Process Scheduling 19
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
Process Scheduling 20
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
Process Scheduling 21
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
Process Scheduling 22
MP Scheduling in Solaris 2.x
• Initial situation
P1 P2 P3 P4 P5
T1pri120
T2pri130
T3pri100
T4pri132
T5pri135
T6pri130
T7pri115
Process Scheduling 23
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
Process Scheduling 24
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
Process Scheduling 25
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
Process Scheduling 26
Priority Inversion (cont)• Transitive priority inheritance
T6pri100
currently running
holds blocks T5pri110
R1
(a) Initial situation
holds blocks T4pri135
R2
T7pri122
becomesrunnable
T6pri100
currently running
holds blocks T5pri110
R1
(b) Transitive priority inheritance
holds blocks T4pri135
R2
T7pri122
runnable
inh pri = 135 inh pri = 135 dispatcherqueues
Process Scheduling 27
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
Process Scheduling 28
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
Process Scheduling 29
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
Process Scheduling 30
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
Process Scheduling 31
Other Scheduling
• Deadline-driven scheduling
• Three-level scheduler
– isochronous class
– real-time class
– general-purpose class
– admission control