1. Tarek Abdelzaher Vikram Adve Marco Caccamo
Processes
Tarek Abdelzaher
Vikram Adve
Marco Caccamo
Copyright ©: Nahrstedt, Angrave, Abdelzaher

2. Users, Programs, Processes
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Users, Programs, Processes
Users have accounts on the system
Users launch programs
Many users may launch same program
One user may launch many instances of the same program
Processes:
an executing program (the unit of work of a modern computer)

3. Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process States
Possible process states (simplified view):
Running (occupy CPU)
Blocked
Ready (does not occupy CPU)

4. Linux: 5 State Process Model
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Linux: 5 State Process Model
Add states for creating and deleting process
Add transitions Timeout, Dispatch, Event Occurs

5. How to List all Processes?
Copyright ©: Nahrstedt, Angrave, Abdelzaher
How to List all Processes?
On Windows: run Windows task manager
Hit Control+ALT+delete
Click on the “processes” tab
On UNIX
$ ps –e
Try “man ps” to understand more about its usage.

6. Process Identification
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process Identification
UNIX identifies processes via a unique Process ID
Each process also knows its parent process ID since each process is created from a parent process.
Root process is the ‘init’ process
‘getpid’ and ‘getppid’ – functions to return process ID (PID) and parent process ID (PPID)
Example 1
#include <stdio.h>
#include <unistd.h>
int main (void) {
printf(“I am process %ld\n”, (long)getpid());
printf(“My parent id is %ld\n”, (long)getppid());
return 0; }

7. Creating a Process – fork()
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Creating a Process – fork()
pid_t fork() creates a duplicate of the calling process:
Both processes continue with return from fork()
Child gets exact copy of code, stack, file descriptors, heap, globals, and program counter
fork() returns
-1 if fork fails
0 in child process
child’s PID in parent process

8. Creating a child Process – fork()
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Creating a child Process – fork()
fork() creates a new process by duplicating the calling process. The new process, referred to as the child, is an exact duplicate of the calling process, referred to as the parent, except for the following points:
The child has its own unique process ID
The child does not inherit its parent’s memory locks (e.g., mlock(2)).
Process resource utilizations and CPU time counters are reset to zero in the child.
The child’s set of pending signals is initially empty.
The child does not inherit record locks from its parent (fcntl(2)).
The child does not inherit timers from its parent.
The termination signal of the child (sent to the parent) is always SIGCHLD. 8 8

9. Creating a child Process – fork()
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Creating a child Process – fork()
The entire virtual address space of the parent is replicated in the child, including the states of mutexes, etc.
The child inherits copies of the parent’s set of open file descriptors. Each file descriptor in the child refers to the same open file description (see open(2)) as the corresponding file descriptor in the parent. This means that the two descriptors share open file status flags, and current file offset. 9 9

10. Creating a Process in Unix
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Creating a Process in Unix
Example 2
#include <stdio.h>
#include <unistd.h>
int main(void) {
pid_t x;
x = fork();
if (x == 0)
printf(“In child: fork() returned %ld\n”, (long) x);
else
printf(“In parent: fork() returned %ld\n", (long) x); }
What does this print?

11. Copyright ©: Nahrstedt, Angrave, Abdelzaher
Chain and Fan
What is the difference between these two segments of code?
pid_t childpid = 0;
for (i=1;i<n;i++)
if (childpid = fork())
break;
pid_t childpid = 0;
for (i=1;i<n;i++)
if ((childpid = fork()) <=0)
break;

12. Copyright ©: Nahrstedt, Angrave, Abdelzaher
Chain and Fan
Fan
Chain
pid_t childpid = 0;
for (i=1;i<n;i++)
if ((childpid = fork()) <=0)
break;
pid_t childpid = 0;
for (i=1;i<n;i++)
if (childpid = fork())
break;
Parent
Parent
Child
Child
Child
Child … … 12 12

13. Process Operations: Creation
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process Operations: Creation
A new process needs resources such as CPU, memory, file descriptors
Child can get resources from OS or from parent
Child address space is a duplicate of parent process
Child process is given a subset of parent resources
Prevents too many processes from overloading system
Execution possibilities are
Parent continues concurrently with child
Parent waits until child has terminated

14. Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process Termination
Normal exit (voluntary)
Returning zero from main()
exit(0)
Error exit (voluntary)
exit(1)
Fatal error (involuntary)
Divide by 0, seg fault, exceeded resources
Killed by another process (involuntary)
Signal: kill(procID)

15. Process Operations: Termination
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process Operations: Termination
When a child process terminates:
Open files are flushed and closed
tmp files are deleted
Child’s resources are de-allocated
File descriptors, memory, semaphores, file locks, …
Parent process is notified via signal SIGCHLD
Exit status is available to parent via wait()

16. Copyright ©: Nahrstedt, Angrave, Abdelzaher
Process Hierarchies
Parent creates a child process, a child process can create its own child processes
Forms a hierarchy
UNIX calls this a "process group"
Windows has no concept of process hierarchy
all processes are created equal

17. wait(), waitpid() System Calls
Copyright ©: Nahrstedt, Angrave, Abdelzaher
wait(), waitpid() System Calls
pid_t wait(int *status);
wait() causes parent process to wait (block) until some child finishes
wait() returns child’s pid and exit status to parent
waitpid() waits for a specific child
errno
Cause
ECHILD
Caller has no unwaited-for children
EINTR
Function was interrupted by signal
EINVAL
Options parameter of waitpid was invalid

18. Copyright ©: Nahrstedt, Angrave, Abdelzaher
wait(), waitpid() System Calls
pid_t wait(int *status);
In the case of a terminated child, performing a wait allows the system to release the resources associated with the child; if a wait is not performed, then the terminated child remains in a "zombie“ state.
If a child has already terminated, then the call returns immediately. Otherwise it blocks until either a child terminates or a signal handler interrupts the call. A child that has terminated and which has not yet been waited upon by this system call (or waitpid) is termed waitable. 18 18

19. Copyright ©: Nahrstedt, Angrave, Abdelzaher
wait(), waitpid() System Calls
If status is not NULL, wait() stores status information in the int to which it points. This integer can be inspected with specific macros (see man pages):
WIFEXITED(status)
returns true if the child terminated normally, that is, by calling exit, or by returning from main().
WEXITSTATUS(status)
returns the exit status of the child. This consists of the least significant 8 bits of the status argument that the child specified in a call to exit or as the argument for a return statement in main(). This macro should only be employed if WIFEXITED returned true. 19 19

20. Copyright ©: Nahrstedt, Angrave, Abdelzaher
wait() & “zombie”
A child that terminates, but has not been waited for becomes a "zombie". The kernel maintains a minimal set of information about the zombie process (PID, termination status, resource usage information) in order to allow the parent to later perform a wait to obtain information about the child.
As long as a zombie is not removed from the system via a wait, it will consume a slot in the kernel process table, and if this table fills, it will not be possible to create further processes.
If a parent process terminates, then its "zombie" children (if any) are adopted by init(8), which automatically performs a wait to remove the zombies. 20 20

21. Waiting for a child to finish (Try “man –s 2 wait”)
Copyright ©: Nahrstedt, Angrave, Abdelzaher
Waiting for a child to finish (Try “man –s 2 wait”)
#include <errno.h>
#include <sys/wait.h>
pid_t childpid;
childpid = wait(NULL);
if (childpid != -1)
printf(“waited for child with pid %ld\n”, childpid);