Lecture Notes for CS 140
Winter 2016
John Ousterhout

  • Readings for this topic from Operating Systems: Principles and Practice: Chapter 7 up through Section 7.2.
  • Resources fall into two classes:
    • Non-preemptible: once given, it can't be reused until thread gives it back. Examples are file space, terminal, and maybe memory.
    • Preemptible: processor or I/O channel. Can take resource away, use it for something else, then give it back later.
  • OS makes two related kinds of decisions about resources:
    • Allocation: who gets what. Given a set of requests for resources, which processes should be given which resources in order to make most efficient use of the resources?
    • Scheduling: how long can they keep it. When more resources are requested than can be granted immediately, in which order should the requests be serviced? Examples are processor scheduling (one processor, many threads), memory scheduling in virtual memory systems.
  • Reminder of thread states for dispatching/scheduling:
    • Running
    • Ready: waiting for a core to become available
    • Blocked: waiting for some other event (disk I/O, incoming network packet, etc.)

Simple Scheduling Algorithms

  • First-come-first-served (FCFS) scheduling (also called FIFO or non-preemptive):
    • Keep all of the ready threads in a single list called the ready queue.
    • When a thread becomes ready, add it to the back of the ready queue.
    • Run the first thread on the queue until it exits or blocks.
    • Problem: one thread can monopolize a core.
  • Solution: limit maximum amount of time that a thread can run without a context switch. This time is called a time slice.
  • Round robin scheduling: run thread for one time slice, then return to back of ready queue. Each thread gets equal share of the cores. Most systems use some variant of this.
    • Typical time slice value: 10 ms
    • The length of a time slice is also called the time quantum.
  • How do we decide whether a scheduling algorithm is good?
    • Make users happy (minimize response time).
    • Use resources efficiently:
      • Full utilization: keep cores and disks busy
      • Low overhead: minimize context switches
    • Fairness (distribute CPU cycles equitably)
  • Is round-robin better than FCFS?
  • Optimal scheduling: STCF (Shortest Time to Completion First); also called SJF (Shortest Job First)
    • Run the thread that will finish most quickly, run it without interruptions.
    • Another advantage of STCF: improves overall resource utilization.
      • Suppose some jobs CPU-bound, some I/O-bound.
      • STCF will give priority to I/O-bound jobs, which keeps the disks/network as busy as possible.
  • Key idea: can use past performance to predict future performance.
    • Behavior tends to be consistent
    • If a process has been executing for a long time without blocking, it's likely to continue executing.

Priority-Based Scheduling

  • Priorities: most real schedulers support a priority for each thread:
    • Always run the thread with highest priority.
    • In case of tie, use round-robin among highest priority threads
    • Use priorities to implement various scheduling policies (e.g. approximate STCF)
  • Exponential Queues (or Multi-Level Feedback Queues): attacks both efficiency and response time problems.
    • One ready queue for each priority level.
    • Lower-priority queues have larger time slices (time slice doubles with each reduction in priority)
    • Newly runnable thread starts in highest priority queue
    • If it reaches the end of its time slice without blocking it moves to the next lower queue.
    • Result: I/O-bound threads stay in the highest-priority queues, CPU-bound threads migrate to lower-priority queues
    • What are the problems with this approach?
  • 4.4 BSD Scheduler (for first project):
    • Keep information about recent CPU usage for each thread
    • Give highest priority to thread that has used the least CPU time recently.
    • Interactive and I/O-bound threads will use little CPU time and remain at high priority.
    • CPU-bound threads will eventually get lower priority as they accumulate CPU time.

Multiprocessor Scheduling

  • Multiprocessor scheduling is mostly the same as uniprocessor scheduling:
    • Share the scheduling data structures among all of the cores
    • Run the k highest-priority threads on the k cores.
    • When a thread becomes runnable, see if its priority is higher than the lowest-priority thread currently running. If so, preempt that thread.
    • However, a single ready queue can result in contention problems if there are lots of cores.
  • 2 special issues for multiprocessors:
    • Core affinity:
      • Once a thread has been running on a particular core it is expensive to move it to a different core (hardware caches will have to be reloaded).
      • Multiprocessor schedulers typically try to keep a thread on the same core as much as possible to minimize these overheads.
    • Gang scheduling:
      • If the threads within a process are communicating frequently, it won't make sense to run one thread without the others: it will just block immediately on communication with another thread.
      • Solution: run all of the threads of a process simultaneously on different cores, so they can communicate more efficiently.
      • This is called gang scheduling.
      • Even if a thread blocks, it may make sense to leave it loaded on its core, on the assumption that it will unblock in the near future.


  • Scheduling algorithms should not affect the behavior of the system (same results regardless of schedule).
  • However, the algorithms do impact the system's efficiency and response time.
  • The best schemes are adaptive. To be optimal, we'd have to predict the future.