Operating Systems Processes

What is a process? An instance of an application execution Process is the most basic abstractions provided by OS An isolated computation context for each application Computation context CPU state + address space + environment

What’s “in” a process? A process consists of (at least): An address space, containing the code (instructions) for the running program the data for the running program (static data, heap data, stack) CPU state, consisting of The program counter (PC), indicating the next instruction The stack pointer Other general purpose register values A set of OS resources open files, network connections, sound channels, … In other words, it’s all the stuff you need to run the program or to re-start it, if it’s interrupted at some point

The OS’s process namespace (Like most things, the particulars depend on the specific OS, but the principles are general) The name for a process is called a process ID (PID) An integer The PID namespace is global to the system Only one process at a time has a particular PID Operations that create processes return a PID E.g., fork() Operations on processes take PIDs as an argument E.g., kill(), wait(), nice()

Process State As a process executes, it changes state new: The process is being created running: Instructions are being executed waiting: The process is waiting for some event to occur ready: The process is waiting to be assigned to a processor terminated: The process has finished execution

Diagram of Process State

Process States terminated running schedule wait for event preempt created ready blocked event done

State queues The OS maintains a collection of queues that represent the state of all processes in the system typically one queue for each state e.g., ready, waiting, … each PCB is queued onto a state queue according to the current state of the process it represents as a process changes state, its PCB is unlinked from one queue, and linked onto another Once again, this is just as straightforward as it sounds! The PCBs are moved between queues, which are represented as linked lists. There is no magic!

Process Creation Parent process create children processes, which, in turn create other processes, forming a tree of processes Generally, process identified and managed via a process identifier (pid) Resource sharing Parent and children share all resources Children share subset of parent’s resources Parent and child share no resources Execution Parent and children execute concurrently Parent waits until children terminate

A tree of processes on a typical Solaris

Process Termination Process executes last statement and asks the operating system to delete it (exit) Process’ resources are de-allocated by operating system Parent may terminate execution of children processes (abort) Child has exceeded allocated resources Task assigned to child is no longer required If parent is exiting Some operating system do not allow child to continue if its parent terminates All children terminated - cascading termination

CPU state=Register contents Process Status Word (PSW) exec. mode, last op. outcome, interrupt level Instruction Register (IR) Current instruction being executed Program counter (PC) Stack pointer (SP) General purpose registers

The PCB The PCB is a data structure with many, many fields: process ID (PID) parent process ID execution state program counter, stack pointer, registers address space info UNIX user id, group id scheduling priority accounting info pointers for state queues In Linux: defined in task_struct (include/linux/sched.h) over 95 fields!!!

Address space Text Program code Data Predefined data (known in compile time) Heap Dynamically allocated data Stack Supporting function calls

Process Control Block (PCB) Information associated with each process Process state Program counter CPU registers CPU scheduling information Memory-management information Accounting information I/O status information

Process Scheduling Queues Job queue – set of all processes in the system Ready queue – set of all processes residing in main memory, ready and waiting to execute Device queues – set of processes waiting for an I/O device Processes migrate among the various queues

Ready Queue And Various I/O Device Queues

Representation of Process Scheduling

Schedulers Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue (seconds, minutes)  (may be slow) Short-term scheduler (or CPU scheduler) – selects which process should be executed next and allocates CPU (milliseconds)  (must be fast)

Context Switch When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process via a context switch Context of a process represented in the PCB Context-switch time is overhead; the system does no useful work while switching Time dependent on hardware support

CPU Switch From Process to Process

CPU Scheduler Selects from among the processes in memory that are ready to execute, and allocates the CPU to one of them CPU scheduling decisions may take place when a process: 1. Switches from running to waiting state 2. Switches from running to ready state 3. Switches from waiting to ready 4. Terminates Scheduling under 1 and 4 is nonpreemptive All other scheduling is preemptive

When to assign? Pre-emptive vs. non-preemptive schedulers once you give somebody the green light, they’ve got it until they relinquish it an I/O operation allocation of memory in a system without swapping Preemptive you can re-visit a decision setting the timer allows you to preempt the CPU from a thread even if it doesn’t relinquish it voluntarily in any modern system, if you mark a program as non-runnable, its memory resources will eventually be re-allocated to others Re-assignment always involves some overhead Overhead doesn’t contribute to the goal of any scheduler We’ll assume “work conserving” policies Never leave a resource idle when someone wants it Why even mention this? When might it be useful to do something else?

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

Scheduling Criteria CPU utilization – keep the CPU as busy as possible Throughput – # of processes that complete their execution per time unit Turnaround time – amount of time to execute a particular process Waiting time – amount of time a process has been waiting in the ready queue Response time – amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment)

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 P1 P2 P3 24 27 30

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

Example of SJF Process Arrival Time Burst Time P1 0.0 6 P2 0.0 8 SJF scheduling chart Average waiting time = (3 + 16 + 9 + 0) / 4 = 7 P4 P3 P1 3 16 9 P2 24

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

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 P1 P2 P3 4 7 10 14 18 22 26 30

Time Quantum and Context Switch Time

CPU SCHEDULING EXAMPLE DATA: Process Arrival Service Time Time 1 0 8 1 0 8 2 1 4 3 2 9 4 3 5

Example of RR with Time Quantum = 20 Example: Process Burst Time Remaining Time P1 53 53 P2 8 8 P3 68 68 P4 24 24 The Gantt chart is:

Multilevel Queue Ready queue is partitioned into separate queues: foreground (interactive) background (batch) 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

Multilevel Queue Scheduling

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.

Multilevel Feedback Queues

Multiple-Processor Scheduling CPU scheduling more complex when multiple CPUs are available Homogeneous processors within a multiprocessor Asymmetric multiprocessing – only one processor accesses the system data structures, alleviating 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 Processor affinity – process has affinity for processor on which it is currently running soft affinity hard affinity

Scheduling Metrics Waiting Time: time the job is waiting in the ready queue Time between job’s arrival in the ready queue and launching the job Service (Execution) Time: time the job is running Response (Completion) Time: Time between job’s arrival in the ready queue and job’s completion Response time is what the user sees: Time to echo a keystroke in editor Time to compile a program Response Time = Waiting Time + Service Time Throughput: number of jobs completed per unit of time Throughput related to response time, but not same thing: Minimizing response time will lead to more context switching than if you only maximized throughput What does CPU scheduling have to do with efficient use of the disk? A lot! Have to have the CPU to make a disk request Fairness: Minimize # of angry phone calls? Minimize my response time?

Scheduling Policy Goals/Criteria Minimize Response Time Minimize elapsed time to do an operation (or job) Maximize Throughput Two parts to maximizing throughput Minimize overhead (for example, context-switching) Efficient use of resources (CPU, disk, memory, etc) Fairness Share CPU among users in some equitable way Fairness is not minimizing average response time: Better average response time by making system less fair What does CPU scheduling have to do with efficient use of the disk? A lot! Have to have the CPU to make a disk request Fairness: Minimize # of angry phone calls? Minimize my response time?