[Day 3] 3. Pipes

Pipes in Linux

Pipes are used for Inter-Process Communication (IPC), allowing data to flow between processes. They have two ends: one for reading and one for writing.

Types of Pipes:

Unnamed Pipes:
- Used for communication between related processes (like a parent and child process).
- Automatically created by the operating system.
Named Pipes (FIFOs):
- Created using the
```
mkfifo
```
  command.
- Can be used for communication between unrelated processes.

Creating a Named Pipe:

Command:
```
mkfifo fifo
```
- This command creates a named pipe called
```
fifo
```
  . It follows the First In, First Out (FIFO) principle, meaning data written first will be read first.

How Pipes Work Internally:

Buffer:
- A circular buffer is created in memory, functioning like an array.
- For example:
  
  !3. Pipes 2.png
- The buffer is assigned file descriptors:
  - ```
  arr[0]
```
  : Read end of the pipe
- ```
arr[1]
```
    : Write end of the pipe
File Descriptors:
- When a pipe is created using the
```
pipe()
```
  system call, two file descriptors are generated:
  - arr[0]
    : Represents the read end of the pipe (associated with
```
stdin
```
    ).
  - arr[1]
    : Represents the write end of the pipe (associated with
```
stdout
```
    ).
- The default standard input (
```
stdin
```
  ) and standard output (
```
stdout
```
  ) are replaced with the pipe's read and write ends.

Synchronisation and Blocking Behaviour:

Blocking Behaviour:
- If a read operation is attempted on an empty pipe, the reading process is blocked and goes into a waiting state until data is written.
- If the buffer is full, the writing process is automatically blocked until space is available in the buffer.
Unidirectional Communication:
- Pipes allow for unidirectional data flow (data can only flow in one direction—from the writer to the reader).
- Because two processes are typically related, unnamed pipes are often used for simpler IPC tasks.

Example Workflow:

Writing to the Pipe:
- A process writes data to the pipe using the write descriptor (
```
arr[1]
```
  ).
Reading from the Pipe:
- Another process reads the data from the pipe using the read descriptor (
```
arr[0]
```
  ).

Diagram of Pipe Communication:

!7. Pipe.png

Conclusion:

Pipes are a fundamental IPC mechanism in Linux that facilitate communication between processes. By understanding the behaviour of pipes, including their blocking nature and unidirectional data flow, you can effectively manage data transfer in multi-process applications.