5 Process and thread scheduling 5 1 Organization

5. Process and thread scheduling 5. 1 Organization of Schedulers – Embedded and Autonomous Schedulers 5. 2 Scheduling Methods – A Framework for Scheduling – Common Scheduling Algorithms – Comparison of Methods 5. 3 Priority Inversion Operating Systems 1

Process and Thread Scheduling • Scheduling occurs at two levels: • Process/job scheduling – Long term scheduling (seconds, minutes, …) – Move process to Ready List (RL) after creation (When and in which order? ) • Dispatching – Short term scheduling (milliseconds) – Select process from Ready List to run • We use the term scheduling to refer to both Operating Systems 2

Organization of Schedulers • Embedded – Called as function at end of kernel call – Runs as part of calling process • Autonomous – Separate process – Multiprocessor: may have dedicated CPU – Single-processor: scheduler and other processes alternate (every quantum) Operating Systems 3

An Embedded Scheduler() { do { find highest priority process p with p. status==ready_a; find a free cpu; if (cpu != NIL) Allocate_CPU(p, cpu); } while (cpu != NIL); do { find highest priority process p with p. status==ready_a; find lowest priority process q with p. status==running; if (Priority(p) > Priority(q)) Preempt(p, q); } while (Priority(p) > Priority(q)); if (self->Status. Type!=running) Preempt(p, self); } Operating Systems 4

Scheduling Methods • Priority determines who runs – Can be static or dynamic – Given by Priority function: P = Priority(p) • p are parameters – Arbitration rule to break ties • Random • Chronological (FIFO) • Cyclic (Round Robin = RR) • When is scheduler invoked? —Decision mode • Preemptive: scheduler called periodically (quantum-oriented) or when system state changes • Nonpreemptive: scheduler called when process terminates or blocks Operating Systems 5

Priority function Parameters • Possible parameters: – Attained service time (a) – Real time in system (r) – Total service time (t) – Period (d) – Deadline (explicit or implied by period) – External priority (e) – System load (not process-specific) Operating Systems 6

Scheduling algorithms Name FIFO: SJF: SRT: RR: ML: Decision mode Priority Arbitration nonpreemptive P=r random nonpreemptive P = –t chronological/random preemptive P = –(t–a) chronological/random preemptive P=0 cyclic preemptive P=e cyclic nonpreemptive P=e chronological • n fixed priority levels • level P is serviced when n through P+1 empty Operating Systems 7

Scheduling algorithms • MLF (Multilevel Feedback) • Like ML, but priority changes dynamically • Every process enters at highest level n • Each level P prescribes maximum time t. P • t. P increases as P decreases • Typically: tn = T (a constant) t. P = 2 t. P+1 Operating Systems 8

Scheduling algorithms • MLF priority function: – depends on level n, and attained time, a P = n– log 2(a/T+1) – derivation is in the book – but note: • there is no need to ever compute P • priority is known automatically by position in queue • MLF is preemptive: CPU is taken away whenever process exhausts t. P • Arbitration rule (at highest non-empty level): cyclic (at quantum) or chronological (at t. P) Operating Systems 9

Scheduling Algorithms RM (Rate Monotonic): – Intended for periodic (real-time) processes – Preemptive – Highest priority: shortest period: P = –d EDF (Earliest Deadline First): – Intended for periodic (real-time) processes – Preemptive – Highest priority: shortest time to next deadline: P = –(d – r % d) • derivation r d number of completed periods r%d time in current period d–r%d time remaining in current period Operating Systems 10

Comparison of Methods • FIFO, SJF, SRT: Primarily for batch systems – total length of computation is the same for all – FIFO simplest – SJF & SRT have better average turnaround times: (r 1+r 2+…+rn)/n – Example: Average turnaround times: FIFO: ((0+5)+(3+2))/2 = 5. 0 SRT: ((2+5)+(0+2))/2 = 4. 5 SJF: same as FIFO (p 1 arrived first, non-preemptive) Operating Systems 11

Comparison of Methods • Time-sharing systems – Response time is critical – Use RR or MLF with RR within each queue – Choice of quantum determines overhead • When q , RR approaches FIFO • When q 0, context switch overhead 100% • When q is much greater than context switch overhead, n processes run concurrently at 1/n CPU speed Operating Systems 12

Comparison of Methods • Real-time systems – Feasible schedule: All deadlines are met – CPU utilization is defined as: U=∑ ti/di for all pi – If schedule is feasible, U 1 (but not vice versa): • EDF always yields feasible schedule if U 1. • RM yields feasible schedule if U<0. 7 (approximately), otherwise, it may fail Operating Systems 13

Comparison of Methods • Example – p 1 has service time 1. 5, period 4 – p 2 has service time 3, period 5 – U=(1. 5/4) +3/5=. 975 < 1 – EDF succeeds but RM fails Operating Systems 14