System V IPC Tutorial

A comprehensive web-based and interactive tutorial on System V Inter-Process Communication (IPC) in Linux. Covers semaphores, shared memory, message queues, and synchronization patterns, with a hands-on implementation of the producer-consumer problem. Features clear explanations, code examples, visual diagrams, a fully structured website, and practical exercises to help learners understand and implement System V IPC concepts from scratch.

🌐 Live Tutorial: https://michael-matta1.github.io/sysv-ipc-tutorial/

---

📚 About This Project

This repository contains a deep-dive tutorial on System V IPC, one of the most fundamental and widely-used mechanisms for inter-process communication in Unix-like systems. Unlike many brief or superficial guides, this tutorial provides:

• Conceptual foundations — Understand why IPC exists and how it solves real problems
• Complete API coverage — Detailed explanations of shmget, shmat, semget, semop, and more
• Real-world implementation — A working producer-consumer system with commodity price streaming
• Best practices — Error handling, signal management, deadlock prevention, and resource cleanup
• Visual explanations — Custom SVG diagrams illustrating memory layout, circular buffers, and semaphore operations

What You'll Build

A multi-process system where:

• Producers generate simulated commodity prices (GOLD, SILVER, CRUDEOIL) using normal distribution
• Consumer displays a real-time dashboard with prices, moving averages, and trend indicators
• Shared memory provides ultra-fast communication between processes
• Semaphores ensure safe synchronization without race conditions

---

🗂️ Repository Structure

sysv-ipc-tutorial/
├── docs/                 # Complete tutorial website (GitHub Pages root)
│   ├── index.html        # Landing page
│   ├── concepts.html     # Core IPC concepts
│   ├── shared_memory.html
│   ├── semaphores.html
│   ├── c_essentials.html
│   ├── implementation.html
│   ├── best_practices.html
│   ├── reference.html
│   ├── styles.css
│   ├── script.js
│   └── images/           # SVG diagrams and visualizations
│       ├── hero_ipc_flow.svg
│       ├── circular_buffer.svg
│       ├── shared_memory_layout.svg
│       └── ...
├── code/                 # Complete C++ source code
│   ├── producer.cpp      # Price generator
│   ├── consumer.cpp      # Dashboard display
│   └── Makefile
└── README.md             # This file

---

🚀 Quick Start

View the Tutorial

Visit the live website to read the complete tutorial with interactive navigation, syntax highlighting, and visual diagrams.

Run the Code

Prerequisites

• Linux or Unix-like OS (macOS, WSL on Windows)
• C++ compiler (g++ or clang++)
• GNU Make

Build and Run

# Clone the repository
git clone https://github.com/Michael-Matta1/sysv-ipc-tutorial.git
cd sysv-ipc-tutorial/code

# Compile both programs
make

# Terminal 1: Start the consumer (creates IPC resources)
./consumer 8

# Terminal 2: Start a producer
./producer GOLD 2000.0 5.0 500 8

# Terminal 3: Start another producer (optional)
./producer SILVER 25.0 0.5 300 8

# Watch the real-time dashboard!
# Press Ctrl+C in consumer terminal to clean up and exit

Command-Line Arguments

Consumer:

./consumer <buffer_size>

• buffer_size — Number of slots in the circular buffer (e.g., 8)

Producer:

./producer <commodity> <mean_price> <std_dev> <update_interval_ms> <buffer_size>

• commodity — Name (e.g., GOLD, SILVER, CRUDEOIL)
• mean_price — Average price around which values fluctuate
• std_dev — Standard deviation for price variation
• update_interval_ms — Delay between price updates in milliseconds
• buffer_size — Must match consumer's buffer size

Cleanup

If processes crash or are terminated abruptly, IPC resources may persist. Clean them up with:

# View active IPC resources
ipcs -m  # Shared memory
ipcs -s  # Semaphores

# Remove specific resources
ipcrm -m <shmid>  # Remove shared memory by ID
ipcrm -s <semid>  # Remove semaphore by ID

# Quick cleanup script (removes all IPC resources for current user)
ipcs -m | awk 'NR>3 {print $2}' | xargs -n1 ipcrm -m 2>/dev/null
ipcs -s | awk 'NR>3 {print $2}' | xargs -n1 ipcrm -s 2>/dev/null

---

📖 Tutorial Contents

The tutorial is organized into six comprehensive parts:

Part 1: Core Concepts

• What is Inter-Process Communication (IPC)?
• The Producer-Consumer Problem
• Three-Semaphore Solution
• Circular Buffers (Ring Buffers)
• Virtual Memory and Address Spaces

Part 2: Shared Memory

• shmget() — Create or access shared memory
• shmat() — Attach to process address space
• shmdt() — Detach from memory
• shmctl() — Control and remove segments
• Memory layout patterns with pointer arithmetic

Part 3: Semaphores

• P (wait) and V (signal) operations
• semget() — Create semaphore sets
• semop() — Perform atomic operations
• semctl() — Initialize and control semaphores
• Avoiding deadlocks

Part 4: C/C++ Essentials

• Pointers and memory management
• Structs and arrays
• String functions and argument parsing
• Time handling and random number generation
• ANSI escape codes for terminal output

Part 5: Implementation

• Complete data structures
• Consumer implementation walkthrough
• Producer implementation walkthrough
• Makefile explanation
• Running the system

Part 6: Best Practices

• Error checking patterns
• Signal handling for cleanup
• Resource management
• Common pitfalls to avoid
• Debugging techniques

---

🎯 Learning Objectives

After completing this tutorial, you will:

• ✅ Understand the fundamental concepts of inter-process communication
• ✅ Master the System V IPC API (shmget, shmat, semget, semop, etc.)
• ✅ Implement the producer-consumer pattern with semaphores
• ✅ Work with circular buffers and shared memory layouts
• ✅ Handle synchronization, race conditions, and deadlocks
• ✅ Write robust IPC code with proper error handling
• ✅ Debug and manage IPC resources on Unix systems

---

🛠️ Technical Details

Technologies Used

• C/C++ — Core implementation language
• System V IPC API — <sys/ipc.h>, <sys/shm.h>, <sys/sem.h>
• ANSI Escape Codes — Terminal-based UI rendering
• Normal Distribution — Realistic price simulation using <random>
• HTML/CSS/JavaScript — Tutorial website
• Highlight.js — Syntax highlighting
• SVG — Custom diagrams and visualizations

Browser Compatibility

The tutorial website supports all modern browsers:

• Chrome/Edge 90+
• Firefox 88+
• Safari 14+
• Mobile browsers (responsive design)

---

📊 Key Features

Tutorial Website

• 📱 Fully responsive — Optimized for desktop, tablet, and mobile
• 🎨 Dark theme — Easy on the eyes with syntax-highlighted code
• 🔍 Table of contents — Quick navigation on wide screens
• ♿ Accessible — Skip links, ARIA labels, keyboard navigation
• 📈 Visual diagrams — Custom SVG illustrations for every concept
• 💾 Copy buttons — One-click code copying

Code Implementation

• 🚀 Production-quality — Error handling, signal management, cleanup
• 📝 Well-commented — Every function and algorithm explained
• 🎯 Educational focus — Optimized for learning, not just performance
• 🔄 Real-time updates — Smooth dashboard rendering
• 🎲 Realistic simulation — Normal distribution for price generation

---

📜 License

This project is released under the MIT License — feel free to use it for learning, teaching, or as a reference for your own projects.

---

🔗 Links

• Live Tutorial: https://michael-matta1.github.io/sysv-ipc-tutorial/
• Source Code: https://github.com/Michael-Matta1/sysv-ipc-tutorial/tree/main/code
• GitHub Repository: https://github.com/Michael-Matta1/sysv-ipc-tutorial