Chapter 5 Process Scheduling Clock interrupt handling Scheduler

Chapter 5. Process Scheduling • Clock interrupt handling • Scheduler goal • Traditional UNIX scheduling • SVR 4 scheduler • Solaris 2. x scheduling enhancements • Scheduling in Mach • Other scheduling implementation 1

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 2

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 3

Callouts • A callout records a function that the kernel must invoke at a later time – e. g. SVR 4 – 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 4

Callouts (cont) • Callout implementation in BSD UNIX Callout listhead time left to fire t=2 t=1 roundrobin schedcpu t=4 f 1 3 7 2 t=0 f 2 7 (a) Callout queue at on instant of time Callout listhead time left to fire t=1 roundrobin schedcpu t=4 f 1 2 6 1 t=0 f 2 6 (b) Callout queue one tick later 5

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 6

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 ~ 150 ms – batch • do not require user interaction, as background jobs • criteria: task’s completion time – real-time • time-critical with guaranteed bounds on response time 7

Traditional Scheduling • SVR 3, 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 8

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 9

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 10

Traditional Scheduling (cont) • Scheduler implementation whichqs 0 0 0 1. . . qs 0~3 4~7 8 ~ 11 12 ~ 15 16 ~ 19 20 ~23 P P P . . . 11

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 12

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 13

SVR 4 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 14

SVR 4 Scheduler (cont) • SVR 4 dispatch queues dqactmap 0 0 1. . . dispq 160 159 158 157 156 155 P P P . . . 15

SVR 4 Scheduler (cont) • SVR 4 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 16

SVR 4 Scheduler (cont) • interface to the scheduling class Global class table rt-init real-time sys-init system ts-init time-sharing rt_classfuncs sys_classfuncs ts_classfuncs proc structures p_cid p_clfuncs p_clproc. . . class-dependent data 17

SVR 4 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 18

SVR 4 Scheduler (cont) • Real-time class – scheduled before any kernel process – fixed priority and time quantum – requires bounded dispatch latency and response time nonpreemptive kernel processing context switch process made runnable context switch initiated process is scheduled to run application code response time Interrupt processing dispatch latency event occurs process responds to event 19

SVR 4 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 CPUbound 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 20

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 21

MP Scheduling in Solaris 2. x • Initial situation T 1 pri 120 P 1 T 2 pri 130 P 2 T 3 pri 100 P 3 T 6 pri 130 T 4 pri 132 P 4 T 5 pri 135 P 5 T 7 pri 115 22

MP Scheduling in Solaris (cont) • After T 6 and T 7 become runnable about to be switched out T 1 pri 120 T 2 pri 130 P 1 T 3 pri 100 P 2 about to be scheduled on P 3 T 6 pri 130 P 3 T 4 pri 132 P 4 T 5 pri 135 P 5 CPU_chosen_level = 130 T 7 pri 115 dispatcher queues 23

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 24

Priority Inversion (cont) currently running T 1 pri 100 R holds blocks T 2 pri 130 T 3 pri 110 becomes runnable T 2 pri 130 T 3 pri 110 currently running (a) Initial situation runnable T 1 pri 100 holds blocks R dispatcher queues (b) Without priority inheritance currently running T 1 pri 100 holds inh pri = 130 blocks R T 2 pri 130 T 3 pri 110 runnable dispatcher queues (c) With priority inheritance 25

Priority Inversion (cont) • Transitive priority inheritance currently running T 6 pri 100 holds blocks R 1 T 5 pri 110 holds blocks R 2 T 4 pri 135 becomes runnable (a) Initial situation currently running T 6 pri 100 runnable holds inh pri = 135 T 7 pri 122 blocks R 1 T 5 pri 110 holds inh pri = 135 blocks R 2 T 4 pri 135 T 7 pri 122 dispatcher queues (b) Transitive priority inheritance 26

Priority Inheritance • Traversing the synchronization chain blocked threads T 4 gp 100 R 1 owner runnable hold own er holds T 1 gp 60 ip 100 s R 2 s currently running T 6 gp 110 T 3 gp 70 T 5 gp 80 hold owner T 2 gp 90 ip 100 R 3 r e own s hold wants R 4 gp = global priority ip = inherited priority 27

Priority Inheritance (cont) blocked threads T 4 gp 100 R 1 owner currently running T 1 gp 60 ip 110 hold s own er holds R 2 s owner r e own s gp = global priority ip = inherited priority hold R 4 T 3 gp 70 T 5 gp 80 ip 110 hold R 3 T 2 gp 90 ip 100 T 6 gp 110 blocked threads 28

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 active T Turnstile pool active T T Blocked threads T Synchronization objects 29

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 30

Other Scheduling • Deadline-driven scheduling • Three-level scheduler – isochronous class – real-time class – general-purpose class – admission control 31