Operating System Interprocess Communication

Chapter 3 - Processes

• Processes in an operating system are the fundamental entities that represent a program in execution.
• Processes can be cooperating or independent.
• Processes can share data and affect each other.
• Cooperating processes need interprocess communication (IPC)
• IPC uses shared memory or message passing.
• Shared memory allows processes to access shared data regions.
• Message passing involves processes exchanging messages.

Process Creation and Termination

• Processes are created and terminated using system calls.
• Programs use system calls to perform these operations.

Interprocess Communication (IPC)

• Processes communicate with each other through communication links.
• Communication links can be:
  • Shared memory
  • Message passing
• Shared memory allows direct access to shared data regions.
  • Processes synchronize their access using techniques described in Chapters 6 and 7.
• Message passing involves processes exchanging messages.
  • Sending and receiving messages can be blocking or non-blocking.
    • Rendezvous uses blocking mechanisms.

Producer-Consumer Problem

• A paradigm where one process (producer) produces data and another process (consumer) consumes it.
• Two variations exist:
  • Unbounded buffer: No practical limit on buffer size.
    • Producer never waits
    • Consumer waits if no data.
  • Bounded buffer: Fixed buffer size.
    • Producer waits if buffer full.
    • Consumer waits if no data.

Bounded Buffer – Shared Memory Solution

• The shared data structure includes a buffer, the index for the input slot (in), and the index for the output slot (out).
• A fixed size for the buffer is defined (BUFFER_SIZE).
• The solution ensures that only BUFFER_SIZE-1 slots in the buffer can be used, preventing an overflow condition.

Producer and Consumer Processes – Shared Memory

• Producer code continuously produces items and stores them while respecting buffer limits.
• Consumer code continuously consumes items from the buffer when available.

What About Filling all the Buffers?

• A counter can be added to track the number of filled buffers.
• The producer increments the counter when adding data and the consumer decrements it when consuming.

Race Condition

• A race condition in the producer/consumer occurs when multiple processes concurrently access and modify shared data without proper synchronization.
• The first solution (where most N buffers can be filled) avoids race conditions from issues in Chapter 6.

IPC - Message Passing

• Processes can communicate without shared variables by resorting to message passing.
  • There are two primary operations: send(message) and receive(message).
• Message sizes can be fixed or variable.

Message Passing (Cont.)

• Processes need to establish a communication link.
• Links can be associated with two or more processes.

Implementation of Communication Link

• Links can be implemented in several ways.
  • Physical:
    • Shared memory
    • Hardware bus
    • Networks
  • Logical:
    • Direct or indirect
    • Synchronous or asynchronous
    • Automatic or explicit buffering

Direct Communication

• Processes name each other explicitly when sending/receiving messages.
  • Example: send(P, message); receive(Q, message)
• Links are established automatically, and each pair of processes has exactly one link.

Indirect Communication

• Messages are directed through mailboxes/ports with unique IDs.
• Processes communicate by exchanging messages through a shared port.
• A mailbox can be shared by multiple processes.

Indirect Communication (Cont.)

• Operations for communicating: create, send, receive, delete.

Synchronization

• Message passing can be blocking (synchronous) or non-blocking (asynchronous).
• Blocking: sender/receiver waits for the message to be sent/received.
  • Rendezvous occurs when both are blocking.
• Non-blocking: sender/receiver doesn't wait. The sender sends the message and proceeds.

Producer-Consumer: Message Passing

• Producer sends messages for the consumer to receive.
• Consumer receives the messages sent by the producer.

Buffering

• Messages exist in a queue attached to the link.
  • Zero capacity: No queue, sender waits for receiver.
  • Bounded capacity: Limited queue size, sender waits if full.
  • Unbounded capacity: Unlimited size, sender never waits.