Inter-process communication (pipes, shared memory) in Operating Systems - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Pipes in IPC

Which statement best describes the behavior of a pipe used for inter-process communication?

A A pipe provides a unidirectional communication channel where data written by one process can be read by another in a FIFO order.

B A pipe allows two unrelated processes to communicate by sharing a common memory space.

C A pipe enables multiple processes to access the same data simultaneously without synchronization.

D A pipe stores data permanently until explicitly deleted by the operating system.

💡 Hint

Think about how data flows between processes using pipes and the order in which data is received.

Pipes create a one-way communication channel where data flows in a first-in, first-out (FIFO) manner from the writing process to the reading process. They do not share memory space and do not store data permanently.

📋 Factual

intermediate

Shared Memory Characteristics

Which of the following is true about shared memory as a method of inter-process communication?

A Shared memory allows multiple processes to access the same memory region directly, requiring synchronization mechanisms to avoid conflicts.

B Shared memory requires data to be copied between processes to communicate.

C Shared memory communication is always slower than pipes due to overhead.

D Shared memory automatically manages access control without programmer intervention.

💡 Hint

Consider how processes access data in shared memory and what is needed to prevent errors.

Shared memory lets processes access the same memory area directly, which is fast but requires synchronization like locks or semaphores to prevent data corruption.

🔍 Analysis

advanced

Analyzing Pipe Communication Behavior

Consider two processes communicating via a pipe. Process A writes 100 bytes, then Process B reads 50 bytes, then Process A writes another 30 bytes. What is the total number of bytes available for Process B to read after these operations?

A 30 bytes

B 130 bytes

C 50 bytes

D 80 bytes

💡 Hint

Remember that reading from a pipe removes data from the buffer.

Process A writes 100 bytes, Process B reads 50 bytes (removing them), so 50 bytes remain. Then Process A writes 30 more bytes, totaling 80 bytes available for reading.

❓ Comparison

advanced

Comparing Pipes and Shared Memory

Which of the following correctly compares pipes and shared memory for inter-process communication?

A Both pipes and shared memory require the processes to be related (parent-child) to communicate.

B Shared memory is unidirectional, while pipes allow bidirectional communication.

C Shared memory requires explicit synchronization, while pipes handle synchronization internally by design.

D Pipes are faster than shared memory because they avoid synchronization overhead.

💡 Hint

Think about how synchronization is managed in each IPC method.

Shared memory allows direct access to memory and needs explicit synchronization by the programmer. Pipes internally manage synchronization by blocking reads and writes as needed.

❓ Reasoning

expert

Diagnosing IPC Deadlock Scenario

Two processes use a pipe for communication. Process A writes data and waits for a response from Process B. Process B waits to read data before sending a response. Both processes are now stuck waiting indefinitely. What is the most likely cause of this deadlock?

A Process A is writing more data than the pipe buffer can hold, causing it to block indefinitely.

B Both processes are waiting for each other to perform an action first, causing a circular wait deadlock.

C The pipe was not created correctly, so no data can be transferred.

D Process B is reading from the pipe before Process A writes any data, causing a race condition.

💡 Hint

Consider what happens when two processes wait on each other to proceed.

Both processes are waiting for the other to act first, creating a circular wait where neither can proceed, causing a deadlock.

Practice

1. Which of the following best describes a pipe in inter-process communication?

easy

A. A way to create new processes in the operating system

B. A memory area shared by multiple processes simultaneously

C. A method to encrypt data between processes

D. A channel that sends data in a stream from one process to another

Solution

1. Step 1: Understand what a pipe does

   A pipe is used to send data in a continuous stream from one process to another, allowing communication.

2. Step 2: Compare with other options

   Shared memory allows direct access to the same data, encryption is unrelated, and process creation is a different concept.

3. Final Answer:

   A channel that sends data in a stream from one process to another -> Option D

4. Quick Check:

   Pipe = Stream data channel [OK]

Hint: Pipes stream data between processes, shared memory shares data directly [OK]

Common Mistakes:

• Confusing pipes with shared memory
• Thinking pipes create processes
• Assuming pipes encrypt data

2. Which of the following is the correct syntax to create a pipe in a Unix-like operating system using C?

easy

A. pipe(int *fd);

B. pipe(fd);

C. pipe(int fd[2]);

D. pipe(fd[2]);

Solution

1. Step 1: Recall the pipe function signature

   The pipe function requires an integer array of size 2 passed by reference to store file descriptors.

2. Step 2: Match the correct syntax

   The correct syntax is pipe(fd); where fd is an integer array of size 2 declared before the call.

3. Final Answer:

   pipe(fd); -> Option B

4. Quick Check:

   pipe needs int array of size 2 [OK]

Hint: pipe() needs int array of size 2 as argument [OK]

Common Mistakes:

• Omitting the type in the argument
• Passing pointer instead of array
• Passing array without size

3. Consider the following pseudo-code using shared memory:

1. Create shared memory segment
2. Process A writes value 10 to shared memory
3. Process B reads value from shared memory
4. Process B writes value 20 to shared memory
5. Process A reads value from shared memory

What value will Process A read in step 5?

medium

A. 20

B. 10

C. 0

D. Undefined or error

Solution

1. Step 1: Track writes and reads in shared memory

   Process A writes 10, then Process B reads 10, then Process B writes 20.

2. Step 2: Determine what Process A reads after Process B's write

   Since shared memory is common, Process A will read the updated value 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   Shared memory shows last written value [OK]

Hint: Shared memory shows latest written value to all processes [OK]

Common Mistakes:

• Assuming Process A reads its own old value
• Thinking reads cause errors
• Confusing shared memory with pipes

4. A programmer tries to use a pipe for communication but notices the reading process blocks indefinitely. What is the most likely cause?

medium

A. Shared memory was used instead of a pipe

B. The pipe was created with incorrect syntax

C. The writing process has not sent any data yet

D. The pipe buffer size is too large

Solution

1. Step 1: Understand pipe blocking behavior

   A reading process blocks if no data is available to read from the pipe.

2. Step 2: Identify the cause of blocking

   If the writing process has not sent data, the reader waits indefinitely for input.

3. Final Answer:

   The writing process has not sent any data yet -> Option C

4. Quick Check:

   Reader blocks if no data sent [OK]

Hint: Reader waits until writer sends data through pipe [OK]

Common Mistakes:

• Blaming syntax errors for blocking
• Confusing pipe with shared memory
• Assuming buffer size causes blocking

5. You want two processes to share a large data structure efficiently and allow both to read and write it. Which IPC method is best and why?

hard

A. Use shared memory because it allows direct access to the same data

B. Use sockets because they work over networks

C. Use message queues because they guarantee message order

D. Use pipes because they provide fast streaming of data

Solution

1. Step 1: Analyze requirements for sharing large data structure

   Efficient sharing with read/write access means processes need direct access to the same memory.

2. Step 2: Compare IPC methods

   Pipes stream data but are unidirectional and less efficient for large shared data. Message queues and sockets add overhead and are for message passing, not direct shared access.

3. Final Answer:

   Use shared memory because it allows direct access to the same data -> Option A

4. Quick Check:

   Shared memory = direct, efficient data sharing [OK]

Hint: Shared memory is best for large, read/write shared data [OK]

Common Mistakes:

• Choosing pipes for large data sharing
• Confusing message queues with shared memory
• Thinking sockets are best for local IPC