CPU SCHEDULING

the CPU scheduling mechanism is the ready queue and clock interrupts

the CPU scheduling policy is determined by parameters input by the system administrator and the policy is implemented by the mechanism

definition of process: executing program including its current state

general process state: running, ready, blocked, suspended, exited/aborted

complete process state is above plus: current CPU register values, current RAM contents (data, heap, stack), files read and written and what read or written in them,

possible state transitions (draw state transition directed graph)

• running to ready: time slice expires or yields the CPU
• running to exited/aborted: reaches closing curly brace, executes an exit system call (TRAP <exit> instruction), executes illegal opcode, address exceeds limit register, divides by zero, etc.
• running to blocked: process executes blocking system call like IO or sleep for n seconds or wait for some other process to finish
• running to suspended: control-Z or suspend system call (a running process suspends itself)
• ready to exited/aborted: killed by another process
• ready to suspended: control-Z or suspend system call (a running process suspends another process in the ready queue and the suspended process is taken out of the ready queue)
• ready to running: process reaches head of ready queue, i.e., chosen by CPU scheduling policy to get CPU next
• blocked to exited/aborted: killed by another process
• blocked to ready: system call completes (IO or sleep)
• suspended to ready: fg or resume system call (a running process resumes another process that was suspended and is therefore not in the ready queue and the resumed process is added to the ready queue)
• suspended to exited/aborted: killed by another process

CPU scheduling policy issues (things that affect choice of policy)

• batch, timesharing (interactive terminals), or both job mix
• background versus foreground
• size of MAX_TICKS_ALLOWED, not too small, not too big
• CPU bound versus IO bound job behavior
• priority: president job, provost job, dean job, faculty job, student job

foreground is usually interactive job, batch jobs should be run in the background at a lower priority

IO bound is usually interactive job or lots of file copying in a batch job or lots of network use in a server

CPU bound is like multiplying matrices or computing large prime numbers

the CPU scheduling policy comes into play when

• a new process is created
• a process exits/aborts
• the running process blocks
• sometimes when a hardware interrupt occurs
• a process is suspended or resumed
• a process yields the CPU (a system call in which a process asks to be moved from the head to the tail of the ready queue)

voluntary release only policy, also called non-preemptive: a running process keeps the CPU until it blocks on IO or exits/aborts or yields the CPU or suspends itself (equivalent to infinite MAX_TICKS_ALLOWED)

involuntary release policy, also called preemptive: a running process might lose the CPU at other times, too, for example MAX_TICKS_ALLOWED = 7 and a CPU bound process running

policy goals

• fair
• keep CPU and IO devices all busy (give IO bound priority)
• maximize batch throughput (jobs completed per unit time)
• minimize batch turnaround time (average completion time)
• minimize interactive response time (time from typing a command until seeing its output)
• priority to foreground (interactive) jobs over background (batch) jobs
• low overhead

some non-preemptive CPU scheduling policies with unrealistic assumptions of knowing all running times in advance, all jobs CPU-bound, and no new jobs appear

• FCFS: simple and fair, can be used in batch only system
• SJF: of theoretical interest only, minimizes average turnaround time at expense of making long jobs wait

some preemptive CPU scheduling policies

general guideline is to give IO bound jobs priority by linking them into the front of the ready queue when they become ready instead of the rear

general guideline: use multiple ready queues to implement priorities (batch versus interactive, foreground versus background, president versus provost versus dean versus faculty versus student)

round robin, i.e., MAX_TICKS_ALLOWED < infinity

• just interactive jobs, use small MAX_TICKS_ALLOWED but not too small
• just batch jobs, use large MAX_TICKS_ALLOWED but not too large
• both: use two ready queues with different MAX_TICKS_ALLOWED for each (preempt running batch job if interactive job becomes ready)

SRTN: preemptive version of SJF assuming new jobs can arrive at any time but still unrealistic assumption of knowing all running times in advance

OS must not allow starvation to occur: jobs in a lower priority queue never get any CPU time because the higher priority queue(s) are never empty

• use aging to prevent starvation: move a starving process into the highest priority queue periodically for one shot on the CPU

analogy: grocery store shopping carts in a checkout line

analogy for RR: tabbed browser loading multiple Web pages simultaneously through a fixed bandwidth Internet connection, where each Web page has a different byte count (proportional to time to download)

pick six random numbers between 1 and 500 and calculate average completion times for FCFS, SJN, and RR

Other CPU scheduling algorithms in the text book: for batch systems three-level scheduling; for interactive systems guaranteed scheduling, lottery scheduling, fair-share scheduling.

home page: http://elvis.rowan.edu/~hartley/index.html
e-mail: hartley@elvis.rowan.edu