cpu scheduling - department of...
TRANSCRIPT
Lesson 3: Processes, Threads & CPU Scheduling
Lesson 3/Page 2AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Contents� The concept of computing Process� Process states and life-cycle� CPU Scheduling considerations� Processes hierarchy� Process creation and termination� Inter-process communication schemes� Synchronization among processes� Threads, relationship to processes� Multithreading models� CPU Scheduling Criteria & Optimization� Priority Scheduling� Queuing and Queues Organization� Deadline Real-Time CPU Scheduling
Lesson 3/Page 3AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Concept� An operating system executes a
variety of programs:� Batch system – jobs� Time-shared systems – user programs or
tasks� Textbooks use the terms job and
process almost interchangeably� Process is a program in execution;
process execution must progress in sequential fashion
� A process includes:� program counter � stack� data section� code (“text”) controls the execution
� does not necessarily be a part of a single process – can be shared
Lesson 3/Page 4AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process States� As a process executes, it changes its state
� new : The process is being created� running : Instructions are being executed� waiting : The process is waiting for some event to occur� ready : The process is waiting to be assigned to a CPU� terminated : The process has finished execution
Lesson 3/Page 5AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Control Block (PCB)
Information associated with each process� Process state� Program counter� CPU registers� CPU scheduling information� Memory-management information� Accounting information� I/O status information � Environment variables
Lesson 3/Page 6AE3B33OSD Silberschatz, Galvin and Gagne ©2005
CPU Switch from Process to Process
� Sometimes call context switch
Lesson 3/Page 7AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Scheduling Queues
� Why Scheduling?� Necessity to decide which process can get CPU cycles
� Job queue – set of all processes in the system� Ready queue – set of all processes residing in main
memory, ready and waiting to execute� Device queues – set of processes waiting for an I/O
device� Processes migrate among the various queues
Lesson 3/Page 8AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Ready Queue and Various I/O Device Queues
Lesson 3/Page 9AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Simplified Model of Process Scheduling
Lesson 3/Page 10AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Schedulers
� Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue� Long-term scheduler is invoked very infrequently (seconds,
minutes) ⇒ (may be slow)� The long-term scheduler controls the degree of
multiprogramming
� Short-term scheduler (or CPU scheduler) – selects which process should be executed next and allocates CPU� Short-term scheduler is invoked very frequently (milliseconds) ⇒ (must be fast)
� Processes can be described as either:� I/O-bound process – spends more time doing I/O than
computations, has many short CPU bursts� CPU-bound process – computationally intensive – spends
much time doing computations; few very long CPU bursts� usually able to ‘eat’ all CPU capacity
Lesson 3/Page 11AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Context Switch
� When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process
� Context-switch time is overhead; the system does no useful work while switching� Should be very fast
� Time dependent on hardware support� Hardware designers try to support routine context-switch
actions like saving/restoring all CPU registers by one pair of machine instructions
Lesson 3/Page 12AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Creation� Parent process create children processes
� Children, in turn create other processes, forming a tree of processes
� Resource sharing� Parent and children share all resources� Children share subset of parent’s resources� Parent and child share no resources
� Execution� Parent and children can execute concurrently, or� Parent can wait until children terminate
� Address space� Child duplicate of parent� Child has a program loaded into it
� POSIX examples� fork system call creates new process� exec system call used after a fork to replace the process’
memory space with a new program
Lesson 3/Page 13AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Creation Illustrated
Tree of processes
POSIX parent process waiting for its child to finish
Lesson 3/Page 14AE3B33OSD Silberschatz, Galvin and Gagne ©2005
C Program Forking Separate Process
int main(){Pid_t pid;
/* fork another process */pid = fork();if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");exit(-1);
}else if (pid == 0) { /* child process */
execl ("/bin/ls", "ls", NULL);}else { /* parent process */
/* parent will wait for the child to complete */wait (NULL);printf ("Child Complete");exit(0);
}}
Lesson 3/Page 15AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Termination
� Process executes last statement and asks the operating system to delete it (_exit )� Output data from child to parent (via wait )� Process’ resources are deallocated by operating system
� Parent may terminate execution of children processes (abort )� Child has exceeded allocated resources� Task assigned to child is no longer required� If parent is exiting
� Some operating system do not allow children to continue if the parent terminates – the problem of ‘zombie’
� All children terminated - cascading termination
Lesson 3/Page 16AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Cooperating Processes
� Independent process cannot affect or be affected by the execution of another process
� Cooperating process can affect or be affected by the execution of another process
� Advantages of process cooperation� Information sharing � Computation speed-up� Modularity� Convenience
� Producer-Consumer Problem� Paradigm for cooperating processes, producer process
produces information that is consumed by a consumer process� unbounded-buffer places no practical limit on the size of the buffer� bounded-buffer assumes that there is a fixed buffer size
Lesson 3/Page 17AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Inter-Process Communication (IPC)
� Mechanism for processes to communicate and to synchronize their actions
� Message system – processes communicate with each other without resorting to shared variables
� IPC facility provides two operations:� send (message) – message size fixed or variable � receive (message)
� If P and Q wish to communicate, they need to:� establish a communication link between them� exchange messages via send/receive
� Implementation of communication link� physical (e.g., shared memory, hardware bus)� logical (e.g., logical properties)
Lesson 3/Page 18AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Direct & Indirect Communication� Direct Communication
� Processes must name each other explicitly:� send (P, message) – send a message to process P� receive (Q, message) – receive a message from process Q
� Properties of communication link� Links are established automatically� A link is associated with exactly one pair of communicating processes� Between each pair there exists exactly one link� The link may be unidirectional, but is usually bi-directional
� Indirect Communication� Messages are directed and received from mailboxes (also referred
to as ports)� Each mailbox has a unique id and is created by the kernel on request� Processes can communicate only if they share a mailbox
� Properties of communication link� Link established only if processes share a common mailbox� A link may be associated with many processes� Each pair of processes may share several communication links� Link may be unidirectional or bi-directional
Lesson 3/Page 19AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Synchronization� Message passing may be either blocking or non-
blocking� Blocking is considered synchronous
� Blocking send: the sender blocks until the message is received by the other party
� Blocking receive: the receiver block until a message is available
� Non-blocking is considered asynchronous� Non-blocking send: the sender sends the message and
continues executing� Non-blocking receive: the receiver gets either a valid
message or a null message (when nothing has been sent to the receiver)
� Often a combination is used:� Non-blocking send and blocking receive
Lesson 3/Page 20AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Single and Multithreaded Processes
� Benefits of Multithreading� Responsiveness� Easy Resource Sharing� Economy� Utilization of Multi-processor Architectures (?)
Lesson 3/Page 21AE3B33OSD Silberschatz, Galvin and Gagne ©2005
User & Kernel Threads� User-level Threads
� All thread management done by user-level threads library� application programmer can influence the scheduling strategies
� Kernel knows nothing about threads (considers only processes)� OSK cannot manage and schedule threads
� Three primary thread libraries:� POSIX Pthreads� Win32 threads� Java threads
� Kernel-level Threads� Threads supported by the OS Kernel� Examples
� Windows XP/2000� Linux� Mac OS X� Tru64 UNIX
Lesson 3/Page 22AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Multithreading Models� Many-to-One
� Many user-level threads mapped to single kernel thread
� Examples:� Solaris Green Threads� POSIX Threads (PThreads)
� One-to-One� Each user-level thread maps to kernel thread� Examples
� Windows NT/XP/2000� Linux� PThreads – if OSK
supports multi-threading
� Many-to-Many� Complicated, with few
benefits, seldom used
Lesson 3/Page 23AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Basic Concepts of CPU Scheduling� Maximum CPU utilization
obtained with multiprogramming� CPU–I/O Burst Cycle – Process
execution consists of a cycle of CPU execution and I/O wait
� CPU burst distribution
Lesson 3/Page 24AE3B33OSD Silberschatz, Galvin and Gagne ©2005
CPU Scheduler� Selects from among the processes in memory that are
ready to execute, and allocates the CPU to one of them� CPU scheduling decisions may take place when a
process:1. Switches from running to waiting state2. Switches from waiting to ready3. Switches from running to ready state4. Terminates
� Switches under 1, 2 and 4 are non-preemptive� If switch No. 3 is included, scheduling is preemptive� Any of these situations is caused by some interrupt
� scheduler is interrupt driven
Lesson 3/Page 25AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process forcibly removed from a CPU even though it is capable further execution (e.g., time quantum exhausted) – preemption. Thistransition does NOT exist in non-preemptive scheduling!
p
Process terminates (either by itself or by “abort”) – exit x
An event causing service completion occurred – the process can continue
e
Process requests a service and must wait for its completionw
Process gets CPU (can execute) – run r
Process is created – start s
MeaningTransition
Process state diagram revisited
New Running TerminatedReady
Waiting
s
r
xp
we
CPU short-time Scheduler
Lesson 3/Page 26AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Dispatcher
� Dispatcher module gives control of the CPU to the process (thread) selected by the short-term scheduler; this involves:� switching context� switching to user mode� jumping to the proper location in the user program to restart that
program
� Dispatch latency – time it takes for the dispatcher to stop one process and start another running – overhead
Lesson 3/Page 27AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Scheduling Criteria & Optimization
� CPU utilization – keep the CPU as busy as possible� Maximize CPU utilization
� Throughput – # of processes that complete their execution per time unit� Maximize throughput
� Turnaround time – amount of time to execute a particular process� Minimize turnaround time
� Waiting time – amount of time a process has been waiting in the ready queue� Minimize waiting time
� Response time – amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing and interactive environment )� Minimize response time
Lesson 3/Page 28AE3B33OSD Silberschatz, Galvin and Gagne ©2005
First-Come, First-Served (FCFS) Scheduling
Process Burst TimeP1 24P2 3P3 3
� Suppose that the processes arrive in the order: P1 , P2, P3 The Gantt Chart for the schedule is:
� Waiting time for P1 = 0; P2 = 24; P3 = 27� Average waiting time: (0 + 24 + 27)/3 = 17
P1 P2 P3
24 27 300
Lesson 3/Page 29AE3B33OSD Silberschatz, Galvin and Gagne ©2005
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the orderP2 , P3 , P1
� The Gantt chart for the schedule is:
� 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
P1P3P2
63 300
Lesson 3/Page 30AE3B33OSD Silberschatz, Galvin and Gagne ©2005
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
� Two schemes: � nonpreemptive – 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. This scheme is know as the Shortest-Remaining-Time-First (SRTF)
� SJF is optimal – gives minimum average waiting time for a given set of processes
Lesson 3/Page 31AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Process Arrival Time Burst TimeP1 0.0 7P2 2.0 4P3 4.0 1P4 5.0 4
� SJF (non-preemptive)
� Average waiting time = (0 + 6 + 3 + 7)/4 = 4
Example of Non-Preemptive SJF
P1 P3 P2
73 160
P4
8 12
Lesson 3/Page 32AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Example of Preemptive SJF
Process Arrival Time Burst TimeP1 0.0 7P2 2.0 4P3 4.0 1P4 5.0 4
� SJF (preemptive)
� Average waiting time = (9 + 1 + 0 +2)/4 = 3
P1 P3P2
42 110
P4
5 7
P2 P1
16
Lesson 3/Page 33AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Problem: Determining Length of Next CPU Burst
� Can only estimate the length� Can be done by using the length of previous CPU bursts,
using exponential averaging
:Define 4.
10 , 3.
burst CPU next the for value predicted 2.
burst CPU of lenght actual 1.
1
≤≤=
=
+
αατ n
th
n nt
( ) .11 nnn t ταατ −+=+
Lesson 3/Page 34AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Examples of Exponential Averaging
� α =0� τn+1 = τn
� History does not count at all
� α =1� τn+1 = α tn� Only the actual last CPU burst counts
� If we expand the formula, we get:τn+1 = α tn+(1 - α)α tn -1 + …
+(1 - α )j α tn -j + …+(1 - α )n +1 τ0
� Since both α and (1 - α) are less than or equal to 1, each successive term has less weight than its predecessor
Lesson 3/Page 35AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Priority Scheduling
� A priority number (integer) is associated with each process
� The CPU is allocated to the process with the highest priority (usually smallest integer → highest priority)� Preemptive� Nonpreemptive
� SJF is a priority scheduling where the priority is the predicted next CPU burst time
� Problem: Starvation – low priority processes may never execute
� Solution: Aging – as time progresses increase the priority of the process
Lesson 3/Page 36AE3B33OSD Silberschatz, Galvin and Gagne ©2005
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 – how to choose q ?� q large ⇒ FCFS� q small ⇒ q must be large with respect to context switch,
otherwise overhead is too high
Lesson 3/Page 37AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Example of RR with Time Quantum = 20
Process Burst TimeP1 53P2 17P3 68P4 24
� The Gantt chart is:
� Typically, higher average turnaround then SJF, but better response
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162
Lesson 3/Page 38AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Time Quantum and Context Switch Time
Turnaround Time Varies With the Time Quantum
Lesson 3/Page 39AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Multilevel Queue� Ready queue is partitioned into separate queues:
foreground (interactive)background (batch)
� Each queue has its own scheduling algorithm� foreground – RR� background – FCFS
� Scheduling must be done between the queues� Fixed priority scheduling; (i.e., serve all from foreground then
from background). Danger of starvation.� Time slice – each queue gets a certain amount of CPU time
which it can schedule amongst its processes; i.e., 80% to foreground in RR
� 20% to background in FCFS
Lesson 3/Page 40AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Multilevel Queue Scheduling
Lesson 3/Page 41AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Multilevel Feedback Queue
� A process can move between the various queues� aging can be treated this way
� Multilevel-feedback-queue scheduler defined by the following parameters:� number of queues� scheduling algorithms for each queue� method used to determine when to upgrade a process� method used to determine when to demote a process� method used to determine which queue a process will enter
when that process needs service
Lesson 3/Page 42AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Example of Multilevel Feedback Queue� Three queues:
� Q0 – RR with time quantum 8 milliseconds� Q1 – RR time quantum 16 milliseconds� Q2 – FCFS
� Scheduling� A new job enters queue Q0. When it gains CPU, job receives 8
milliseconds. If it exhausts 8 milliseconds, job is moved to queue Q1.
� At Q1 the job receives 16 additional milliseconds. If it still does not complete, it is preempted and moved to queue Q2.
Lesson 3/Page 43AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Multiple-Processor Scheduling� CPU scheduling more complex when multiple CPUs are
available� Multiple-Processor Scheduling has to decide not only which
process to execute but also where (i.e. on which CPU) to execute it
� Homogeneous processors within a multiprocessor� Asymmetric multiprocessing – only one processor
accesses the system data structures� alleviating the need for data sharing
� Symmetric multiprocessing (SMP) – each processor is self-scheduling, all processes in common ready queue, or each has its own private queue of ready processes
� Processor affinity – process has affinity for the processor on which it has been recently running� Reason: Some data might be still in cache� Soft affinity is usually used – the process can migrate among
CPUs
Lesson 3/Page 44AE3B33OSD Silberschatz, Galvin and Gagne ©2005
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
� Pthreads library has calls to choose different scheduling policies and parameters
Lesson 3/Page 45AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Windows XP Priorities
Priority classes (assigned to each process)R
ela
tive
prio
ritie
s w
ithin
eac
h cl
ass
� Relative priority “normal” is a base priority for each class – starting priority of the thread
� When the thread exhausts its quantum, the priority is lowered� When the thread comes from a wait-state, the priority is increased
depending on the reason for waiting � A thread released from waiting for keyboard or mouse gets more boost
than a thread having been waiting for disk I/O
Lesson 3/Page 46AE3B33OSD Silberschatz, Galvin and Gagne ©2005
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, recrediting occurs
� Based on factors including priority and history
� Real-time� Soft real-time� POSIX.1b compliant – two classes
� FCFS and RR� Highest priority process always runs first
Lesson 3/Page 47AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Real-Time Systems
� A real-time system requires that results be not only correct but in time� produced within a specified deadline period
� An embedded system is a computing device that is part of a larger system � automobile, airliner, dishwasher, ...
� A safety-critical system is a real-time system with catastrophic results in case of failure� e.g., railway traffic control system
� A hard real-time system guarantees that real-time tasks be completed within their required deadlines� mainly single-purpose systems
� A soft real-time system provides priority of real-time tasks over non real-time tasks� a “standard” computing system with a real-time part that takes
precedence
Lesson 3/Page 48AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Real-Time CPU Scheduling
� Periodic processes require the CPU at specified intervals (periods)
� p is the duration of the period� d is the deadline by when the process MUST be
serviced (must finish within d) – often equal to p� t is the processing time
Lesson 3/Page 49AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Scheduling of N Tasks
Process P1: service time = 20, period = 50, deadline = 50
Process P2: service time = 35, period = 100, deadline = 100
eschedulabl. ⇒<=+= 1750100
35
50
20r
When P2 has a higher priority than P1, a failure occurs:
11
≤=∑=
N
i i
i
p
trCan be scheduled if
r – CPU utilization
(N = number of processes)
Lesson 3/Page 50AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Rate Monotonic Scheduling (RMS)� A process priority is assigned based on the inverse of its period� Shorter periods = higher priority;� Longer periods = lower priority
� P1 is assigned a higher priority than P2.
Process P1: service time = 20, period = 50, deadline = 50
Process P2: service time = 35, period = 100, deadline = 100
works well
Lesson 3/Page 51AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Missed Deadlines with RMS
Process P1: service time = 25, period = 50, deadline = 50Process P2: service time = 35, period = 80, deadline = 80
RMS is guaranteed to work if
N = number of processes
sufficient condition
( )
( ) 6931470212
121
.lnlim
;
≈=−
−≤=
∞→
=∑
N
N
NN
i i
i
N
Np
tr
0,70529820
0,71773410
0,7434915
0,7568284
0,7797633
0,8284272
N ( )12 −NN
failure
eschedulabl 0,9375 ⇒<=+= 180
35
50
25r
Lesson 3/Page 52AE3B33OSD Silberschatz, Galvin and Gagne ©2005
Earliest Deadline First (EDF) Scheduling
� Priorities are assigned according to deadlines:
the earlier the deadline, the higher the priority;the later the deadline, the lower the priority.
Process P1: service time = 25, period = 50, deadline = 50
Process P2: service time = 35, period = 80, deadline = 80
Works well even for the case when RMS failed
PREEMPTION may occur
Lesson 3/Page 53AE3B33OSD Silberschatz, Galvin and Gagne ©2005
RMS and EDF Comparison
� RMS:� Deeply elaborated algorithm � Deadline guaranteed if the condition
is satisfied (sufficient condition)� Used in many RT OS
� EDF:� Periodic processes deadlines kept even at 100% CPU
load� Consequences of the overload are unknown and
unpredictable� When the deadlines and periods are not equal, the
behaviour is unknown
( )12 −≤ NNr
End of Lesson 3