Scheduling topic in operating systems (OS).

Silberschatz, Galvin and Gagne ©2013
Operating System Concepts – 9th
Edition
Chapter 6: CPU Scheduling

6.2 Silberschatz, Galvin and Gagne ©2013
Edition
Chapter 6: CPU Scheduling
 Basic Concepts
 Scheduling Criteria
 Scheduling Algorithms
 Thread Scheduling
 Multiple-Processor Scheduling
 Real-Time CPU Scheduling
 Operating Systems Examples
 Algorithm Evaluation

Edition
Objectives
 To introduce CPU scheduling, which is the basis for
multiprogrammed operating systems
 To describe various CPU-scheduling algorithms
 To discuss evaluation criteria for selecting a CPU-scheduling
algorithm for a particular system
 To examine the scheduling algorithms of several operating
systems

Edition
Basic Concepts
Basic Concepts
 In a single-processor system, only one process can run at a time.
 Othersmust wait until the CPU is free and can be rescheduled.
 The objective ofmultiprogramming is to have some process running
at all times, to maximizeCPU utilization. The idea is relatively
simple.
 A process is executed until it must wait, typically for the completion
of some I/O request. In a simplecomputer system, the CPU then just
sits idle.
 All this waiting time is wasted;no useful work is accomplished.

Edition
 With multiprogramming, we try to use this time productively. Several
processes are kept in memory at one time.
 When one process has to wait, the operating system takes the CPU
away from that process and gives the CPU to another process.
 This pattern continues. Everytime one process has to wait, another
process can take over use of the CPU.
 Scheduling of this kind is a fundamental operating-system function.
 Almost all computer resources are scheduled before use. The CPU
is, of course,one of the primary computer resources.
 Thus, its scheduling is central to operating-system design.

Edition
Basic Concepts
 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 followed by I/O burst
 CPU burst distribution is of main
concern

Edition
CPU–I/O Burst Cycle
• The success of CPU scheduling depends on an observed property of
processes:
• process execution consists of a cycle of CPU execution and I/O wait.
Processes alternate between these two states.
• Process execution begins with a CPU burst.That is followed by an I/O
burst, which is followed by another CPU burst, then another I/O
burst, and so on.
• Eventually, the final CPU burst ends with a system request to terminate
execution

Edition
• The durations of CPU bursts have been measured extensively.
Althoughthey vary greatly from process to process and from
computer to computer,they tend to have a frequency curve similar to
that shown in Figure 6.2.
• The curve is generally characterized as exponential or
hyperexponential, with a large number of short CPU bursts and a
small number of long CPU bursts.

Edition

Edition
CPU Scheduler
 Short-term scheduler selects from among the processes in
ready queue, and allocates the CPU to one of them
 Queue may be ordered in various ways
 CPU scheduling decisions may take place when a process:
1. Switches from running to waiting state
2.Switches from running to ready state(for example, when
an interrupt occurs)
3.Switches from waiting to ready(for example, at
completion of I/O)
4. Terminates
 For situations 1 and 4, there is no choice in terms of
scheduling.
 A new process(if one exists in the ready queue) must
be selected for execution. There is a choice, however,
for situations 2 and 3.

Edition
Scheduling under 1 and 4 is nonpreemptive
 All other scheduling is preemptive
 Consider access to shared data
 Consider preemption while in kernel mode
 Consider interrupts occurring during crucial OS activities

Edition
Nonpreemptive& preemptive scheduling
• Under nonpreemptive scheduling, once the CPU has been allocated to a
process, the process keeps the CPU until it releases the CPU either by
terminating or by switching to the waiting state.
• This scheduling method was used by Microsoft Windows 3.x.
• Windows 95 introduced preemptive scheduling, and all subsequent
versions of Windows operating systems have used preemptive
scheduling.
• preemptive scheduling can result in race conditions when data are
shared among several processes.
• Consider the case of two processes that share data. While one process
is updating the data, it is preempted so that the second process can run.
• The second process then tries to read the data, which are in an
inconsistent state.

Edition
• Preemption also affects the design of the operating-system kernel.
• During the processing of a system call, the kernel maybe busy with
an activity on behalf of a process.
• Such activities may involve changing important kernel data (for
instance, I/O queues).

Edition
Dispatcher
 Dispatcher module gives control of the CPU to the
process 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

Edition
Scheduling Criteria
• Different CPU-scheduling algorithms have different properties, and
the choice of a particular algorithm may favor one class of
processes over another.
• In choosing which algorithm to use in a particular situation, we must
consider the properties of the various algorithms.
• The criteria include the following:
• CPU utilization. We want to keep the CPU as busy as possible.
Conceptually,CPU utilization can range from 0 to 100 percent. In
a real system, itshould range from 40 percent (for a lightly
loaded system) to 90 percent(for a heavily loaded system).

Edition
• Throughput. -
• If the CPU is busy executing processes, then work is being done.
• One measure of work is the number of processes that are
completed per time unit, called throughput.
• For long processes, this ratemay be one process per hour; for short
transactions, it may be ten processes per second.
• Turnaround time.—
• Turn around time is the sum of the periods spent waiting to get into
memory, waiting in the ready queue, executing on the CPU, and
doing I/O.

Edition
• Waiting time.—
• Waiting time is the sum of the periods spent waiting in the ready queue.
• Response time.—
• In an interactive system, turnaround time may not be the best criterion.
• Often, a process can produce some output fairly early and can continue
computing new results while previous results are being output to the
user.
• Thus, another measure is the time from the submission of a request
until the first response is produced. This measure, called response time,
is the time it takes to start responding, not the time it takes to output the
response. The turnaround time is generally limited by the speed of the
output device.

Edition
Scheduling Algorithm Optimization Criteria
 Max CPU utilization
 Max throughput
 Min turnaround time
 Min waiting time
 Min response time

Edition
First- Come, First-Served (FCFS) Scheduling
Process Burst 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:
 Waiting time for P1 = 0; P2 = 24; P3 = 27
 Average waiting time: (0 + 24 + 27)/3 = 17
P P P
1 2 3
0 24 30
27

Edition
• If the processes arrive in the order P1, P2,
P3, and are served in FCFS order,we get
the result shown in the following Gantt
chart, which is a bar chart that illustrates
a particular schedule, including the start
and finish times of each of the participating
processes

Edition
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order:
P2 , 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
 Consider one CPU-bound and many I/O-bound processes
P1
0 3 6 30
P2
P3

Edition
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 – gives minimum average waiting time for a given
set of processes
 The difficulty is knowing the length of the next CPU request
 Could ask the user

Edition
Example of SJF
ProcessArriva l Time Burst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3
 SJF scheduling chart
 Average waiting time = (3 + 16 + 9 + 0) / 4 = 7
P3
0 3 24
P4
P1
16
9
P2

Edition
• The waiting time is 3 milliseconds for
process P1, 16milliseconds for process
P2, 9milliseconds for process P3, and
0milliseconds for process P4.
• Thus, the average waiting time is (3 + 16 +
9 + 0)/4 = 7 milliseconds.
• By comparison, if we were using the FCFS
scheduling scheme, the average waiting
time would be 10.25 milliseconds.

Edition
• The real difficulty with the SJF algorithm is
knowing the length of the next CPU
request.
• For long-term (job) scheduling in a batch
system, we can use the process time limit
that a user specifies when he submits the
job.

Edition
• In this situation, users are motivated to
estimate the process time limit
accurately,since a lower value may mean
faster response but too low a value will
cause a time-limit-exceeded error and
require resubmission.
• SJF scheduling is used frequently in long-
term scheduling

Edition
• Although the SJF algorithm is optimal, it
cannot be implemented at the level of
short-term CPU scheduling.
• With short-term scheduling, there is no way
to know the length of the next CPU burst.
• One approach to this problem is to try to
approximate SJF scheduling.
• We may not know the length of the next
CPU burst, but we may be able to predict
its value.

Edition
• We expect that the next CPU burst will be
similar in length to the previous ones.
• By computing an approximation of the
length of the next CPU burst, we can pick
the process with the shortest predicted
CPU burst.

Edition
Determining Length of Next CPU Burst
• The next CPU burst is generally predicted as an
exponential average of the measured lengths of previous
CPU bursts.
• We can define the exponential average with the following
formula.
• The value of tn contains our most recent information, while
"n stores the past history.
• The parameter # controls the relative weight of recent and
past historyin our prediction.
:
Define
4.
1
0
,
3.
burst
CPU
next
the
for
value
predicted
2.
burst
CPU
of
length
actual
1.







 1
n
th
n n
t 1

Edition
Prediction of the Length of the Next CPU Burst

Edition
Examples of Exponential Averaging
•  =0
 n+1 = n
 Recent history does not count(current conditions are
assumed to be transient)
  =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

Edition
Example of Shortest-remaining-time-first
 Now we add the concepts of varying arrival times and preemption to
the analysis
ProcessA arri Arrival TimeT Burst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
 Preemptive SJF Gantt Chart
 Average waiting time = [(10-1)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5
msec
P4
0 1 26
P1
P2
10
P3
P1
5 17

Edition
Priority Scheduling
 A priority number (integer) is associated with each process
 The CPU is allocated to the process with the highest priority
(smallest integer  highest priority)
 Preemptive
 Nonpreemptive
 SJF is priority scheduling where priority is the inverse of predicted
next CPU burst time
 Problem  Starvation – low priority processes may never execute
 Solution  Aging – as time progresses increase the priority of the
process

Edition
Example of Priority Scheduling
ProcessA arri Burst TimeT Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2
 Priority scheduling Gantt Chart
 Average waiting time = 8.2 msec

Edition
Round Robin (RR)
 Each process gets a small unit of CPU time (time quantum q),
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.
 Timer interrupts every quantum to schedule next process
 Performance
 q large  FIFO
 q small  q must be large with respect to context switch,
otherwise overhead is too high

Edition
Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
 The Gantt chart is:
 Typically, higher average turnaround than SJF, but better
response
 q should be large compared to context switch time
 q usually 10ms to 100ms, context switch < 10 usec
P P P
1 1 1
0 18 30
26
14
4 7 10 22
P2
P3
P1
P1
P1

Edition
• Let’s calculate the average waiting time for
this schedule.
• P1 waits for 6milliseconds (10 - 4), P2
waits for 4 milliseconds, and P3 waits for 7
milliseconds.
• Thus, the average waiting time is 17/3 =
5.66 milliseconds.

Edition
• 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.
• Each process must wait no longer than (n
− 1) × q time units until its next time
quantum.

Edition
• For example, with five processes and a
time quantum of 20 milliseconds, each
process will get up to 20 milliseconds
every 100 milliseconds.

Edition
• In the RR scheduling algorithm, no process is
allocated the CPU for more than 1 time
quantum in a row (unless it is the only
runnable process).
• If a process’s CPU burst exceeds 1 time
quantum, that process is preempted and is
put back in the ready queue.
• The RR scheduling algorithm is thus
preemptive.

Edition
• The performance of the RR algorithm
depends heavily on the size of the time
quantum.
• At one extreme, if the time quantum is
extremely large, the RR policy is the same
as the FCFS policy.
• In contrast, if the time quantum is
extremely small (say, 1 millisecond), the
RR approach can result in a large number
of context switches.

Edition
• Assume, for example, that we have only
one process of 10 time units.
• If the quantum is 12 time units, the
process finishes in less than 1 time
quantum, with no overhead.
• If the quantum is 6 time units, however,
the process requires 2 quanta, resulting in
a context switch.

Edition
• If the time quantum is 1 time unit, then
nine context switcheswill occur, slowing
the execution of the process accordingly
(Figure 6.4).

Edition
Time Quantum and Context Switch Time

Edition
Turnaround Time Varies With The Time Quantum
80% of CPU bursts
should be shorter than q

Edition

Edition
Multilevel Queue
 Ready queue is partitioned into separate queues, eg:
 foreground (interactive)
 background (batch)
 Process permanently in a given queue
 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). Possibility 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

Edition
Multilevel Queue Scheduling

Edition
Multilevel Feedback Queue
 A process can move between the various queues; aging can be
implemented 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

Edition
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 which is
served FCFS
 When it gains CPU, job receives 8
milliseconds
 If it does not finish in 8
milliseconds, job is moved to
queue Q1
 At Q1 job is again served FCFS and
receives 16 additional milliseconds
 If it still does not complete, it is
preempted and moved to queue Q2

Edition
Thread Scheduling
 Distinction between user-level and kernel-level threads
 When threads supported, threads scheduled, not processes
 Many-to-one and many-to-many models, thread library schedules
user-level threads to run on LWP
 Known as process-contention scope (PCS) since scheduling
competition is within the process
 Typically done via priority set by programmer
 Kernel thread scheduled onto available CPU is system-contention
scope (SCS) – competition among all threads in system

Edition
Process(heavy weight) Threads(user level)
System calls involved in
process
Threre is no system call
involved
OS treats different
processes differently
All user level threads
treated as a single task for
OS
Different process have
different copies of
data,files,code(overhead is
created)
Threads share same copy
of code and data
Context switching is slower Context switching is faster
Blocking a process will not
block another
Blocking a thread will block
entire process
Independent Intradependent

Edition
User level thread Kernel level thread
User level threads are
managed by user level
library
Kernel level threads are
managed by OS (by default
SYMcalls)
User level threads are
typically fast
Kernel level threads
areslower
Context switching is faster Context switching is slow
If one user level threads
perform blocking operation
entire process get blocked
If one kernel level thread is
bloked,no effect on others

Edition
Pthread Scheduling
 API allows specifying either PCS or SCS during thread creation
 PTHREAD_SCOPE_PROCESS schedules threads using
PCS scheduling
 PTHREAD_SCOPE_SYSTEM schedules threads using
SCS scheduling
 Can be limited by OS – Linux and Mac OS X only allow
PTHREAD_SCOPE_SYSTEM

Edition
Pthread Scheduling API
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5
int main(int argc, char *argv[]) {
int i, scope;
pthread_t tid[NUM THREADS];
pthread_attr_t attr;
/* get the default attributes */
pthread_attr_init(&attr);
/* first inquire on the current scope */
if (pthread_attr_getscope(&attr, &scope) != 0)
fprintf(stderr, "Unable to get scheduling scopen");
else {
if (scope == PTHREAD_SCOPE_PROCESS)
printf("PTHREAD_SCOPE_PROCESS");
else if (scope == PTHREAD_SCOPE_SYSTEM)
printf("PTHREAD_SCOPE_SYSTEM");
else
fprintf(stderr, "Illegal scope value.n");
}

Edition
Pthread Scheduling API
/* set the scheduling algorithm to PCS or SCS */
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
/* create the threads */
for (i = 0; i < NUM_THREADS; i++)
pthread_create(&tid[i],&attr,runner,NULL);
/* now join on each thread */
for (i = 0; i < NUM_THREADS; i++)
pthread_join(tid[i], NULL);
}
/* Each thread will begin control in this function */
void *runner(void *param)
{
/* do some work ... */
pthread_exit(0);
}

Edition
Multiple-Processor Scheduling
 Load Sharing possible
 CPU scheduling more complex when multiple CPUs are
available
 Consider Homogeneous processors within a multiprocessor
 Processors are identical in functionality.
 We can then use any available processor to run any process in
the queue.
 even with homogeneous multiprocessors, there are sometimes
limitations on scheduling

Edition
Approaches to Multiple-Processor Scheduling
 Asymmetric multiprocessing – only one processor accesses the system
data structures, alleviating the need for data sharing
 In a multiprocessor system has all scheduling decisions, I/O processing,
and other system activities handled by a single processor—the master
server.
 The other processors execute only user code.
 Simple because only one processor accesses the system data structures,
reducing 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
 Currently, most common support SMP, includingWindows, Linux, and
Mac OS X

Edition
Processor Affinity
 Processor affinity – process has affinity for processor on which it is
currently running.
 The data most recently accessed by the process populate the cache for the
processor.
 As a result, successive memory accesses by the process are often satisfied
in cache memory.
 if the process migrates to another processor?
 the second processor must be repopulated.
 Because of the high cost of invalidating and repopulating caches, most SMP
systems try to avoid migration of processes from one processor to another.
 soft affinity
 hard affinity
 Variations including processor sets

Edition

Edition
 soft affinity: When an operating system has a policy of
attempting to keep a process running on the same
processor—but not guaranteeing that it will do so—we
have a situation known as soft affinity.
 hard affinity: some systems provide system calls that
support hard affinity, thereby allowing a process to
specify a subset of processors on which it may run.
 Linux implements soft affinity, but it also provides the
sched setaffinity() system call, which supports hard
affinity.

Edition
Multiple-Processor Scheduling – Load Balancing
 If SMP, need to keep all CPUs loaded for efficiency
 Load balancing attempts to keep workload evenly distributed
 Push migration – periodic task checks load on each
processor, and if found pushes task from overloaded
CPU to other CPUs
 Pull migration – idle processors pulls waiting task from
busy processor

Edition
Multicore Processors
 Recent trend to place multiple processor cores on same
physical chip
 Faster and consumes less power
 Multiple threads per core also growing
 Takes advantage of memory stall to make progress on
another thread while memory retrieve happens

Edition
Multithreaded Multicore System

Edition
Real-Time CPU cSheduling
• Real-time systems are systems that carry
real-time tasks.
• These tasks need to be performed
immediately with a certain degree of
urgency.
• Classified into hard and soft real-time
tasks.

Edition
Real-Time CPU cSheduling
 CPU scheduling for real-time operating systems involves special issues
 Soft real-time systems – no guarantee as to when critical real-time process
will be scheduled. They guarantee only that the process will
be given preference over noncritical processes.
• Soft real-time systems have degraded performance if their timing needs
cannot be met.
Ex:streaming video
 Hard real-time systems – task must be serviced by its deadline. Otherwise
considered as no service.
 Hard real-time systems have total failure if their timing needs cannot be met.
 Ex:Assembly line robotics,automobile air-bag deployment

Edition
Real-Time CPU Scheduling
 When an event occurs, the system must respond to and
service it as quickly as possible.
 We refer to event latency as the amount of time that
elapses from when an event occurs to when it is
serviced.
 different events have different latency requirements
 Two types of latencies affect performance
1. Interrupt latency – Period of time from arrival of
interrupt to start of routine that services interrupt
2. Dispatch latency – time for schedule to take current
process off CPU and switch to another

Edition
Minimizing Latency
• A real time systems is event driven in nature.When an event occurs, the system must
respond to and service it as quickly as possible.
• Event Latency is the time between the occurence of a triggering event and the
(completion of) the system’s response to the event.
tt00
Event E first occurs
t0 t1
Real-time system
respond to E
time
Event Latency

Edition
Interrupt latency
 When an interrupt occurs, the operating system
must first complete the instruction it is executing
and determine the type of interrupt that
occurred.
 It must then save the state of the current
process before servicing the interrupt using the
specific interrupt service routine (ISR).
 The total time required to perform these tasks is
the interrupt latency

Edition
Real-Time CPU Scheduling cont.. --Interrupt Latency

Edition
Dispatch latency
 The amount of time required for the scheduling
dispatcher to stop one process and start another
is known as dispatch latency.
 Providing real time tasks with immediate access to the
cpu mandates that real-time OS minimize this latency
as well.
 The most effective technique for keeping dispatch
latency low is to provide preemptive kernels.

Edition
Real-Time CPU Scheduling (Cont.) – Dispatch
latency
 Conflict phase of
dispatch latency:
1. Preemption of
any process
running in kernel
mode
2. Release by low-
priority process
of resources
needed by high-
priority
processes

Edition
• Using a technique known as an admission-control algorithm,each
task must specify its needs at the time it attempts to launch.
• The scheduler does one of two things:It either admits the
process,guranteeing that the process will complete on time,or
• Rejects the requests as impossible if it cannot gurantee that the task
will be serviced by its deadline.
• The process of deciding the execution order of rreal-time
tasks,depends on the priority of the task
• Task A: deadline=5,exe time=3
• Task B: deadline=7,exe time=4

Edition
Priority-based Scheduling
 For real-time scheduling, scheduler must support preemptive, priority-
based scheduling
 But only guarantees soft real-time
 For hard real-time must also provide ability to meet deadlines
 Processes have new characteristics:
 periodic ones require CPU at constant intervals.
 Once a periodic process has acquired the CPU, it has a fixed
processing time t, a deadline d by which it must be serviced by the
CPU, and a period p.
 Has processing time t, deadline d, period p
 0 ≤ t ≤ d ≤ p
 Rate of periodic task is 1/p

Edition

Edition
Rate monotonic scheduling
 Unusual about this form of scheduling is that a process
may have to announce its deadline requirements to the
scheduler.
 Then, using a technique known as an admission-
control algorithm, the scheduler does one of two things.
 It either admits the process, guaranteeing that the
process will complete on time. (or)
rejects the request as impossible if it cannot guarantee
that the task will be serviced by its deadline.

Edition
 The rate-monotonic scheduling algorithm schedules
periodic tasks using a static priority policy with
preemption.
 Higher priority one preempt the lower priority
 Upon entering the system, each periodic task is assigned
a priority inversely based on its period.
 The shorter the period, the higher the priority;
 policy is to assign a higher priority to tasks that require
the CPU more often.
 This assumes that the processing time of a periodic
process is the same for each CPU burst.
 That is, every time a process acquires the CPU, the
duration of its CPU burst is the same.

Edition
Rate Monotonic Scheduling
 A 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.
 Example:
P1 and P2
 Period: 50(P1); 100(P2)
 Burst Time: 20(p1), 35(P2)
 Deadlines: Before start of next Period.

Edition
Rate Monotonic Scheduling
P1 anPd P2. The periods
for PP1 and P2. The periods
for P1 and P2 are 50 and 100, respectively—that is, p1 = 50
and p2 = 100. The
processing times are t1 = 20 for P1 and t2 = 35 for P2. The
deadline for each
process requires that it complete its CPU burst by the start of
its next period.1 and P2 are 50 and 100, respectively—that is,
p1 = 50 and p2 = 100. The
processing times are t1 = 20 for P1 and t2 = 35 for P2. The
pP

Edition
Missed Deadlines with Rate Monotonic Scheduling

Edition
Earliest Deadline First Scheduling (EDF)
 Priorities are assigned according to deadlines:
the earlier the deadline, the higher the priority;
the later the deadline, the lower the priority

Edition
Proportional Share Scheduling
 Proportional share schedulers operate by allocating T shares
among all applications.
 An application can receive N shares of time, thus ensuring that
the application will have N/T of the total processor time.
 T shares are allocated among all processes in the system
 An application receives N shares where N < T
 This ensures each application will receive N / T of the total
processor time

Edition
 Eg: T = 100 shares is to be divided among three processes,
 A, B, and C. Ais assigned 50 shares – 50%
B is assigned 15 shares – 15%
C is assigned 20 shares – 20%
 These must work in conjunction with an admission-control policy to
guarantee that an application receives its allocated shares of time.
 This policy will admit a client requesting a particular number of shares only if
sufficient shares are available.
 A+B+C= 50 + 15 + 20 = 85 shares
If D requires 30 shares that is denied

Scheduling topic in operating systems (OS).

More Related Content

Similar to Scheduling topic in operating systems (OS). (20)

Recently uploaded (20)

Scheduling topic in operating systems (OS).