1. CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda
School of Computing Science
Simon Fraser University
CMPT 300: Operating Systems I
Ch 3: Processes
Dr. Mohamed Hefeeda

2. Objectives Understand Process concept Process scheduling
Creating and terminating processes
Interprocess communication

3. Process Concept Process is a program in execution Note:
process execution must progress in sequential fashion
Note:
The terms job and process are interchangeable
A process includes:
program counter
stack
data section

4. Process in Memory int global = 0; int main (int arg) Local variables {
float local;
char *ptr;
ptr = malloc(100);
local = 0;
local += 10*5;
….. ….
foo();
…. /* return addr */
return 0; }
Dynamically allocated
Global variables
Program code
Local variables
Return address

5. Process State As process executes, it changes state new: just created
running: instructions are being executed
waiting: process is waiting for some event to occur
ready: process is waiting for CPU
terminated: process has finished execution

6. Process Control Block (PCB)
OS maintains info about process in PCB
Process state
Program counter
CPU registers
CPU scheduling info
Memory-management info
Accounting info
I/O status info
PCB used to manage processes
E.g., to switch CPU from one process to another
Typically, a large C structure in kernel
Linux: struct task_struct

7. CPU Switch From Process to Process (Context Switch)
When switching occurs, kernel
Saves state of P0 in PCB0 (in memory)
Loads state of P1 from PCB1 into registers
State = values of the CPU registers, including the program counter, stack pointer

8. Context Switch
Context-switch time is pure overhead; no useful work is done
Switching time depends on hardware support
Some systems (Sun UltraSPARC) provide multiple register sets  very fast switching (just change a pointer)
Typical systems, few milliseconds for switching

9. Job Types Jobs (Processes) can be described as either:
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

10. Scheduling: The Big Picture
Consider a large computer system to which many jobs are submitted
Initially, jobs go to the secondary storage (disk)
Then, job scheduler chooses some of them to go to memory (ready queue)
Then, CPU scheduler chooses from ready queue a job to run on CPU
Medium-term scheduler may move (swap) some partially-executed jobs from memory to disk (to enhance performance)

11. Scheduling: The Big Picture (cont’d)
Disk
Jobs
Job sched.
CPU sched.
Midterm sched.
In most small and interactive systems (UNIX, WinXP, …), only the CPU scheduler exists

12. Schedulers Long-term scheduler (or job scheduler)
Selects which processes should be brought into ready queue
Controls the degree of multiprogramming
Invoked infrequently (seconds, minutes)
 can be slow
Should maintain a ‘good mix’ of CPU-bound and I/O-bound jobs in the system

13. Schedulers (cont’d) Short-term scheduler (or CPU scheduler)
selects which process should be executed next and allocates CPU to it
Short-term scheduler is invoked very frequently (milliseconds)
 must be fast
Medium-term scheduler
Swaps processes in and out of ready queue to enhance performance (i.e., maintain the good mix of jobs)

14. Scheduling Queues Processes migrate among various 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

15. Process Lifetime

16. Process Creation Parent process creates children processes, Execution
which, in turn may create other processes,
forming a tree of processes
Execution
Parent and children execute concurrently
Parent waits until children terminate
Resource sharing can take the form:
Parent and children share all resources
Children share subset of parent’s resources
Parent and children share no resources

17. Process Creation: Unix Example
Process creates another process (child) by using fork system call
Child is a copy of the parent
Typically, child loads another program into its address space using exec system call
Parent waits for its children to terminate

18. C Program Forking Separate Process
int main() {
pid_t pid;
pid = fork(); /* fork another process */
if (pid < 0) { /* error occurred */
fprintf (stderr, “fork Failed");
exit(-1); }
else if (pid == 0) { /* child process */
execlp ("/bin/ls", "ls", NULL);
else { /* parent process */
/* parent will wait for child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);
Note: fork returns 0 to child and the pid of the new process to parent.

19. A tree of processes on a typical Solaris

20. Process Termination
Process executes last statement and asks OS to delete it (exit)
Process’ resources are de-allocated by OS
Output data from child to parent (via wait)
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 OSes do not allow child to continue if its parent terminates
All children of the children are terminated (cascad termination)

21. Cooperating Processes
Cooperating process can affect or be affected by the execution of another process
Why processes cooperate?
Information sharing
Computation speed-up
Modularity, Convenience
Interprocess Communication (IPC) methods
Shared memory
Message passing

22. Interprocess Communication Models
Message Passing
Shared Memory

23. IPC: Shared Memory
Processes communicate by creating a shared place in memory
One process creates a shared memory—shmget()
Other processes attach shared memory to their own address space—shmat()
Then, shared memory is treated as regular memory
Synchronization is needed to prevent concurrent access to shared memory (conflicts)
Pros
Fast (memory speed)
Convenient to programmers (just regular memory)
Cons
Need to manage conflicts (tricky for distributed systems)

24. IPC: Message Passing
If processes P and Q wish to communicate, they need to:
establish a communication channel between them
exchange messages via:
send (message) – message size fixed or variable
receive (message)
Pros
No conflict  easy to exchange messages especially in distributed systems
Cons
Overhead (message headers)
Slow
prepare messages
Kernel involvement: sender  kernel  receiver (several system calls)

25. IPC: Message Passing (cont’d)
Communication channel can be
Direct: Processes must name each other explicitly:
send (P, message) – send a message to process P
receive (Q, message) – receive a message from process Q
Indirect: Processes communicate via mailboxes (or ports)
Messages are sent to and received from mailboxes
Each mailbox has a unique id
Send (A, message) – send a message to mailbox A
Receive (A, message) – receive a message from mailbox A

26. IPC: Message Passing (cont’d)
Synchronization: message passing is either
Blocking (or synchronous)
send () has sender block until message is received
receive () has receiver block until message is available
Non-blocking (or asynchronous)
send () has sender send message and continue
receive () has receiver receive a valid message or null
Buffering: Queue of messages attached to communication channel
Zero capacity – Sender must wait for receiver (rendezvous)
Bounded capacity – Sender must wait if link full
Unbounded capacity – Sender never waits

27. Summary Process is a program in execution Process scheduling
OS maintains process info in PCB
Process State diagram
Creating and terminating processes (fork)
Process scheduling
Long-, short-, and medium-term schedulers
Scheduling queues
Interprocess communication
Shared memory
Message passing