Inter-process communication (pipes, shared memory) in Operating Systems - Mini Project: Build & Apply

Inter-process Communication with Pipes and Shared Memory

📖 Scenario: You are working on a simple operating system simulation where two processes need to share information. One process will send a message, and the other will receive it. You will create data structures and configurations to simulate communication using pipes and shared memory.

🎯 Goal: Build a basic setup that represents inter-process communication using pipes and shared memory. You will create the initial data structures, configure communication parameters, implement the core logic for sending and receiving messages, and finalize the setup to simulate the communication.

📋 What You'll Learn

Create a dictionary to represent pipes with exact pipe names and empty message lists

Create a dictionary to represent shared memory segments with exact segment names and initial empty strings

Add a configuration variable for maximum message size

Implement a function to send a message through a pipe if it does not exceed the maximum size

Implement a function to write a message to shared memory

Add a final step to simulate receiving a message from a pipe and reading from shared memory

💡 Why This Matters

🌍 Real World

Inter-process communication is essential in operating systems to allow processes to exchange data safely and efficiently.

💼 Career

Understanding pipes and shared memory helps in roles like system programming, OS development, and software engineering where process communication is critical.

1

Create initial data structures for pipes and shared memory

Create a dictionary called pipes with keys 'pipe1' and 'pipe2', each having an empty list as value. Also create a dictionary called shared_memory with keys 'segment1' and 'segment2', each having an empty string as value.

Operating Systems

# Create pipes and shared_memory dictionaries with specified keys and empty values
# Your code here

Need a hint?

Use dictionary syntax with exact keys and empty list or string values.

2

Add configuration for maximum message size

Create a variable called max_message_size and set it to 100 to limit the size of messages sent through pipes.

Operating Systems

pipes = {'pipe1': [], 'pipe2': []}
shared_memory = {'segment1': '', 'segment2': ''}
# Set max_message_size to 100
# Your code here

Need a hint?

Just assign the number 100 to the variable max_message_size.

3

Implement functions to send messages through pipes and write to shared memory

Define a function called send_pipe_message(pipe_name, message) that adds message to pipes[pipe_name] only if the length of message is less than or equal to max_message_size. Also define a function called write_shared_memory(segment_name, message) that sets shared_memory[segment_name] to message.

Operating Systems

pipes = {'pipe1': [], 'pipe2': []}
shared_memory = {'segment1': '', 'segment2': ''}
max_message_size = 100
# Define send_pipe_message and write_shared_memory functions
# Your code here

Need a hint?

Use len(message) to check size and append to the list for pipes. For shared memory, assign the message string directly.

4

Simulate receiving a message from a pipe and reading from shared memory

Create a variable called received_message that removes and stores the first message from pipes['pipe1'] if it is not empty. Also create a variable called shared_mem_content that stores the content of shared_memory['segment1'].

Operating Systems

pipes = {'pipe1': [], 'pipe2': []}
shared_memory = {'segment1': '', 'segment2': ''}
max_message_size = 100

def send_pipe_message(pipe_name, message):
    if len(message) <= max_message_size:
        pipes[pipe_name].append(message)

def write_shared_memory(segment_name, message):
    shared_memory[segment_name] = message

# Remove first message from pipes['pipe1'] if available and store in received_message
# Store shared_memory['segment1'] content in shared_mem_content
# Your code here

Need a hint?

Use pop(0) to remove the first message from the pipe list safely.