Scheduling in Representative Operating Systems

1
Scheduling in Representative Operating Systems

2
Uniprocessor Scheduling
3
Uniprocessor Scheduling (cont.)
4
(No Transcript)
5
(No Transcript)
6
Scheduling 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)
8
Scheduling 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)
10
Traditional 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

11
Traditional 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
12
Traditional 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

13
Traditional UNIX Scheduling (Example
14
Multiprocessor 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

15
Thread 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

16
Thread 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

17
Real-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

18
Characteristics 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

19
Features 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

20
Scheduling of a Real-Time Process
21
Scheduling of a Real-Time Process
22
Scheduling of a Real-Time Process
23
Scheduling of a Real-Time Process
24
Real-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

25
Deadline 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

26
Linux 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

27
Linux 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

28
Linux 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

29
Linux Scheduling FIFO vs. RR
30
UNIX 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

31
UNIX 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)

32
UNIX SVR4 Scheduling Dispatch Queues
33
Windows 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

34
Windows 2000 Scheduling (cont.)
35
Windows 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

36
Windows 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

37
Windows 2000 Scheduling Example of Dynamic
Priorities
38
Windows 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