1. Operating Systems Processes

2. 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

3. 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

4. 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()

5. 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

6. Diagram of Process State

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

8. 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!

9. 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

10. A tree of processes on a typical Solaris

11. 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

12. 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

13. 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!!!

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

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

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

17. Ready Queue And Various I/O Device Queues

18. Representation of Process Scheduling

19. 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)

20. 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

21. CPU Switch From Process to Process

22. 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

23. 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?

24. 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

25. 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)

26. 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: ( )/3 = 17 P1 P2 P3 24 27 30

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

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

29. Round Robin (RR)
Each process gets a small unit of CPU time (time quantum), usually 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

30. 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

31. Time Quantum and Context Switch Time

32. CPU SCHEDULING EXAMPLE DATA: Process Arrival Service Time Time 1 0 8

33. Example of RR with Time Quantum = 20
Example: Process Burst Time Remaining Time P P P P
The Gantt chart is:

34. 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

35. Multilevel Queue Scheduling

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

37. Multilevel Feedback Queues

38. 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

39. 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?

40. 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?