Presentation is loading. Please wait.

Presentation is loading. Please wait.

Job scheduling Queue discipline.

Similar presentations

Presentation on theme: "Job scheduling Queue discipline."— Presentation transcript:

1 Job scheduling Queue discipline

2 Scheduling • Modern computers have many processes/threads that want to run concurrently The scheduler is the manager of the CPU resource • It makes allocation decisions – it chooses to run certain processes over others from the ready queue – Zero threads: just loop in the idle loop – One thread: just execute that thread – More than one thread: now the scheduler has to make a resource allocation decision • The scheduling algorithm determines how jobs are scheduled

3 • Threads alternate between performing I/O and performing computation
• In general, the scheduler runs: – when a process switches from running to waiting – when a process is created or terminated – when an interrupt occurs • In a non-preemptive system, the scheduler waits for a running process to explicitly block, terminate or yield • In a preemptive system, the scheduler can interrupt a process that is running.

4 Process states Processes are I/O-bound when they spend most of their time in the waiting state Processes are CPU-bound when they spend their time in the ready and running states Time spent in each entry into the running state is called a CPU burst Frequency Burst Duration

5 Scheduling Evaluation Metrics
CPU utilization: % of time the CPU is not idle (r) Throughput: completed processes per unit time Turnaround time: submission to completion (R) Waiting time: time spent on the ready queue (W) The right metric depends on the context

6 Evaluating Scheduling Algorithms
Queueing theory Mathematical techniques Uses probablistic models of jobs / CPU utilization Simulation Probabilistic(e.g. Taylor) or trace-driven Deterministic methods / Gantt charts Use more realistic workloads

7 First-Come, First-Served
Process A B C Burst Time 8 1 8 9 10 A B C Gantt Chart Avg Wait Time ( ) / 3 = 5.7

Problems with FCFS Average waiting time can be large if small jobs wait behind long ones (convoy effect) May lead to poor overlap of I/O and CPU time Problems with LCFS May lead to starvation – early processes may never get the CPU

9 Shortest Job First (SJF)
long short – Choose the job with the shortest next CPU burst – Provably optimal for minimizing average waiting time

10 Shortest Job First 1 2 10 A B C Process A B C Burst Time 8 1
1 2 10 A B C Avg Wait Time ( ) / 3 = 1

11 SFJ Variants Two Schemes:
i) Non-Preemptive -- Once CPU given to the job, it cannot be preempted until it completes its CPU burst. ii) Preemptive -- If a new job arrives with CPU burst length shorter than remaining time of the current executing job -- preempt. (Shortest remaining time first or SRPT)

12 Example of Non-Preemptive SJF
Process Arrival Time Burst Time P P P P SJF (non-preemptive) P1 P3 P2 7 3 16 P4 8 12 Average waiting time = ( )/4 = 4

13 Preemptive SJF (SRPT) SJF (preemptive)
Process Arrival Time Burst Time P P P P SJF (preemptive) P1 P3 P2 4 2 11 P4 5 7 16 Average waiting time = ( )/4 = 3

14 Problems with SJF Impossible to predict CPU burst times
Schemes based on previous history (e.g. exponential averaging) SJF may lead to starvation of long jobs Solution to starvation- Age processes: increase priority as a function of waiting time

15 Priority Scheduling 1 9 10 A B C SJF is a special case Process A B C
Burst Time 8 1 Priority 2 1 3 1 9 10 A B C Avg Wait Time ( ) / 3 = 3.3

16 Priority Scheduling Criteria?
Internal open files memory requirements CPU time used - time slice expired (RR) process age - I/O wait completed External $ department sponsoring work process importance super-user (root) - nice

17 Round robin (RR) Often used for timesharing
Ready queue is treated as a circular queue (FIFO) Each process is given a time slice called a quantum (q) – It is run for the quantum or until it finishes – RR allocates the CPU uniformly (fairly) across all participants. If average queue length is n, each participant gets 1/n

18 Example of Round Robin (q=8)
Process P1 P2 P3 P4 P5 P6 P7 Burst Time 10 6 23 9 31 3 19 Wait Times 41 8 60 51 70 38 75 2 41 8 15 7 14 29 17 1 22 29 23 15 7 30 22 15 3 38 11 3 41 19 15 P1 8 P2 6 P3 8 P4 8 P5 8 P6 3 P7 8 P1 2 P3 8 P4 1 P5 8 P7 8 P3 7 P5 8 P7 3 343 / 7 = 49.00 P5 7

19 Round Robin Fun Wait time? Process A B C Burst Time 10 q = 10 q = 1
As the time quantum grows, RR becomes FCFS Smaller quanta are generally desirable, because they improve response time • Problem: Overhead of frequent context switch As q  0, we get processor sharing (PSRR)

20 Fun with Scheduling Process A B C Burst Time 10 1 2 Priority 2 1 3
Gantt Charts: FCFS SJF Priority RR (q=1) Performance: Throughput Waiting time Turnaround time

21 Multi-Level Queues ... System Interactive Batch
Ready queue is partitioned into separate queues. System Priority 1 Priority 2 Priority 3 Interactive Batch ... Each queue has its own scheduling algorithm. Scheduling must be done between the queues

22 MQ-Fixed Priority Scheduling
Queues A, B, C... Serve all from A then from B... If serving queue B and process arrives in A, then start serving A again: i1) Preemptive -- As soon as processes arrive in A (preempt, if serving from B) i2) Non-preemptive -- Wait until process from B finishes starvation is possible -- processes do not move between queues

23 MQ-Time Slice Allocation
Each queue gets a certain amount of CPU time which it can schedule amongst its processes Example 80% to foreground in RR 20% to background in FCFS

24 Linux Process Scheduling
Two classes of processes: Real-Time Normal Real-Time: Always run Real-Time above Normal Round-Robin or FIFO “Soft” not “Hard”

25 Linux Process Scheduling
Normal: Credit-Based process with most credits is selected time-slice then lose a credit (0, then suspend) no runnable process (all suspended), add to every process: credits = credits/2 + priority Automatically favors I/O bound processes

26 Windows NT Scheduling Basic scheduling unit is a thread
Priority based scheduling per thread Preemptive operating system No shortest job first, no quotas

27 Priority Assignment NT kernel uses 31 priority levels
31 is the highest; 0 is system idle thread Realtime priorities: Dynamic priorities: Users specify a priority class: realtime (24) , high (13), normal (8) and idle (4) and a relative priority: highest (+2), above normal (+1), normal (0), below normal (-1), and lowest (-2) to establish the starting priority Threads also have a current priority

28 Quantum Determines how long a Thread runs once selected
Varies based on: NT Workstation or NT Server Intel or Alpha hardware Foreground/Background application threads How do you think it varies with each?

Download ppt "Job scheduling Queue discipline."

Similar presentations

Ads by Google