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

8. 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

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 11 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?