Operating Systems

Process Management
By Rizal Mohd Nor
Slides adopted from Mikhail Nesterenko OS slides at Kent State University
Previous slides review
 major OS duties are
 process management
 memory management
 disk/file management
 OS interacts with users through system calls, to ease interaction
 API - for app. programmers
 GUI or CLI for end-users
 OS is a big and complex program; traditional monolithic kernel
design approach yields OSes that are fast but hard to develop,
modify and debug; other approaches have been suggested:
 microkernel
 virtual machine
Lecture 4: Process Management

 process
 process creation/termination
 context
 process control block (PCB)
 context switch
 5-state process model
 process scheduling
 short/medium/long term
 Unix process model

3
 Process

 process (also called task, or job) is a program in

execution
 process
 program code (or text) sequence of instructions to
be executed
 note: multiple processes may be running the same code
(editor, web-browser, etc)
 context (execution state)

prompt% ps -efl
UID PID PPID C STIME TTY TIME COMMAND
root 0 0 0 Jan 19 ? 10:53 swapper
root 1 0 0 Jan 19 ? 0:17 init
root 2 0 0 Jan 19 ? 7:39 telnetd
…
4 rizal 1546 1321 0 15:38:45 pts/17 3:31 chrome
Unix Process Creation
 one process can create another process, perhaps to do
some work for it
 child – the new process
 an (almost) identical copy of parent (same code, same data, etc.)
 parent – the original process
 parent can either wait for the child to complete, or continue executing in parallel (concurrently) with
the child
 parent does not terminate until the child does
 In UNIX, a process creates a child process using the system call fork( )
 In child process, fork() returns 0
 In parent process, fork() returns process id of new child
 child often uses exec( ) to start another completely different program

5
 Process Creation

Process Parent
spawning Child process
process
• when the • is the • is the new
OS creates a original, process
process at creating,
the explicit process
request of
another
process
Example of Unix Process Creation

#include <sys/types.h>
#include <stdio.h>
int a = 6;/* global (external) variable */
int main(void) {
int b; /* local variable */
pid_t pid; /* process id */ example execution
b = 88; prompt% forkprogram
printf("..before fork\n"); ..before fork
..after fork, a = 7, b = 89
pid = fork(); ..after fork, a = 6, b = 88
if (pid == 0) { /* child */
a++; b++;
} else /* parent */
wait(pid);

printf("..after fork, a = %d, b = %d\n", a, b);

exit(0);
}
7
Unix Process Tree
as one processes creates another, they form a tree

8
 Process Termination

 There must be a means for a process to indicate its

completion
 A batch job should include a HALT instruction or an
explicit OS service call for termination
 For an interactive application, the action of the user will
indicate when the process is completed (e.g. log off,
quitting an application)
 Process Termination In Unix

 after completing work a process may execute exit()

system call – asking the OS to delete it
 parent is notified
 process’ resources are deallocated by operating system
 parent may terminate execution of a child process -
abort() system call
 possible reasons
 task assigned to child is no longer required
 child exceeded allocated resources
 if parent exits (some) OS require all children to
terminate – cascading termination

10
Reasons for
Process
Termination
 Context
 context – information about running process
 program code (?)
 static data (bss)
 heap (dynamic data) program memory
 procedure call stack - contains temporary data - subroutine allocation
parameters, return addresses, local variables
 register contents
 general purpose registers
 program counter (PC) — address of next instruction to be executed
 stack pointer (SP)
 program status word (PSW) — interrupt status, condition codes, etc.
 OS resources in use - open files, connections to other
programs
 accounting information
 note that for each process there are two contexts
 for user mode and for kernel mode
12
 Process Control Block
 process control block (PCB) – data structure
maintained by OS to keep track of process’ state
 contains
 process id number
 user id of the owner
 process state (running, not-running, etc.)
 PC, SP, PSW, general purpose registers
 memory limits (static, dynamic) - base/limit register
contents
 list of open files
 CPU scheduling information (e.g., priority)
 I/O states, I/O in progress - list of I/O devices
allocated to process, list of open files, etc. status of I/O
requests
 …
13
 Context Switch
 context switch - stopping one
process and
restarting another
sequence of actions
 OS takes control (through
interrupt)
 saves old context in the
process PCB
 reloads new context
from the new process
PCB
 this amounts to changing
the execution of processes (as soon as the PC is reloaded)
 returns control to app. program
 how is context switch different from mode switch? How are they similar?
how many mode switches are there in a context switch?
 context switch requires several thousand instructions
time-sharing
 14 OS may do 100–1000 context switches a second
Interleaving of Process Execution in Time-Sharing OS

from the user’s standpoint

in reality OS interleaves
multiple processes
are executed concurrently
process execution

time time
process A
process process process process B
A B C process C
process A
process B
process C
process process A
D process C
process A
process D
process C
process D
process C

15
 Five State Process Model
 OS maintains the state of a process.
 process is
 new – when it is being created
 running - executing on the CPU
 waiting (blocked) – waiting on input/output event to occur
 ready – ready to run on the CPU
 terminated – finished execution, is being destroyed
 how many processes in the system can be in a particular state?

16
 OS Process Queues
OS queues PCBs according to their state
 ready queue –
processes in state
ready (waiting to
be run on CPU)
 for each device there
is an I/O queue –
processes in state
waiting, blocked
on particular device
waiting for their
request to be
submitted
to the device
controller
17
 Short Term
Scheduler
 selects process
from the ready
queue to run on
the CPU
 runs when
 process is created
or terminated
 process switches
from running to blocked
 interrupt occurs
 goals:
 minimize response time (e.g., program execution, character to screen)
 minimize variance of average response time — predictability may be important
 maximize throughput
 minimize overhead (OS overhead, context switching, etc.)
 efficient use of resources
18
 fairness — share CPU in an equitable fashion
Other Types
of Schedulers

 medium-term
scheduler
 temporarily
swaps processes in/out of main memory
 may suspend/resume processes
 goal: balance load for better throughput
 long-term scheduler (job scheduler) – does not exist on time-sharing OS
 selects job from the spool, and loads it into memory
 executes infrequently, maybe only when process leaves system
 controls degree of multiprogramming
 goal: good mix of CPU-bound and I/O-bound processes
 I/O-bound process – spends more time doing I/O than computations, many short CPU
bursts
 CPU-bound process – spends more time doing computations; few very long CPU bursts

19
 Unix Process States

 enhanced 5-state model

 blocked and ready states has to be split depending on
whether a process is swapped out on disk or in memory
 running state is also split depending on the mode: kernel or user
 Unix process states:
 created - just created not yet ready to run
 ready (memory) - ready as soon as kernel schedules it
 ready (disk) - ready, but needs to be swapped to memory
 asleep - blocked (memory) - waiting on event in memory
 asleep - blocked (disk) - waiting on event on disk
 running (kernel) - executing in kernel mode
 running (user) - executing in user mode
 zombie - process terminated but left a record for parent to collect

20
 Unix Process Scheduling
 process is running in user mode until an interrupt occurs or
it executes a system call
 if time slice expires the process is preempted and another is scheduled
 a process goes to sleep if it needs to wait for some event to occur and is woken up when
this event occurs
 when process is created decision is made whether to put it in memory or disk
fork
user mode kernel mode
interrupt enough created not enough
memory memory
kernel schedule swap out
return running ready swap in
ready
interrupt, preempt
user
system call
running wakeup wakeup
exit
sleep
swap out
zombie asleep asleep
21 disk