Operating Systems
CMPSC 473
Processes (contd.)
September 01, 2010 - Lecture 4
Instructor: Bhuvan Urgaonkar
Process Switch
• Suspend the current process and resume a
previously suspended process
– Also called context switch or task switch
Process Switch
Process 0
Involuntary/Voluntary
Process 1
Context_switch() {
A1
A2
B1
B2
}
B3
B4
Process Switch
• What does the kernel need to save when suspending a
process?
– Hint: The entire address space is already saved (either in memory or
on swap space). What else would the process need when it has to be
resumed?
– CPU registers
• This is called the hardware context of the process
• Execution context, PC, pointers to elements within address
space, page table, etc.
Context_switch() {
push R0, R1, …
PCB[curr].SP = SP
PCB[curr].PT = PT
next = schedule()
// save regs on its stack
// save stack pointer
// save ptr(s) to address space
// find next process to run
PT = PCB[next].PT
SP = PCB[next].SP
pop Rn, … R0
return
}
// NOTE: Ctrl returns to another process
Overheads of Process Switch
• Direct
– The time spent switching context
• Indirect
– Cache pollution
– TLB flush
CPU Scheduling
Process Scheduling
Hmm .. Who should
I pick to run?
Running
OS (scheduler)
Ready
Lock
Waiting
Disk
When is the scheduler
invoked?
• CPU scheduling decisions may take place when a process:
1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates
• Scheduling only under 1 and 4: nonpreemptive scheduling
– E.g., FCFS and SJF
• All other scheduling is preemptive
First-Come, First-Served Scheduling
(FCFS)
Process
Run Time
P1
24
P2
3
P3
3
• Suppose that the processes arrive in the order: P1 , P2 , P3
The Gantt Chart for the schedule is:
P1
0
P2
24
• Waiting time for P1 = 0; P2 = 24; P3 = 27
• Average waiting time: (0 + 24 + 27)/3 = 17
P3
27
30
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order
P2 , P3 , P1
• The Gantt chart for the schedule is:
P2
0
•
•
•
•
P3
3
P1
6
Waiting time for P1 = 6; P2 = 0; P3 = 3
Average waiting time: (6 + 0 + 3)/3 = 3
Much better than previous case
Convoy effect short process behind long process
30
Choosing the Right Scheduling
Algorithm/Scheduling Criteria
• CPU utilization – keep the CPU as busy as possible
• Throughput – # of processes that complete their execution
per time unit
• Turnaround time – amount of time to execute a particular
process
• Waiting time – amount of time a process has been waiting in
the ready queue
• Response time – amount of time it takes from when a
request was submitted until the first response is produced,
not output (for time-sharing environment)
• Fairness
Shortest-Job-First (SJF)
Scheduling
• Associate with each process the length of its next CPU
burst. Use these lengths to schedule the process with the
shortest time
• SJF is optimal for avg. waiting time – gives minimum
average waiting time for a given set of processes
– In class: Compute average waiting time for the previous example
with SJF
– Exercise: Prove the optimality claimed above
Why Pre-emption is
Necessary
• To improve CPU utilization
– Most processes are not ready at all times during their lifetimes
– E.g., think of a text editor waiting for input from the keyboard
– Also improves I/O utilization
• To improve responsiveness
– Many processes would prefer “slow but steady progress” over “long wait
followed by fast process”
• Most modern CPU schedulers are pre-emptive
SJF: Variations on the
• Non-preemptive: once CPU given to the process it cannot theme
be
preempted until completes its CPU burst - the SJF we already saw
• Preemptive: if a new process arrives with CPU length less
than remaining time of current executing process, preempt.
This scheme is know as Shortest-Remaining-Time-First (SRTF)
 Also called Shortest Remaining Processing Time (SRPT)
• Why SJF/SRTF may not be practical
 CPU requirement of a process rarely known in advance
Round Robin (RR)
• Each process gets a small unit of CPU time (time
quantum), usually 10-100 milliseconds. After this time
has elapsed, the process is preempted and added to the
end of the ready queue.
• If there are n processes in the ready queue and the time
quantum is q, then each process gets 1/n of the CPU
time in chunks of at most q time units at once. No
process waits more than (n-1)q time units.
• Performance
– q large => FCFS
– q small => q must be large with respect to context
switch, otherwise overhead is too high
Example of RR with Time
Quantum = 20
Process
P1
P2
P3
P4
CPU Time
53
17
68
24
• The Gantt chart is:
P1
0
P2
20
37
P3
P4
57
P1
77
P3
97 117
P4
P1
P3
P3
121 134 154 162
• Typically, higher average turnaround than SJF, but better response
Time Quantum and Context Switch
Time
Turnaround Time Varies With Time Quantum
Proportional-Share
A generalization of round robin
Schedulers
Process P given a CPU weight w > 0
•
•
i
i
• The scheduler needs to ensure the following
– forall i, j, |Ti(t1, t2)/Tj(t1,t2) - wi/wj| ≤ e
– Given Pi and Pj were backlogged during [t1,t2]
• Who chooses the weights and how?
• Application modeling problem: non-trivial
• Many PS schedulers developed in the 90s
– E.g., Start-time Fair Queueing (Qlinux UT-Austin/Umass-Amherst)
Lottery Scheduling
[Carl Waldspurger, MIT, ~1995]
•
•
Perhaps the simplest proportional-share scheduler
Create lottery tickets equal to the sum of the weights of all processes
– What if the weights are non-integral?
•
Draw a lottery ticket and schedule the process that owns that ticket
– What if the process is not ready?
• Draw tickets only for ready processes
– Exercise: Calculate the time/space complexity of the operations Lottery scheduling will
involve
Lottery Scheduling Example
P1=6
P2=9
1
4
7
10
13
2
5
8
11
14
3
6
9
12
15
9
Schedule P2
Lottery Scheduling Example
P1=6
P2=9
1
4
7
10
13
2
5
8
11
14
3
6
9
12
15
3
Schedule P1
Lottery Scheduling Example
P1=6
P2=9
1
4
7
10
13
2
5
8
11
14
3
6
9
12
15
11
•
•
•
As t
∞, processes will get their share (unless they were blocked a lot)
Problem with Lottery scheduling: Only probabilistic guarantee
What does the scheduler have to do
–
–
When a new process arrives?
When a process terminates?
Schedule P2