Producer-Consumer Problem Quiz

Chapter 3 - Processes

• This chapter covers processes in operating systems.
• Topics include process concepts, scheduling, operations on processes, interprocess communication (IPC), IPC in shared-memory systems, IPC in message-passing systems, examples of IPC systems, and communication in client-server systems.
• Processes are either independent or cooperating.
• Cooperating processes can affect, or be affected by, other processes. This includes sharing data.
• Reasons for cooperating processes include information sharing, computation speedup, modularity, and convenience.
• Cooperating processes require interprocess communication (IPC). Two models of IPC are shared memory and message passing.
• The objectives of this chapter include identifying process components and how they are represented and scheduled in an operating system.
• Describing how processes are created and terminated, including system calls, in an operating system.
• Describing and comparing interprocess communication (IPC) using shared memory and message passing.
• Designing programs that use pipes and POSIX shared memory to perform IPC.
• Describing client-server communication using sockets and remote procedure calls (RPCs).

Interprocess Communication

• Processes in a system may be independent or cooperating.
• Cooperating processes can affect or be affected by other processes because they share data.
• Cooperating processes need IPC. IPC uses two main models: shared memory and message passing.
• Reasons for cooperation:
  • Information sharing
  • Computation speedup
  • Modularity
  • Convenience

Communication Models

• Shared memory: Processes share portions of memory, allowing for direct data access.
• Message passing: Processes communicate by exchanging messages through kernel support.

Producer-Consumer Problem

• A paradigm for cooperating processes where a producer creates data and a consumer uses it.
• Two variations, unbounded buffer (no limit on buffer size, no waiting) and bounded buffer (limited buffer size, producer/consumer may wait).

IPC - Shared Memory

• Shared memory is an area of memory shared among communicating processes.
• Communication is under the control of the user processes, not the operating system.
• Major issue: synchronizing access to shared memory (discussed in detail in Chapters 6 & 7).
• A solution is to use shared data structures using code examples for producer and consumer process

Bounded Buffer – Shared Memory Solution

• Illustrates a shared memory solution for the producer-consumer problem.
• Includes data structures (e.g., BUFFER_SIZE, an array of item structures, in, and out pointers).
• Demonstrates a correct solution (with code examples) but with a limited capability (one element less than BUFFER_SIZE).

Producer Process – Shared Memory

• Uses a while loop to wait if the buffer is already full. This uses the defined data structures to produce data for use in the consumer process

Consumer Process – Shared Memory

• Uses a while loop to wait if the buffer is empty. Utilizes the defined data structures to consume data that has been produced.

What about filling all buffers?

• The solution uses an integer counter to keep track of full buffers.
• Producer increments and consumer decrements this counter.

Producer

• Includes a while loop condition checking the counter against the maximum buffer size.
• Producer code is for producing data in the buffer

Consumer

• Includes a while loop condition checking the counter to see if the counter is 0.
• Consumer code is for consuming data in the buffer

Race Condition

• counter++ and counter-- are not atomic operations in Java and can lead to race conditions if not handled properly.
• Illustrates the race condition problem using an example interleaving scenario.

Race Condition (Cont.)

• Explains why the first solution didn't have race conditions.
• More details are available in Chapter 6.

IPC - Message Passing

• Processes communicate without shared variables.
• IPC facilities typically provide send() and receive() operations.
• Message size can be fixed or variable.

Message Passing (Cont.)

• Processes need to establish a communication link to exchange messages.
• How process links are established is a concern. One link is usually established between processing pairs.
• Questions concerning multiple links between a pair of processes, link capacity, fixed/variable messages sizes, and unidirectional/bidirectional links are considered.

Implementation of Communication Link

• Physical links include shared memory, hardware buses, and networks.
• Logical links involve direct (symmetric communication) or indirect communication (communication via mailboxes), synchronous (sender waits) or asynchronous (sender continues) communication.

Direct Communication

• Processes must name each other explicitly to communicate.
• Communication links are automatically established.
• A link is associated with exactly one pair of processes. The link is usually bi-directional, but can be unidirectional.

Indirect Communication

• Messages are sent and received through mailboxes (ports).
• Mailboxes have unique IDs.
• Processes can communicate only if they share a mailbox.
• A mailbox can be shared by several processes.
• Link may be unidirectional or bidirectional.
• Demonstrates operations like create, send, and receive mailboxes.

Indirect Communication (Cont.)

• Mailbox sharing—multiple processes can access the same mailbox.
• Concerns about who gets a message. Different solutions to address the problem of message destination during sharing.

Synchronization

• Message passing can be blocking or non-blocking.
• Blocking means a process halts sending/receiving until the message is complete. Also called synchronous.
• Non-blocking means a process sends/receives and continues without waiting; also called asynchronous

Producer-Consumer: Message Passing

• Producer and consumer processes use message passing to communicate, producing and consuming data in the same way as before.

Buffering

• Implemented as a message queue
• Three types of buffering discussed:
  • Zero capacity: no queuing, sender blocks until receiver is ready (rendezvous).
  • Bounded capacity: a queue of finite size; sender blocks until space is available.
  • Unbounded capacity: unlimited queue size; sender never blocks.

Examples of IPC Systems – Windows

• Message passing is centered around an advanced local procedure call (LPC) mechanism.
• Uses ports to establish and maintain communication channels, including a connection port object.
• Illustrates client-server communication where the client sends a connection request, the server creates ports, sends handles that the client can use to send messages.

Local Procedure Calls in Windows

• Diagrams showing the interaction between client and server processes using the LPC facility.

Pipes

• Pipes act as channels for communication between processes. Can they be unidirectional or bidirectional, half duplex, or full duplex?
• Ordinary Pipes: cannot be accessed from outside the creating process
• Named Pipes: processes use a shared name to communicate. No parent-child relationship required.

Ordinary Pipes

• Communication is unidirectional.
• Producer writes to one end (write end); consumer reads from another (read end).
• Requires a parent-child relationship. Windows calls these anonymous pipes.

Named Pipes

• Communication is bidirectional.
• No parent-child relationship required.

Sockets

• Endpoints for communication defined via IP address and port number.
• The socket 161.25.19.8:1625 specifies the network services.
• All ports below 1024 are well-known, standard ports.
• The special IP address 127.0.0.1 (loopback) is used for communications on the same system

Socket Communication

• Diagram demonstrating communication using sockets.

Sockets in Java

• Shows different types; Connection-oriented (TCP) and Connectionless (UDP) sockets
• Includes code snippets for a Java date server and client, illustrating socket communication.

Remote Procedure Calls

• Remote procedure calls (RPCs) abstract procedure calls across networks.
• RPCs use ports for differentiating services.
• RPC uses stubs: client-side proxies for actual procedures on the server.
• The client-side stub locates the server, and then marshals the parameters, which the server then unpacks to execute operations.

Remote Procedure Calls (Cont.)

• Data representation is managed using External Data Representation (XDL). This accounts for different architectures. (big-endian or little-endian).
• Remote communication has challenges, including potential message failures, and message delivery issues (exactly once, or at most once).

Execution of RPC

• Diagram showing the execution steps of a remote procedure call, including how the client finds the server, marshalling parameters, and the steps involved in sending messages to the server and receiving back the results.

End of Chapter 3