Date post: | 28-Dec-2015 |
Category: |
Documents |
Upload: | leslie-dickerson |
View: | 223 times |
Download: | 0 times |
1
Fair Resource Access & Allocation OS Scheduling
2
Scheduling Criteria (Optimization)
• CPU utilization: keep CPU as busy as possible (maximize)
• Throughput: # of processes completed/time unit (maximize)
• Turnaround time: average amount of time to execute a particular process (minimize)
• Waiting time: process wait time in ready queue (minimize)• Response time (min): amount of time it takes from when a
request was submitted until the first response (not output) is produced. [result output time = RT deadline]
Optimize all plus want “Fair & Efficient” solutions!
3
1. Task/Process/Thread Types
• Non pre-emptive (NP): An ongoing task cannot be displaced
• Pre-emptive: Ongoing tasks can be switched in/out as needed
4
2. Sequences of CPU And I/O Bursts
Patterns can be CPU or I/O-bound
5
A: First-Come, First-Served (FCFS) Scheduling
Process Length (CPU Burst Time)
P1 24
P2 3
P3 3
• Suppose the processes arrive in the order: P1 , P2 , P3
Gantt Chart for the schedule (single queue of ready processes: NP):
• Waiting time for P1 = 0; P2 = 24; P3 = 27• Average waiting time: (0 + 24 + 27)/3 = 17
P1 P2 P3
24 27 300
6
FCFS Scheduling (NP: Non-Preemptive)
Suppose that the processes arrive in the order
P2 , P3 , P1
• Gantt chart for the schedule:
• Waiting time for P1 = 6; P2 = 0; P3 = 3
• Average waiting time: (6 + 0 + 3)/3 = 3
Variability of wait time – control? Convoy effect: cluster short processes behind long process (starvation
possible!)
P1P3P2
63 300
7
Scheduling in Batch Systems
Shortest job first (SJF) scheduling
8
B: 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
Options: non-preemptive – once CPU given to the process it cannot be preempted
until it completes its CPU burst
– preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt.
… Shortest-Remaining-Time-First (SRTF)
9
Process Arrival Time Burst Time
P1 0.00 7
P2 0.0+ 4
P3 0.0+ 1
P4 0.0+ 4
• SJF (non-preemptive) P1, then P3 then P2, P4 (FCFS here)
• Average waiting time = (0 + 8 + 7 + 12)/4 = 6.75 (fixed arrival)
• Av. waiting = (0 + [8-2] + [7-4] + [12-5])/4 = 4.00 (staggered arrival)
Example of Non-Preemptive SJF
P1 P3 P2
73 160
P4
8 12
0.0
2.0
4.0
5.0
10
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
Options: – non-preemptive – once CPU given to the process it cannot be preempted
until it completes its CPU burst preemptive – if a new process arrives with CPU burst length less than
remaining time of current executing process, preempt. … Shortest-Remaining-Time-First (SRTF)
11
Preemptive SJF(Shortest Remaining Time First)
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (preemptive)
• Average waiting time = P1:[0, (11-2)]; P2:[0, (5-4)]; P3: 0; P4: (7-5)
• Average waiting time = (9 + 1 + 0 +2)/4 = 3 …[6.75;4.00]
• Dynamic scheduling (SRT) calculations: cost factor!
P1 P3P2
42 110
P4
5 7
P2 P1
16
P1: 5 left P2: 2 left P2:2, P4:4, P1:5
12
Determining Length of Next CPU Burst
• Can only estimate the length (easy for batch jobs)
• Use the length of previous CPU bursts (history logs)
nn 1
:Define 4.
1;0 , 3.
burst CPUnext for the valuepredicted 2.
burst CPU oflength actual 1.
1
n
thn nt
.1 1 nnn t
nn t1
(0) direct fn. of history
(1) direct fn. of most recent run
13
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
Options: – non-preemptive – once CPU given to the process it cannot be preempted until completes
its CPU burst
– preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. Shortest-Remaining-Time-First (SRTF)
• SJF is optimal – gives minimum average waiting time for a given set of processes
• SJF can still lead to starvation: if new short jobs keep coming in and getting considered in the “shortest” ranking, a “long” job can potentially starve!
14
Variations
• SJF EDF (Earliest Deadline First)
15
C: Round Robin (RR/TDMA): Fixed Slots• Each process gets a fixed slice of CPU time (time quantum: q), 10-100ms
– After this time has elapsed, the process is “forcefully” 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 too large FIFO (poor response time & poor CPU utilization)– q too small q must be large with respect to context switch ovhd.,
else context switching overhead reduces efficiency
ReadyQ
16
Example of RR with Time Quantum = 20(Dynamic Q: if a process finishes in less than 20, then the next slot starts earlier!)
Process Burst TimeP1 53 P2 17 P3 68 P4 24
• Gantt chart:
• Typically, higher average turnaround than SJF, but better response– Turnaround time – amount of time to execute a particular process (minimize)– Response time (min) – amount of time it takes from request submission until first response
• Scheduling is static though calculating/estimation “right” length of quantum is crucial!!!
• Possible to have quanta of varying lengths!!! (dynamic scheduling costs ~ SJF)
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162
17
D: Priority Scheduling
• A priority number (integer) is associated with each process• The CPU is allocated to process with the highest priority
(For Unix BSD: smallest integer highest priority)
– Preemptive
– Non-preemptive
SJF is a priority scheduling where priority is the predicted next CPU burst time
• Problem Starvation: low priority processes may never execute– also…remember priority-inversion case? Interrupt Disabling for ME? Spinlock cases?
• Solution Aging: as time progresses increase priority of process
18
Priority Scheduling (Solaris, Windows, Linux)
* Kernel process: generally non-preemptive; User processes: pre-emptable• Priority can be static or dynamic (fn. time for fairness etc)
P_user-pri = P_USER + P_cpu/4 + (2 * P_nice)
process using CPU: P_cpu increases with time P_user-pri goes up (BSD: large # =‘s low priority )
process waiting: P_cpu keeps decreasing P_user-pri keeps going down ( higher priority)
(FCFS within a priority level)
Higher Priority: Small quantaLower Priority: Bigger quanta
19
Scheduling in Real-Time Systems Hard/Firm/Soft Real-time: Missing deadline catastrophic/acceptable
Issues: Priority, periodicity, compute time, deadlines
• Periodic Task Model: Process assigned static priority based on their run_length (or period): Shortest Period Highest Priority (RM)
Schedulable real-time system, given:• m periodic events• event i occurs within period Pi and requires Ci seconds
– Then the load can only be handled if
• Composite Periodic/A periodic Model: Dynamic priority with highest priority to task whose deadline is closest! EDF: Earliest Deadline First
1
1m
i
i i
C
P
20
Thread Scheduling
• Local Scheduling – How the threads library decides which thread to put onto an available LWP
• Global Scheduling – How the kernel decides which kernel thread to run next
21
Thread Scheduling (User Scheduler)
Possible scheduling of user-level threads• 50-msec process quantum; threads run 5 msec/CPU burst• simple process level context switch; thread block process blocks• split level scheduling (kernel + dedicated application/thread type specific)
22
Thread Scheduling (Kernel Scheduler)
Possible scheduling of kernel-level threads• 50-msec process quantum; threads run 5 msec/CPU burst• flexible…costly full context switch for threads• monolithic kernel scheduler also avoids thread blocks (on I/O etc)
23
OS Examples
• Solaris scheduling
• Windows XP scheduling
• Linux scheduling
24
Solaris 2 Scheduling
25
Solaris Dispatch Table
* Lowest priority 0 (diff. from BSD) is given largest quantum* TQE: new (reduced) priority for tasks that have used quanta without blocking* RFS: (raised) priority of awakened tasks
26
Windows XP: Priority Based, Preemptive
priority classes
relative priority within a priority class (High # =‘s High Priority; diff. from BSD)
27
Linux Scheduling
Two algorithms: time-sharing and real-time• Time-sharing
– Prioritized credit-based – process with most credits is scheduled next
– Credit subtracted when timer interrupt occurs– When credit = 0, another process chosen– When all processes have credit = 0, re-crediting occurs
• Based on factors including priority and history
• Real-time– Soft real-time– Two classes
• FCFS and RR• Highest priority process always runs first