Process [40]

program

• program: source code compiled to executable

• passive entity and resides on disk

process

• process: a program in execution

• active entity and the unit of work

• data for the variables used by the instructions

• also called a job or task

• long time to switch heavyweight processes

thread

• short time to switch lightweight processes

• subprocesses inside a process

CPU

• Central Processing Unit or processor

• executes processes, performing the instructions

Process: Definitions [41]

running

• one process is running, or executing, on the CPU

concurrent

• time-share CPU - appear to run simultaneously

cooperating

• interact and affect each other

• share data or resources

• synchronous

• asynchronous: not cooperating (no interaction)

state

• current activity or condition (e.g. running)

suspended

• waiting for memory - then joins the ready queue

Process: Definitions [42]

ready

• waiting for access to the CPU

• not waiting for I/O or some other event

• in the ready queue - list of process IDs (PIDs)

• ready to running: scheduled for CPU

• running to ready: interrupted by scheduler

• running to waiting

waiting

• not ready to use the CPU

• waiting for I/O or memory

• waiting for a semaphore to be signaled

• waiting for a message to be received

device queue

• waiting for Input

• waiting for Output

Process: State Changes [43]

Figure 4.1:

state changes

• new processes admitted to ready queue

• ready process is scheduled for CPU

• current running process returns to ready

• or terminates

• or waits for I/O or other event

Visual OS (VOS): A Process Manager [44]

VOS: States [45]

free:	not in the system - unused PID's
suspended:	waiting for admittance to ready queue
	see long-term scheduler in Memory Management
ready:	waiting for the CPU
running:	executing on the CPU
waiting:	for a semaphore signal (synchronization)
receiving:	waiting for a message send
sleeping:	waiting for a wakeup timer
writing:	output to console
reading:	input from keyboard

VOS System Calls [46]

process	(pid,prio)	:	free	$\rightarrow$	suspended
resume	(pid)	:	suspended	$\rightarrow$	ready
suspend	(pid)	:	ready	$\rightarrow$	suspended
			running	$\rightarrow$	suspended
set_prio	(pid,prio)	:	ready	$\rightarrow$	running
			running	$\rightarrow$	ready
resched	()	:	ready	$\rightarrow$	running
			running	$\rightarrow$	ready
wait	(sem)	:	running	$\rightarrow$	waiting
signal	(sem)	:	waiting	$\rightarrow$	ready
receive	(&pid)	:	running	$\rightarrow$	receiving
send	(pid,msg)	:	receiving	$\rightarrow$	ready
sleep	(delay)	:	running	$\rightarrow$	sleeping
wakeup	(pid)	:	sleeping	$\rightarrow$	ready
putline	(str)	:	running	$\rightarrow$	writing
(console)	()	:	writing	$\rightarrow$	ready
getline	(str)	:	running	$\rightarrow$	reading
(keyboard)	()	:	reading	$\rightarrow$	ready
destroy	(pid)	:	any	$\rightarrow$	free

Process Control Block (PCB) [47]

Figure 4.2:

pointer

process state

process number

program counter

registers

memory limits

list of open files

...

• each process has its own PCB

• program counter (pc) points to the next instruction to be executed

• information is sufficient to stop/restart process (context switch)

• store all registers, etc. in PCB1

• put PID1 back in ready queue (or other queue)

• remove PID2 from ready queue, load registers based on PCB2

• start executing PID2 at pc register

Program Counter (pc) [48]

      |                 |                 |                 \
       \               /             pc-> |                 /
        |              \                  |                /
        |               |                  \          pc-> \
       /                |                  /                \
 pc-> |                /                  /                 /
     /                 \                 /                 /
    |                   \               /                  \
    |               pc-> \              \                   \
     \                   /               \                  /

• each process (or thread) has a pc

• increments sequentially but branches for loops and conditionals

Context Switch by Dispatcher [49]

  executing |                                           .              
            v --------------> dispatcher                . idle
            .                 SAVE: PCB 1               .
            .                 LOAD: PCB 2 ------------> |
       idle .                                 executing |          
            .                                           |
            .                 dispatcher  <------------ v
            .                 SAVE: PCB 2               .       
            | <-------------- LOAD: PCB 1               . idle
  executing v                                           .

• CPU is switched to another process

• state (PCB) of the old process is saved

• saved state of the new process is loaded

Interrupts [50]

• event that alters the sequence of instruction execution

• OS is interrupt driven:

• sits quietly (no polling) until told there is something to do

• interrupt is generated by hardware or software

• Steps:

• interrupts (usually) are disabled to prevent new ones

• OS gains control of CPU

• OS saves state of interrupted process (if user process: PCB)

• OS analyzes interrupt, passes control to interrupt handler routine

• predefined number of routines

• index into table (interrupt vector) that points to routines

• routine processes interrupt

• restore state of interrupted process (or some ``next'' process)

• interrupts (usually) are enabled to allow new ones

• interrupted process (or ``next'') executes

Interrupts [51]

software interrupts:

• program check interrupt: division by zero, bad memory location

• system call to OS kernel (trap)

• kernel is aware of process crossing its border

• example: read()

• kernel's device driver processes request

• loads registers in device controller and starts controller

• controller transfers data to buffer

• when controller is finished: generates a hardware I/O interrupt

hardware interrupts:

• I/O interrupt

• I/O completed, CPU can restart user process or ``next'' process

• external interrupt: expiration of quantum on clock

• allows OS dispatcher to context switch to next process