Multitasking and scheduling

Transcription

1 Multitasking and scheduling Guillaume Salagnac Insa-Lyon IST Semester Fall 2017

2 2/39 Previously on IST-OPS: kernel vs userland pplication 1 pplication 2 VM1 VM2 OS Kernel rchitecture Hardware Each program executes on an isolated virtual machine : the processor is just for me: virtual PU the memory is just for me: virtual memory

3 3/39 Separation of mechanism and policy Principle: design for orthogonality Operating system designers try not to confuse mechanisms (and their implementation) on one hand and policies (and their specifications) on the other hand Example: vs

4 4/39 Outline 1. Introduction: the concept of a process 2. chieving multitasking through context switching 3. Scheduling: problem statement 4. Scheduling: classical algorithms 5. Evaluating a scheduling policy

5 5/39 Definitions: Multitasking vs Multiprocessing Multiprocessing, multi-core computing simultaneous execution of programs by separate processors VS Multiprogramming K multitasking ability to run several programs at the same time typically: number of PUs < number of programs

6 6/39 Pseudo-parallelism through interleaving Policy = 1 VPU / application VPU1 VPU2 VPU3 pplication pplication pplication VS t t t Mechanism = PU time-sharing PU t Note: interleaving is fine as long as the user doesn t notice

7 Degree of multiprogramming Definition: degree of multiprogramming Number of processes currently loaded in the system source: Tanenbaum. Modern Operating Systems (4th ed, 2014). page 87 7/39

8 8/39 Why do we want multiprogramming? Typically: number of PUs < number of programs also: better resource utilization

9 9/39 Why do we want multiprogramming? Empirical observation When executing, a program alternates between doing some calculations (PU burst) and waiting for data (I/O burst) PU1 I/O waiting waiting idle idle idle t PU2 I/O waiting waiting idle idle idle VS PU I/O

10 10/39 Multiprogramming: remarks Why do we have to wait? because of access latency: memory, disk, network... interactive programs have to wait for user input programs may also have to synchronize with each other ad approach: busy waiting K polling difficult to program correctly precious PU time is wasted doing nothing Solution: passive waiting K blocking easier to use: just call a blocking function better PU utilization latency hiding: overlap computations and I/O need a mechanism to share the PU

11 11/39 Illustration of a context switch between two programs Program 1 Kernel Program 2 P1 is running P1 is dormant interrupt or syscall (deal with syscall?) copy PU registers to T1 (deal with interrupt?) P2 is dormant load PU registers from T2 choose P2 RETI P2 is running

12 12/39 ontext switch: remarks dispatcher = implements the context switch executed very often must be quick (dispatch latency) scheduler = chooses which program to execute next possible that P2 = P1, e.g. after a write()... possible that P2 P1, e.g. read() blocking call ssociated kernel data structures : Process ontrol lock = P represents a running program: process number (PID), executable filename, permissions... contains one T Thread ontrol lock = T represents a virtual processor K execution context contains a copy of the PU state: registers, P, SR...

13 13/39 Outline 1. Introduction: the concept of a process 2. chieving multitasking through context switching 3. Scheduling: problem statement 4. Scheduling: classical algorithms 5. Evaluating a scheduling policy

14 14/39 What program to execute next? P1 I/O t P2 I/O P3 I/O Question: On a single PU, how should we execute this workload?

15 15/39 Naive scheduling First idea: always execute,, then, and repeat PU I/O t quite inefficient, especially for Second idea: execute as often as possible PU I/O t a lot better for, while almost the same for and

16 16/39 Not all processes want the all PU all the time PU I/O t t1 t2 at time t1: has the PU is ready to execute is waiting for an input/output request to complete at time t2: has the PU and are ready to execute

17 17/39 Process state diagram (1) New Terminated Ready Running locked Possible states for a thread: New: P/T currently being created by the kernel Running = active: currently executing on the processor Ready = activable: waits to be executed locked = sleeping: waits for some event to complete Terminated: P/T being cleaned up by the kernel

18 Process state diagram (2) New Terminated Ready 4 2 locked Running 3 Transitions: 0 P/T initialization is done 1 the dispatcher loads the thread on the PU 2 an IRQ or syscall interrupts execution 3 the program makes a blocking syscall e.g. input-output read(), delay sleep(), etc... 4 the awaited event completes e.g. data becomes available, delay expires, etc... 5 execution comes to an end (either voluntarily or abruptly) 18/39

19 19/39 Scheduling: problem statement Purpose of the PU scheduler given K threads which are ready to execute and supposing that we know some features about them given N 1 available processors decide which threads to execute on each processor Remark: when is the scheduler activated? upon each transition running blocked (3) e.g. sleep() when a process terminates (5) upon each transition blocked ready (4) upon each transition running ready (2) e.g. upon receiving and IRQ from the system timer

20 20/39 Two types of scheduling ooperative scheduler: activated only upon (3) and (5) applications explicitely yield control of the PU blocking system calls + a dedicated yield() syscall efficient but supposes to trust the applications Preemptive scheduler : activated upon (2), (3), (4) and (5) enables the kernel to stay in control of the machine system timer sends periodic IRQs to trigger preemption less efficient but allows for executing untrusted applications

21 21/39 States implemented as queues process creation dispatch Ready queue PU preemption request completed request completed Disk queue Net queue disk request network request delay expired Sleeping queue sleep()

22 22/39 Organisation des P en files: remarques Thread ontrol locks are chained together in queues Ready Queue K Run Queue Purpose of the scheduler: choose a T in the Ready Queue locked processes transfered to another queue one Device Queue for each device one queue for sleeping processes... one queue for each earson to be locked

23 23/39 Outline 1. Introduction: the concept of a process 2. chieving multitasking through context switching 3. Scheduling: problem statement 4. Scheduling: classical algorithms 5. Evaluating a scheduling policy

24 24/39 Scheduling in project management Off-line scheduling: projects, workshop, factory, etc Input: a list of tasks with their duration and dependencies ( + a list of available resources ) Output: a start date for each task ( + assignment of resources to tasks )

25 Off-line scheduling vs long-running programs Omniscient point of view P1 I/O t P2 I/O P3 I/O VS Point of view of the scheduler at t=0 The Ready Queue contains P1, P2 and P3. The PU is idle. how can we decide what to do? 25/39

26 FFS Scheduling: First ome First Served also known as FIFO (First In First Out) FFS scheduling: principle run jobs in the same order they arrived in the queue In our example: PU I/O t Remarks: inspired from real-life situations rather fair ; no risk of starvation non-preemptive scheduling short tasks (e.g. ) may be penalized 26/39

27 27/39 Execution is a sequence of bursts Heuristic For each process in the ready queue, the kernel will try and guess the duration of the next PU burst. Remark: in practice, the scheduler does not think in terms of processes or threads, but in terms of PU bursts! Point of view of the scheduler at t=0 the Ready Queue contains,, and. which process should we execute next?

28 28/39 Different types of bottlenecks In our example: and are mostly doing calculations bottleneck = PU is mostly doing intput/output bottleneck = I/O device Definitions program is said to be «compute-bound» if a faster processor would reduce its execution time program is said to be «I/O-bound» if faster intput/output would reduce its execution time variants: memory-bound, disk-bound, network-bound... Empirical observation In practice, a thread will be either compute-bound or I/O-bound.

29 Distribution of PU bursts durations source: Silberschatz Operating Systems oncepts Essentials (2011). p /39

30 30/39 SJF Scheduling: Shortest Job First SJF Scheduling: principle in the Ready Queue, pick the job with smallest execution time In our example: PU I/O t Remarks: beneficial to IO-bound processes......while not harming PU-bound processes too much risk of starvation if many short jobs arrive

31 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready t=0 PU I/O t Ready Queue:,,

32 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready t=1 PU I/O t Ready Queue:,

33 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready t=3 PU I/O t Ready Queue:,,

34 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready t=4 PU I/O t Ready Queue:,

35 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready t=5 PU I/O t Ready Queue:,

36 31/39 SRTF Scheduling: Shortest Remaining Time First SRTF Scheduling: principle like SJF but with preemption choice re-evaluated on each transition blocked ready PU I/O t Remarks: similar to SJF (with our example: result identical) preemptive: one process can t monopolize the PU but still prone to starvation

37 RR Scheduling: Round Robin Round Robin Scheduling: principle processes are given the PU each in turn kernel uses the system timer tick to measure time a burst which exceeds its time quantum gets preempted In our example, with a quantum duration q = 2 ticks: system timer IRQ PU I/O t Remarks: naturally fair and immune to starvation but how do we choose the value of q? 32/39

38 33/39 In real life: priority scheduling Priority scheduling: principle maintain several ready queues simultaneously consider them by decreasing order of priority each queue can implement a different policy: RR, SRTF... Variants: fixed priority real-time scheduling variable priority time sharing (K best-effort ) example: Multi-Level Feedback Queues Scheduling (MLFQ) with criteria to promote/demote processes MLFQ scheduling: example high priority: RR q=5ms interactive processes average priority: RR q=50ms I/O-bound tasks low priority: SRTF run PU-bound tasks in the background

39 34/39 Outline 1. Introduction: the concept of a process 2. chieving multitasking through context switching 3. Scheduling: problem statement 4. Scheduling: classical algorithms 5. Evaluating a scheduling policy

40 35/39 Evaluating a scheduling policy Evaluation methodology deterministic simulation: on a given scenario play out the algorithms, on paper or with a computer schocastic modeling queueing theory, markov chains... real system instrumentation K benchmarking impact on performance, choice of the workload... Example scenarios: task duration T1 6 T2 8 T3 3 task arrival duration T1 0 8 T2 1 4 T3 2 9 T4 3 5

41 36/39 Evaluation criteria PU utilization rate: proportion of time when the PU is active ideally, should be close to 100% Throughput: number of jobs finished by unit of time only makes sense if jobs can finish Fairness in general and non-starvation in particular a whole subject by itself Turnaround time: time elapsed between arrival and termination only makes sense if jobs can finish Waiting time: duration spent in the ready queue all time spent in the ready queue really is wasted Response time: time elapsed before first response depends on the definition of response

42 Example onsider this scenario: task arrival duration T1 0 8 T2 1 4 T3 2 9 T4 3 5 FFS T1 T2 T3 T4 SJF T1 T2 T4 T3 SRTF 1 T2 T4 T1 T3 RR q=3 T1 T2 T3 T4 T1 2 T3 T4 T1 T time (17 0) + (5 1) + (26 2) + (10 3) For SRTF: TT = 4 (10 1) (17 2) + (5 3) WT= = = 13 37/39

43 38/39 Outline 1. Introduction: the concept of a process 2. chieving multitasking through context switching 3. Scheduling: problem statement 4. Scheduling: classical algorithms 5. Evaluating a scheduling policy

44 39/39 Summary Policy vs Mechanism Multitasking vs Multiprocessing VPU vs context switch + scheduling Important concepts Dispatcher, Scheduler, Process ontrol lock, Preemption, PU-burst / IO-burst, process states, Ready Queue... Scheduling policies First ome First Served Shortest Job First, Shortest Remaining Time First Round Robin with a value for the time quantum Priority scheduling, either with fixed or dynamic priorities Multi-Level Feedback Queue Evaluation: Turnaround Time, Waiting Time...