Chapter 3: Processes

Operating System Concepts – 9th Silberschatz, Galvin and Gagne

 Chapter 3: Processes
● Process Concept
● Process Scheduling
● Operations on Processes
● Interprocess Communication

Operating System Concepts – 9th 3.2 Silberschatz, Galvin and Gagne

 Objectives
● To introduce the notion of a process -- a program in
execution, which forms the basis of all computation

● To describe the various features of processes,

including scheduling, creation and termination, and
communication

● To explore interprocess communication using shared

memory and mes- sage passing

● To describe communication in client-server systems

Operating System Concepts – 9th 3.3 Silberschatz, Galvin and Gagne

 Process Concept
● An operating system executes a variety of programs:
● Batch system – jobs
● Time-shared systems – user programs or tasks
● Textbook uses the terms job and process almost interchangeably
● Process – a program in execution; process execution must progress in
sequential fashion
● Multiple parts
● The program code, also called text section
● Current activity including program counter, processor registers
● Stack containing temporary data
4 Function parameters, return addresses, local variables
● Data section containing global variables
● Heap containing memory dynamically allocated during run time
● Program is passive entity stored on disk (executable file), process is
active
● Program becomes process when executable file loaded into memory
● Execution of program started via GUI mouse clicks, command line entry of
its name, etc
● One program can be several processes
● Consider multiple users executing the same program

Operating System Concepts – 9th 3.4 Silberschatz, Galvin and Gagne

 Process in Memory

Operating System Concepts – 9th 3.5 Silberschatz, Galvin and Gagne

 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

Operating System Concepts – 9th 3.6 Silberschatz, Galvin and Gagne

 Diagram of Process State

Operating System Concepts – 9th 3.7 Silberschatz, Galvin and Gagne

 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
● The more complex the OS and the PCB, longer the
context switch

● Time dependent on hardware support

● Some hardware provides multiple sets of registers per
CPU which facilitates multiple contexts loaded at once

Operating System Concepts – 9th 3.8 Silberschatz, Galvin and Gagne

 Process Control Block (PCB)
Information associated with each
process
(also called task control block)
● Process state – running, waiting,
etc
● Program counter – location of
instruction to next execute
● CPU registers – contents of all
process-centric registers
● CPU scheduling information-
priorities, scheduling queue
pointers
● Memory-management information
– memory allocated to the process
● Accounting information – CPU
used, clock time elapsed since
start, time limits
●System
Operating I/O Concepts
status– information
th
9 – I/O 3.9
devices Silberschatz, Galvin and Gagne
 CPU Switch From Process to Process

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Representation in Linux
Represented by the C structure
task_struct

pid t_pid; /* process identifier */

long state; /* state of the process */

unsigned int time_slice; /* scheduling information */

struct task_struct *parent; /* this process’s parent */

struct list_head children; /* this process’s children */

struct files_struct *files; /* list of open files */

struct mm_struct *mm; /* address space of this process */

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Representation in Linux

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Scheduling

● Maximize CPU use, quickly switch processes onto CPU for time
sharing
● Process scheduler selects among available processes for next
execution on CPU
● Maintains scheduling queues of processes
● 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

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Representation of Process Scheduling
Queueing diagram represents queues, resources,
flows

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Schedulers
● Long-term scheduler (or job scheduler) – selects which processes should
be brought into the ready queue
● Short-term scheduler (or CPU scheduler) – selects which process should
be executed next and allocates CPU
● Sometimes the only scheduler in a system

● Short-term scheduler is invoked very frequently (milliseconds) ⇒ (must be

fast)
● Long-term scheduler is invoked very infrequently (seconds, minutes) ⇒ (may
be slow)
● The long-term scheduler controls the degree of multiprogramming
● 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

● Long-term scheduler strives for good process mix meaning that it selects a
balanced combination of CPU-bound and I/O-bound processes to ensure
efficient
Operating system
System Concepts
th
– 9 performance 3. Silberschatz, Galvin and Gagne
 Schedulers
The short-term scheduler (CPU scheduler) is sometimes the only scheduler in
a system because of the simplicity of process handling in specific types of
systems. This occurs in systems where there is no need for medium-term or
long-term scheduling.

For example:

Batch Processing Systems

● In traditional batch systems, jobs are submitted and processed one after
another.
● There is no need for interactive user scheduling, so long-term and
medium-term schedulers are unnecessary.
● The short-term scheduler simply picks the next job when the CPU becomes
idle.

Single-User, Single-Tasking Systems

● In a system where only one process is running at a time (e.g., older

embedded systems, simple microcontrollers), no long-term or medium-
term scheduling is required.
● The short-term scheduler directly manages CPU allocation without swapping
Operatingor suspending
System Concepts – 9processes.
th
3. Silberschatz, Galvin and Gagne
 Addition of Medium Term Scheduling
● Medium-term scheduler can be added if degree of
multiple programming needs to decrease
● Remove process from memory, store on disk, bring
back in from disk to continue execution: swapping

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Operations on Processes

System must provide mechanisms for -

process creation, termination, and so on as detailed
next

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 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 options

● Parent and children share all resources
● Children share subset of parent’s resources
● Parent and child share no resources

● Execution options
● Parent and children execute concurrently
● Parent waits until children terminate

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 A Tree of Processes in Linux

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Creation (Cont.)
● Address space
● Child duplicate of parent
● Child has a program loaded into it
● UNIX examples
● fork() system call creates new process
● exec() system call used after a fork() to replace the process’
memory space with a new program

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 C Program Forking Separate Process

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 C Program Forking Separate Process

<sys/types.h>: Defines data types like pid_t (used for process IDs)
<stdio.h>: Includes standard I/O functions (e.g., printf, fprintf)
<unistd.h>: Provides access to POSIX operating system API (e.g., fork, exec, wait)

fork() creates a child process that is an exact copy of the parent process.
pid stores the return value:

● pid < 0: Fork failed (no child process created.

● pid == 0: Child process executes
● pid > 0: Parent process executes

If fork() returns a negative value, it indicates a failure (e.g., system resources exhausted)
fprintf(stderr, "Fork Failed"); prints an error message

The child process replaces its memory image with the /bin/ls command using execlp()
execlp() executes the ls command (listing files in the current directory)
If execlp() succeeds, it never returns (as the process image is replaced)

● The parent process waits for the child process to finish using wait(NULL)
● The child process executes ls, displaying the list of files in the current directory.
● Once ls finishes, the parent prints: Child Complete

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 C Program Forking Separate Process
fork( ): Creates a new child process
execlp( ): Replaces child process with a new program (ls in this
case)
wait( ): Ensures the parent waits for the child to finish before
proceeding

Process Execution Flow:

● Parent creates child.
● Child executes ls.
● Parent waits for the child to complete.
● Parent prints "Child Complete".

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Termination
● Process executes last statement and asks the operating system to
delete it (exit())
● Output data from child to parent (via wait())
● Process’ resources are deallocated 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 systems do not allow child to continue if its
parent terminates. Then all children get terminated resulting
in cascading termination

● If no parent waiting, then terminated process is a zombie

● If parent terminated, processes are orphans

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Termination
When a process terminates, its termination status needs to be collected
by the parent process. If the parent does not handle the terminated
child properly, the child can become a zombie or orphan process.

If a parent process calls wait(), it collects the exit status of the child
and prevents it from becoming a zombie.

pid_t pid = fork();

if (pid == 0) {
printf("Child process terminating\n");
exit(0); // Child process terminates
} else {
sleep(10); // Parent does not call wait(), child
becomes zombie
}

The child process terminates immediately. The parent sleeps for 10 seconds, so
it does not collect the child’s exit status. During this time, the child remains a
zombie in the system.

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Termination
An orphan process occurs when the parent terminates before the
child, leaving the child without a parent.

pid_t pid = fork();

if (pid == 0) {
sleep(5); // Child sleeps while parent terminates
printf("Orphan process running\n");
} else {
exit(0); // Parent exits immediately
}

What Happens to Orphans?

● Orphan processes are adopted by the init (PID 1) process in

Unix/Linux.
● The init process automatically reaps orphans, preventing them
from becoming zombies.

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Process Termination

● Zombies waste system resources, so always use wait( ).

● Orphans are not a problem because init takes care of them.

● Use proper process management to avoid resource issues.

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Interprocess Communication
● Processes within a system may be independent or
cooperating
● Cooperating process can affect or be affected by other
processes, including sharing data
● Reasons for cooperating processes:
● Information sharing
● Computation speedup
● Modularity
● Convenience
● Cooperating processes need interprocess
communication (IPC)
● Two models of IPC
● Shared memory
● Message passing

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Interprocess Communication
● Processes within a system may be independent or
cooperating
● Cooperating process can affect or be affected by other
processes, including sharing data
● Reasons for cooperating processes:
● Information sharing
● Computation speedup
● Modularity
● Convenience

● A web browser consists of separate processes for rendering,

networking, and JavaScript execution.

● If one process (e.g., a web page’s script execution) crashes, the

entire browser doesn’t crash. This modular approach improves
stability and security

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Interprocess Communication

● Cooperating processes need interprocess

communication (IPC)
● Two models of IPC
● Shared memory
● Message passing

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Communications Models

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne

 Multiprocess Architecture: Chrome Browser

● Many web browsers ran as single process (some still do)

● If one website causes trouble, entire browser can hang
or crash
● Google Chrome Browser is multiprocess with 3 categories
● Browser process manages user interface, disk and
network I/O
● Renderer process renders web pages, deals with HTML,
Javascript, new one for each website opened
4 Runs in sandbox restricting disk and network I/O,
minimizing effect of security exploits
● Plug-in process for each type of plug-in

Operating System Concepts – 9th 3. Silberschatz, Galvin and Gagne