Interprocess Communication (IPC)

Interprocess Communication (IPC)

• Processes often require communication with each other, as seen in a shell pipeline where output from one process is passed to the next.
• Communication between processes managed by the OS is termed Interprocess Communication (IPC).
• IPC should be well-structured, and avoid interrupts to maintain system performance.

IPC Example: Printing System

• A process submits a file for printing by placing its name in a designated spooler directory.
• A print daemon periodically scans this directory, and sends any listed files to the printer, and then removes names from directory.

Spooler Directory Setup

• A spooler directory may have numbered slots (0, 1, 2, etc.) for storing file names.
• Variables 'out' and 'in' can denote the next file to print and the next available directory slot, respectively.
• These variables can be stored in a shared, two-word file accessible to all processes.

Race Conditions

• Race conditions occur when multiple processes read or write shared data, and the outcome depends on the timing of their execution.
• Mutual exclusion is needed, ensuring that only one process can access a shared variable/file at a time.

Critical Section

• A critical section is a part of a program where shared memory is accessed.
• Avoiding simultaneous execution of critical sections by multiple processes is essential to prevent race conditions.

Requirements for Critical Section Solutions (Dijkstra Conditions)

• No two processes inside critical sections at same time; mutual exclusion is needed
• There should be no assumptions about processor speeds or number of processors.
• Processes outside critical sections should not block other processes.
• No process should wait indefinitely to enter its critical section.

Simple Critical Section Structure

• Processes Pi (i=0 and i=1) structure includes entry, critical section, exit code, and non-critical section components.

Methods for Preventing Critical Section

Disabling Interrupts

• Simplest solution is to disable interrupts upon entering a critical section, and re-enable upon exiting.
• Prevents processor switches, but also halts other processes from intervening shared memory.
• This is generally not recommended to give user processes control of interrupts. A user could potentially halt the running of entire OS.

Lock Variables

• Using a shared "lock" variable initialized to 0, processes check the lock before entering a critical section.
• Setting it to 1 when entering and resetting to 0 when exiting.
• Problems can still occur through the testing that creates fatal flaws.

Strict Alteration

• In strict alternation, processes take turns entering critical sections based on a "turn" variable.
• This is problematic because if a process is blocked by others outside of the Critical Section, condition 3 is voilated

Peterson's Solution

• Peterson created a mutual exclusion lock algorithm to prevent 2 threads from concurrently accessing shared memory, and avoid race conditions
• This well working process is problematic because it wastes CPU time while processes are actively waiting.

Test-and-Set Instruction

• Test-and-set instruction returns true if lock is true, otherwise it first sets the value of lock to true and returns false.
• Test-and-Set() can be used for the solution of the CS problem – still with active waiting.

Swap Instruction

• The “swap” instruction interchanges the content of its parameters between int lock and int key.
• This process still causes active waiting.

Semaphores

• E.W. Dijkstra introduced semaphores, a new variable type with atomic DOWN and UP operations, for IPC solutions.
• The DOWN system call checks if, and decrements a semaphore's value if it is above 0. Blocks the calling process puts it to sleep, otherwise.
• The UP system call increases the semaphore's value, and wakes up all blocked processes.
• Atomic nature of these operations which guarantees process isolation during semaphore modifications.
• Semaphores can be used for CS problem as follows . semaphore mutex = 1;

Classical IPC Problems with Semaphores

• Semaphores can be used to synchronize processes. For example, to ensure statement st2 of process p2 executes after st1 of p1.

Bounded Buffer (Producer-Consumer)

• This problem involves producer and consumer processes who share a common buffer of n slots.
• Producers fill the buffer, and consumers empty these slots.
• Important to make sure consumers don't try to consume an empty slot, and producers don't try to write on full slots
• This can be fixed with a mutex variable set to 1

Readers and Writers Problem

• In a database system with multiple processes, multiple readers can access the database at the same time, although no one can when a writer is writing.
• To fix this, the correct code should implement a read count and reading and updating code

Dining Philosophers Problem

• N philosophers spend their lives thinking and eating in a room.
• In their round table there is a plate of infinite rice and N chopsticks. Philosophers have one chopstick to the left, or right of them. They need 2 to eat.
• The main point is to not cause deadlocks of philosophers

Sleeping Barber

• A barber shop has one barber, one barber chair, and N chairs for waiting customers. If there is no customer at present, the barber sits down in the barber chair and falls asleep. When a customer arrives, he has to wake up the sleeping barber.
• If additional customers arrive while the barber is cutting a customer's hair, they either sit down (if there is an empty chair) or leave the shop (if all chairs are full).
• The problem is to program the barber and the customers without getting into race conditions or deadlocks.