Process in Operating Systems and the Contrast Between Interprocess Communication Models

A process in an operating system is the active execution of a program, not merely the program file stored on disk.2 A process includes its code, current activity, CPU state, memory regions such as stack and heap, open files, and other execution metadata maintained by the OS.2 In academic terms, a program is passive, whereas a process is dynamic and schedulable.2

Processes are central to multiprogramming, because the OS must create, schedule, suspend, resume, and terminate them while preserving correctness and fairness.2 To do this, the operating system maintains a process control block or PCB for each process, containing fields such as process state, program counter, CPU registers, scheduling information, memory-management data, accounting data, and I/O status.2

A process typically moves through standard states such as new, ready, running, waiting or blocked, and terminated.2 These states express whether the process is prepared to execute, currently executing, stalled for an event such as I/O, or finished.2 The transition among these states is a foundation for CPU scheduling and context switching.2

When processes need to cooperate, they require interprocess communication or IPC.2 The two fundamental IPC models are shared memory and message passing.2 Shared memory emphasizes speed after setup because the kernel mainly assists in establishing the region, while message passing emphasizes structure, isolation, and easier communication across process or machine boundaries.2

Footnotes

1. Lecture 4: Process State - Defines a process as a dynamic instance of a program and describes its memory components. ↩ ↩² ↩³

2. Operating Systems Lecture Notes - Distinguishes program and process as passive versus active entities. ↩

3. Chapter 3: Processes - Textbook-style material on process states, PCB, creation, termination, and IPC models. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

4. Operating Systems: Processes - Explains the program-versus-process distinction and core process concepts. ↩ ↩²

5. Lecture 4 (January 24, 2000) - Describes PCB contents, process state, and OS-maintained process context. ↩ ↩²

6. States of a Process in Operating Systems - Summarizes standard process states and context switching behavior. ↩ ↩²

7. Inter-Process Communication - OMSCS Notes - Explains shared memory and message-based IPC, synchronization, and OS involvement. ↩ ↩² ↩³

8. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩²

9. MESSAGE-PASSING SYSTEMS VERSUS SHARED MEMORY SYSTEMS - Compares synchronization, communication behavior, and suitability of shared memory and message passing. ↩

Understanding the Term Process in Operating System

A process is best understood as the complete execution environment of a running program.2 It contains more than instructions: it also includes the current CPU context, memory image, resource ownership, and relationships with other processes.2 Thus, if two users launch the same editor, the program binary may be identical, but the OS treats the running instances as separate processes with distinct PCBs, address spaces, and resource states.

The memory image of a process commonly includes the text segment, data segment, heap, and stack.2 The heap grows as a program allocates memory at runtime, while the stack supports procedure calls and local execution context. The program counter and CPU registers capture the exact point of execution, allowing the process to be paused and later resumed.2

The PCB exists because the OS must manage each process precisely.2 During a context switch, the kernel saves the outgoing process state into its PCB and restores the incoming process state from another PCB.2 Without this mechanism, preemptive scheduling, multitasking, and responsive interactive systems would not be possible.

A process may be independent or cooperating. An independent process neither affects nor is affected by other executing processes, whereas a cooperating process can share data, synchronize activities, or jointly accomplish a task. Cooperation is useful for information sharing, computation speedup, modularity, and convenience.

3

Footnotes

1. Lecture 4: Process State - Defines a process as a dynamic instance of a program and describes its memory components. ↩ ↩² ↩³ ↩⁴ ↩⁵

2. Chapter 3: Processes - Textbook-style material on process states, PCB, creation, termination, and IPC models. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

3. Lecture 4 (January 24, 2000) - Describes PCB contents, process state, and OS-maintained process context. ↩ ↩² ↩³ ↩⁴

4. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩² ↩³

5. Operating Systems: Processes - Explains the program-versus-process distinction and core process concepts. ↩

Process States, Scheduling, and Lifecycle

The standard five-state model captures the lifecycle of a process in many introductory and practical OS descriptions: new, ready, running, waiting, and terminated.2 A newly created process enters the system in the new state; once prepared for execution, it joins the ready queue.2 When selected by the CPU scheduler, it enters the running state. If it must wait for I/O completion, a timer, child completion, or a communication event, it transitions to the waiting state.2 Finally, after completion, it terminates and its control structures are reclaimed.2

In UNIX-like systems, process creation often follows the fork() and exec() model.2 The fork() system call creates a child process, often as a near duplicate of the parent, while exec() replaces the child’s memory image with a new program.2 The parent may continue concurrently or invoke wait() to synchronize with the child’s termination.2 This model clearly illustrates that process creation, scheduling, and IPC are tightly related concepts in operating systems.2

Footnotes

1. Chapter 3: Processes - Textbook-style material on process states, PCB, creation, termination, and IPC models. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

2. States of a Process in Operating Systems - Summarizes standard process states and context switching behavior. ↩ ↩² ↩³

3. Lecture 4 (January 24, 2000) - Describes PCB contents, process state, and OS-maintained process context. ↩

4. Operating Systems Lecture Notes On Process Creation - Covers fork(), exec(), wait(), and process termination behavior. ↩ ↩² ↩³ ↩⁴

5. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩

Why Interprocess Communication Is Needed

IPC is needed whenever cooperating processes must exchange data or coordinate behavior.2 A producer may generate data that a consumer must read; a parent may coordinate with a child; a client may send requests to a server; or multiple components of a larger application may divide work across processes.2 Since processes normally have isolated address spaces for protection, the operating system must provide explicit communication mechanisms.2

Textbook OS literature groups IPC into two fundamental models: shared memory and message passing.2 In shared memory, processes communicate by reading and writing a common region mapped into their address spaces.2 In message passing, processes exchange discrete messages through kernel-supported channels such as pipes, queues, sockets, or mailboxes.2

The design trade-off is important. Shared memory often yields higher performance because once the region is established, user processes can transfer data without repeated kernel mediation.2 However, this efficiency shifts responsibility for synchronization to the application, which must avoid races and inconsistent views of data.2 Message passing, by contrast, is usually simpler conceptually and safer across isolated or distributed environments, but it can involve more kernel overhead due to system calls, copying, and communication management.2

Footnotes

1. Inter-Process Communication - OMSCS Notes - Explains shared memory and message-based IPC, synchronization, and OS involvement. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

2. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

3. MESSAGE-PASSING SYSTEMS VERSUS SHARED MEMORY SYSTEMS - Compares synchronization, communication behavior, and suitability of shared memory and message passing. ↩ ↩² ↩³ ↩⁴

Contrasting the IPC Models: Shared Memory vs Message Passing

The most important contrast is how data moves.2 In shared memory, the OS first creates and maps a common memory region into participating processes; after that, each process reads and writes the same underlying memory.2 In message passing, data is packaged into messages and transferred using explicit send() and receive()-style operations through an OS-managed communication facility.2

The second major contrast is who controls communication after setup.2 In shared memory, communication is largely under user-process control after the memory mapping is established, which reduces kernel involvement and can improve throughput for large data transfers.2 In message passing, the kernel or runtime usually remains involved in communication operations, which improves abstraction and protection but may increase latency and overhead.2

A third contrast is synchronization style.2 Shared memory requires explicit coordination through mechanisms such as semaphores, mutexes, monitors, or condition variables to ensure that concurrent reads and writes are correct.2 Message passing often embeds synchronization in the communication act itself: a blocking receive, for example, can naturally wait until a message arrives.2

A fourth contrast is scope and suitability.2 Shared memory is especially efficient on the same machine where multiple processes can map the same physical pages.2 Message passing is more natural for distributed systems, microkernel designs, networked services, and loosely coupled components because it does not require a common address space.2

Footnotes

1. Inter-Process Communication - OMSCS Notes - Explains shared memory and message-based IPC, synchronization, and OS involvement. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰

2. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

3. MESSAGE-PASSING SYSTEMS VERSUS SHARED MEMORY SYSTEMS - Compares synchronization, communication behavior, and suitability of shared memory and message passing. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

Analytical Comparison Table

The following table provides a compact academic contrast of the two IPC models.3

A concise way to express the trade-off is this: if communication cost is dominated by repeated copying and kernel crossings, shared memory often reduces that cost; if communication design is dominated by modularity, isolation, and location transparency, message passing is often preferable.3

Footnotes

1. Inter-Process Communication - OMSCS Notes - Explains shared memory and message-based IPC, synchronization, and OS involvement. ↩ ↩²

2. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩²

3. MESSAGE-PASSING SYSTEMS VERSUS SHARED MEMORY SYSTEMS - Compares synchronization, communication behavior, and suitability of shared memory and message passing. ↩ ↩²

Conclusion

In operating systems, a process is the live, managed execution of a program, represented internally by state information such as the PCB, memory image, CPU context, and resource ownership.3 The concept matters because scheduling, protection, and concurrency all operate at the process level.2 When processes must cooperate, IPC becomes necessary.2

The two fundamental IPC models differ in philosophy. Shared memory offers efficient local communication by allowing multiple processes to access the same memory region, but it requires careful synchronization.2 Message passing offers explicit, structured communication through send and receive operations, often making it more suitable for protected, modular, and distributed systems, albeit with more overhead.2 A strong operating-systems answer should therefore define the process precisely, describe its lifecycle and PCB, and then compare IPC models using performance, synchronization, kernel involvement, and deployment scope as the primary dimensions.3

Footnotes

1. Lecture 4: Process State - Defines a process as a dynamic instance of a program and describes its memory components. ↩

2. Chapter 3: Processes - Textbook-style material on process states, PCB, creation, termination, and IPC models. ↩ ↩² ↩³

3. Lecture 4 (January 24, 2000) - Describes PCB contents, process state, and OS-maintained process context. ↩

4. States of a Process in Operating Systems - Summarizes standard process states and context switching behavior. ↩

5. Inter-Process Communication - OMSCS Notes - Explains shared memory and message-based IPC, synchronization, and OS involvement. ↩ ↩² ↩³ ↩⁴

6. Interprocess Communication, Operating System Concepts slides - Identifies the two IPC models and explains send/receive operations and cooperating processes. ↩ ↩² ↩³

7. MESSAGE-PASSING SYSTEMS VERSUS SHARED MEMORY SYSTEMS - Compares synchronization, communication behavior, and suitability of shared memory and message passing. ↩