Job scheduling
Queue discipline
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
• 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.
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
Burst DurationF
requ
ency
Scheduling Evaluation Metrics
• CPU utilization: % of time the CPU is not idle ()• 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
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
First-Come, First-ServedProcess
A
B
C
Burst Time
8
1
1
• Avg Wait Time (0 + 8 + 9) / 3 = 5.7
0 8 9 10
A B CGanttChart
FCFS(FIFO) and LCFS(LIFO)
• 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
Shortest Job First (SJF)
longshort
long short
– Choose the job with the shortest next CPU burst
– Provably optimal for minimizing average waiting time
Shortest Job First
0 1 2 10
AB C
• Avg Wait Time (0 + 1 + 2) / 3 = 1
Process
A
B
C
Burst Time
8
1
1
SFJ VariantsTwo 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)
Example of Non-Preemptive SJFProcess Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (non-preemptive)
P1 P3 P2
73 160
P4
8 12
•Average waiting time = (0 + 6 + 3 + 7)/4 = 4
Preemptive SJF (SRPT)Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (preemptive)
P1 P3P2
42 110
P4
5 7
P2 P1
16
•Average waiting time = (9 + 1 + 0 +2)/4 = 3
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
Priority Scheduling• SJF is a special case
Process
A
B
C
Burst Time
8
1
1
Priority
2
1
3
0 1 9 10
AB C
Avg Wait Time (0 + 1 + 9) / 3 = 3.3
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
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
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
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
P5 7
2
0
15
1
23
0
11
0
7
0
15
3
0
7
0
0
0
8
14
22
30
38
41
41
29
29
22
19
17
15
15
3
41
86051703875
343 / 7 = 49.00
Round Robin Fun
Process
A
B
C
Burst Time
10
10
10
• Wait time?• q = 10• q = 1• q --> 0
•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)
Fun with SchedulingProcess
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
Multi-Level Queues• Ready queue is partitioned into separate queues.
• Each queue has its own scheduling algorithm.• Scheduling must be done between the queues
SystemPriority 1
Priority 2
Priority 3
Interactive
Batch
... ...
MQ-Fixed Priority SchedulingQueues 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
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
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”
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
Windows NT Scheduling
• Basic scheduling unit is a thread
• Priority based scheduling per thread
• Preemptive operating system
• No shortest job first, no quotas
Priority Assignment• NT kernel uses 31 priority levels
– 31 is the highest; 0 is system idle thread– Realtime priorities: 16 - 31– Dynamic priorities: 1 - 15
• 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
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?