Title: Scheduling in Representative Operating Systems
1Scheduling in Representative Operating Systems
2Uniprocessor Scheduling
3Uniprocessor Scheduling (cont.)
4(No Transcript)
5(No Transcript)
6Scheduling Algorithms (cont.)
- Short-term scheduling criteria
- User oriented, performance related
- Turnaround time
- Response time
- Deadlines
- User oriented, other
- Predictability
- System oriented, performance related
- Throughput
- Processor utilization
- System oriented, other
- Fairness
- Enforcing priorities
- Balancing resources
- Priorities
7(No Transcript)
8Scheduling Algorithms (cont.)
- Scheduling policies
- First-Come-First Served (FCFS) or
First-In-First-Out (FIFO) - Round Robin (RR)
- Shortest Process Next (SPN)
- Shortest Remaining Time (SRT)
- Highest Response Ratio Next (SRRN)
- Feedback
- Fair-Share Scheduling
9(No Transcript)
10Traditional UNIX Scheduling
- SVR3 and 4.3 BSD UNIX designed primarily for
time-sharing interactive environment - Scheduling algorithm objectives
- Provide good response time for interactive users
- Ensure that low-priority background jobs do not
starve - Scheduling algorithm implementation
- Multilevel feedback using round robin within each
of the priority queues - 1 second preemption
- Priority based on process type and execution
history - Priorities are recomputed once per second
- Base priority divides all processes into fixed
bands of priority levels - Bands used to optimize access to block devices
(e.g., disk) and to allow the OS to respond
quickly to system calls
11Traditional UNIX Scheduling (cont.)
- Priority calculation
- CPU j (i)
CPU j ( i 1)
2
CPU j ( i 1)
P j (i) Base j
2
Where CPU j (i) Measure of processor
utilization by process j through interval i P j (
i ) Priority of process j at beginning of
interval i lower values equal higher
priorities Base j Base priority of
process j
12Traditional UNIX Scheduling (cont.)
- Bands in decreasing order of priority
- Swapper
- Block I/O device control
- File manipulation
- Character I/O device control
- User processes
- Goals
- Provide the most efficient use of I/O devices
- Within the user process band, use the execution
history to penalize processor-bound processes at
the expense of I/O bound processes - Example of process scheduling
- Processes A, B, and C are created at the same
time with base priorities of 60 - Clock interrupts the system 60 times a second and
increments counter for running process
13Traditional UNIX Scheduling (Example
14Multiprocessor and Real-Time Scheduling
- Multiprocessor Thread Scheduling
- Load sharing
- Global queue of ready threads is maintained and
each processor, when idle, selects a thread from
the queue - Gang scheduling
- Set of related threads is scheduled to run on a
set of processors at the same time, on a
one-to-one basis - Dedicated processor assignment
- Each program is assigned a number of processors
equal to the number of threads in the program,
for the duration of program execution - Dynamic scheduling
- Number of threads in a process can be altered
during course of execution
15Thread Scheduling
- Load Sharing
- Load is distributed evenly across the processors
- No centralized scheduler required
- The global queue can be organized and accessed
using any scheduling policy - One of the most widely used schemes in
multiprocessing - Gang Scheduling
- Simultaneous scheduling of threads that make up a
single process - Useful for applications where performance
severely degrades when any part of the
application is not running - Threads often need to synchronize with each other
16Thread Scheduling
- Dedicated Processor Assignment
- When application is scheduled, each of its
threads is assigned to a processor that remains
dedicated to that thread through completion - Some processors may be idle
- No multiprogramming of processors
- Avoidance of process switching can improve speed
of application - Dynamic Scheduling
- The number of threads in the process are changed
dynamically - Both the OS and the application are involved in
scheduling the OS assigns processors to jobs,
the application decides which thread subset to
run - For applications that can take advantage of
dynamic scheduling, this approach is superior to
both gang scheduling and dedicated processor
assignment - The overhead may negate the apparent performance
advantage
17Real-Time Systems
- Correctness of the system depends not only on the
logical result of the computation but also on the
time at which the results are produced - Tasks or processes attempt to control or react to
events that take place in the outside world - The events being controlled occur in real time
the real-time task must be able to keep up with
these events - Examples
- Control of laboratory experiments
- Process control plants
- Robotics
- Air traffic control
- Telecommunications
- Military command and control systems
18Characteristics of Real-Time Operating Systems
- Deterministic
- Operations are performed at fixed, predetermined
times or within predetermined time intervals - The OS must acknowledge interrupts in time and
must have sufficient capacity to handle all
requests within required time - Responsiveness
- How long, after acknowledgment, it takes the
operating system to service the interrupt - User control
- User specifies task priority and may also specify
the use of paging or process swapping, and the
processes resident in main memory, - Reliability
- Loss or degradation of performance may have
catastrophic consequences - Attempt either to correct the problem or minimize
its effects while continuing to run - Make sure that the most critical, high priority
tasks execute
19Features of Real-Time Operating Systems
- Fast process or thread switch
- Preemptive scheduling base on priority
- Minimization of intervals during which interrupts
are disabled - Ability to respond to external interrupts quickly
- Use of special sequential files that can
accumulate data at a fast rate - Special alarms and timeouts
20Scheduling of a Real-Time Process
21Scheduling of a Real-Time Process
22Scheduling of a Real-Time Process
23Scheduling of a Real-Time Process
24Real-Time Scheduling
- Classes of algorithms
- Static table-driven scheduling
- Applicable to tasks that are periodic
- Scheduler develops a schedule that meet the
requirements of all periodic tasks - Static priority-driven preemptive scheduling
- Uses priority-driven preemptive scheduling
mechanism - Priority assignment is related to the time
constraints associated with each task - Dynamic planning-based scheduling
- After the arrival of a new task, an attempt is
made to revise the schedule such that the needs
of the new task and the existing tasks are met - Dynamic best effort scheduling
- On arrival, task assigned priority based on its
characteristics - Deadline scheduling (e.g., earliest-deadline
scheduling) is used
25Deadline Scheduling
- Real-time applications are concerned with
completing (or starting) tasks on time - Scheduling tasks with the earliest deadline
minimized the fraction of tasks that miss their
deadlines - Recent proposals for real-time task scheduling
are based on additional information about each
task - Ready time
- Starting deadline
- Completion deadline
- Processing time
- Resource requirements
- Priority
- Subtask scheduler
26Linux Scheduling
- Enhances the traditional UNIX scheduling by
adding two new scheduling classes for real-time
processing - Scheduling classes
- SCHED_FIFO First-in-first-out real-time threads
- SCHED_RR Round-robin real-time threads
- SCHED_OTHER Other, non-real-time threads
- Multiple priorities can be used within each
class priorities for real-time threads higher
than for non-real-time threads
27Linux Scheduling (cont.)
- Scheduling for the FIFO threads is done according
with the following rules - An executing FIFO thread can be interrupted only
when - Another FIFO thread of higher priority becomes
ready - The executing FIFO thread becomes blocked,
waiting for an event - The executing FIFO thread voluntarily gives up
the processor (sched_yield) - When an executing FIFO thread is interrupted, it
is placed in a queue associated with its priority - When a FIFO thread becomes ready and it has a
higher priority than the currently running
thread, the running thread is pre-empted and the
thread with the higher priority is executed. If
several threads have the same, higher priority,
the one that has been waiting the longest is
assigned the processor - Scheduling for the Round-Robin threads is
similar, except for a time quota associated with
each thread - At the end of the time quota, the thread is
suspended and a thread of equal or higher
priority is assigned the processor
28Linux Scheduling (cont.)
- Example The distinction between FIFO and RR
scheduling - Assumptions (a)
- A program has four threads with three relative
priorities - All waiting threads are ready to execute when the
current thread waits or terminates - No higher-priority thread is awakened while a
thread is executing - Scheduling of FIFO threads (b)
- Thread D executes until it waits or terminates
- Thread B executes (it has been waiting longer
than C) until waits or terminates - Thread C executes
- Thread A executes
- Scheduling of Round-Robin threads ( c )
- Thread D executes until it waits or terminates
- Threads B and C execute time-sliced
- Thread A executes
- Scheduling of non-real-time threads
- Execute only if no real-time threads are ready
using the traditional UNIX scheduling algorithm
29Linux Scheduling FIFO vs. RR
30UNIX SVR4 Scheduling
- Complete redesign of the traditional UNIX
scheduling algorithm - Goal give preference in the following order
- Highest preference to real-time processes
- Next-highest to kernel-mode processes
- Lowest preference to other user-mode processes
(time-shared processes) - Major enhancements
- The addition of a preemptable static priority
scheduler - The introduction of 160 priority levels divided
into three priority classes - The introduction of preemption points in the
kernel (points where the kernel can safely
interrupt and schedule a new process) - Priority classes and levels
- Real-time (159-100)
- Guaranteed execution before kernel or
time-sharing processes - Preemption points can be used to preempt kernel
or user processes - Kernel (99-60)
- Guaranteed execution before time-sharing
processes - Time-shared (59-0)
- Lowest-priority processes user applications
other than real-time
31UNIX SVR4 Scheduling (cont.)
- Implementation
- A dispatch queue is associated with each priority
level processes at that level are executed
round-robin (dispq) - A bit-map vector, dqactmap, has one bit for each
priority level a 1 indicates a nonempty queue at
that level - When a process leaves the Running state (block,
time-slice expiration, or preemption), the
dispatcher - Checks the dqactmap, and
- Dispatches a process from the highest-priority
non-empty queue - When a defined preemption point is reached, the
kernel - Checks the flag kprunrun
- If set (at least one real-time process is in the
Ready state), preempts the current process if it
is of lower priority than the highest-priority
real-time ready process - A real-time process has a fixed priority and a
fixed quantum - A time-sharing process has a variable priority
and a variable time quantum - The priority is reduced every time the process
uses up the time quantum and is raised when the
process blocks on an event or resource - The time quantum changes with the priority (100ms
for priority 0, 10ms for 59)
32UNIX SVR4 Scheduling Dispatch Queues
33Windows 2000 Scheduling
- Goal optimize response for
- Single user in highly interactive environment, or
- Server
- Implementation
- Priority-driven preemptive scheduler with
round-robin within a priority level - When a thread becomes ready and has higher
priority than the currently running thread, the
lower priority thread is preempted - Dynamic priority variation as function of current
thread activity for some levels - Process and thread priorities organized into two
bands (classes), each with 16 levels - Real-time priorities
- Real-time tasks or time-dependent functions
(e.g., communications) - Have precedence over other threads
- Variable priorities
- Non-real-time tasks and functions
34Windows 2000 Scheduling (cont.)
35Windows 2000 Scheduling (cont.)
- Real-time priority class
- All threads have a fixed priority that never
changes - All active threads at a given priority level are
in a round-robin queue - Variable priority class
- A threads priority begins at some initial
assigned value and then may change, up or down,
during the threads lifetime - There is a FIFO queue at each priority level, but
a thread may migrate to other queues within the
variable priority class - The initial priority of a thread is determined by
- Process base priority attribute of the process
object, from 0 to 15 - Thread base priority equal to that of its
process or within two levels above or below that
of the process - Dynamic priority
- Thread starts with base priority and then
fluctuates within given boundaries, never falling
under base priority or exceeding 15
36Windows 2000 Scheduling (cont.)
- Variable priority class dynamic priorities
- If thread is interrupted because it has used its
current time quantum, executive lowers its
priority processor-bound threads move toward
lower priorities - If thread is interrupted to wait on an I/O event,
executive raises its priority I/O-bound threads
move toward higher priorities - Priority raised more for interactive waits (e.g.,
wait on keyboard or display) - Priority raised less for other I/O (e.g., disk
I/O) - Example
- A process object has a base priority of 4
- Each thread associated with this process can have
an initial priority between 2 and 6 and dynamic
priorities between 2 and 15 - The threads priority will change based on its
execution characteristics
37Windows 2000 Scheduling Example of Dynamic
Priorities
38Windows 2000 Scheduling (cont.)
- Single processor vs. multiprocessor scheduling
- Single processor
- Highest-priority thread is always active unless
it is waiting on an event - If there is more than one thread at the highest
priority, the processor is shared, round-robin - Multiprocessor system with N processors
- The (N 1) highest-priority threads are always
active, running on the (N 1) processors - All other lower-priority threads share the
remaining processor - Example three processors, two highest-priority
threads run on two processors, all other threads
run on the remaining processor - Exception for threads with processor affinity
attribute