IPC MECHANISM CHARACTERISTICS AT A GLANCE
═══════════════════════════════════════════════════════════════════════
 
                        Anon   Named  POSIX   Unix    Unix    Shared   Signal
                        Pipe   Pipe   MsgQ    Stream  Dgram   Memory
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Unrelated processes      ✗      ✓      ✓       ✓       ✓        ✓       ✓
Message boundaries       ✗      ✗      ✓       ✗       ✓        N/A     N/A
Bidirectional           ✗      ✗*     ✓       ✓       ✓        N/A     ✗
Multiple readers        ✗      ✗      ✓       ✓       ✓        ✓       ✗
Multiple writers        ✓      ✓      ✓       ✓       ✓        ✓       ✓
Pass file descriptors   ✗      ✗      ✗       ✓       ✓        ✗       ✗
Priority support        ✗      ✗      ✓       ✗       ✗        N/A     ✓**
select/poll/epoll       ✓      ✓      ✓       ✓       ✓        ✗       ✗***
Zero-copy potential     ✗      ✗      ✗       ✗       ✗        ✓       N/A
Cross-machine capable   ✗      ✗      ✗       ✗       ✗        ✗       ✗
 
* Named pipes can be opened at both ends for read/write, but it's complex
** Signals have implicit priority (real-time signals can queue)
*** Signals can be waited for with signalfd which IS poll-able
 
Network IPC (for comparison):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TCP Socket              ✓      ✓      ✗       ✓       N/A      ✗       ✗
UDP Socket              ✓      ✓      ✓       N/A     ✓        ✗       ✗

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// ❌ MISTAKE: Polling shared memory for changes
while (1) {
    if (shared->flag == READY) {  // Spinning! Wasting CPU!
        process(shared->data);
        shared->flag = PROCESSED;
    }
    // Even with usleep(), this is inefficient and has latency issues
}
 
// ✓ CORRECT: Use condition variable or eventfd
pthread_mutex_lock(&shared->mutex);
while (shared->flag != READY) {
    pthread_cond_wait(&shared->cond, &shared->mutex);  // Sleeps efficiently
}
process(shared->data);
shared->flag = PROCESSED;
pthread_cond_signal(&shared->cond);
pthread_mutex_unlock(&shared->mutex);
 
// ❌ MISTAKE: Named pipe for bidirectional
int fd = open("/tmp/myfifo", O_RDWR);  // Seems to work...
write(fd, request, len);
read(fd, response, len);  // Might read your own request back!
 
// ✓ CORRECT: Use Unix domain socket for bidirectional
int sock = socket(AF_UNIX, SOCK_STREAM, 0);
connect(sock, ...);
write(sock, request, len);
read(sock, response, len);  // Receives peer's response, not your request
 
// ❌ MISTAKE: TCP for local IPC
// Creates unnecessary 3-way handshake, Nagle delay, etc.
int sock = socket(AF_INET, SOCK_STREAM, 0);
connect(sock, &(struct sockaddr_in){
    .sin_family = AF_INET,
    .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
    .sin_port = htons(8080)
}, ...);
 
// ✓ CORRECT: Unix domain socket for local IPC
int sock = socket(AF_UNIX, SOCK_STREAM, 0);
connect(sock, &(struct sockaddr_un){
    .sun_family = AF_UNIX,
    .sun_path = "/var/run/myservice.sock"
}, ...);
// Faster, no TCP overhead, credential passing available

IPC MECHANISM SELECTION CHECKLIST
═══════════════════════════════════════════════════════════════════════
 
□ PROCESS RELATIONSHIP
  [ ] Related (parent-child/siblings)? → Anonymous pipe, inherited sockets OK
  [ ] Unrelated processes? → Need named mechanism (paths, network)
 
□ DATA CHARACTERISTICS  
  [ ] Message-oriented or byte stream?
  [ ] What's the typical message size?  <1KB / 1KB-1MB / >1MB
  [ ] What's the transfer frequency?  <100/s / 100-10K/s / >10K/s
  [ ] Message boundaries important? → Avoid pipes, use MQ or SEQPACKET
 
□ COMMUNICATION PATTERN
  [ ] Unidirectional? → Pipe or MQ
  [ ] Bidirectional? → Socket or shared memory
  [ ] Request-response? → Socket (natural for this)
  [ ] Publish-subscribe? → Socket + app routing, or MQ per subscriber
  [ ] Producer-consumer? → MQ or shared memory ring buffer
 
□ PERFORMANCE REQUIREMENTS
  [ ] Latency critical (<1μs)? → Shared memory with careful sync
  [ ] Throughput critical (>1GB/s)? → Shared memory for data, socket for control
  [ ] CPU usage matters? → Shared memory avoids copy overhead
  [ ] 'Normal' performance fine? → Message passing is usually sufficient
 
□ SECURITY REQUIREMENTS
  [ ] Need peer authentication? → Unix socket (SO_PEERCRED) or TLS
  [ ] Audit trail required? → Message passing (observable)
  [ ] Processes don't fully trust each other? → Avoid shared memory
  [ ] Cross-user or cross-privilege? → Socket with credential check
 
□ OPERATIONAL REQUIREMENTS
  [ ] Need to monitor IPC health? → Socket (connection state), MQ (queue depth)
  [ ] Debugging priority? → Message passing (log messages)
  [ ] Crash recovery needs? → Persistent MQ, or socket reconnection
  [ ] Hot restart/upgrade? → Socket (new process takes over)
 
□ PORTABILITY
  [ ] Linux-only? → Everything available
  [ ] Need macOS? → Avoid POSIX MQ
  [ ] Need Windows? → Use sockets or abstraction library
  [ ] Need embedded? → Check RTOS support
 
AFTER CHECKLIST - RECOMMENDATION:
─────────────────────────────────
Most answers favor simplicity → Unix Domain Socket
Need message priority/queueing → POSIX Message Queue  
Need maximum performance + expertise → Shared Memory + Semaphore
Parent-child simple flow → Anonymous Pipe
Notification only → Signal or eventfd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// Abstract IPC interface - swap implementation without changing callers
 
typedef struct ipc_channel ipc_channel_t;
 
// Generic interface
ipc_channel_t* ipc_create(const char *config);
void ipc_destroy(ipc_channel_t *ch);
int ipc_send(ipc_channel_t *ch, const void *msg, size_t len);
int ipc_recv(ipc_channel_t *ch, void *buf, size_t len);
 
// Implementations (compile different ones as needed)
 
// --- Unix Socket Implementation ---
struct ipc_channel {
    int sock_fd;
};
 
ipc_channel_t* ipc_create_socket(const char *path) {
    ipc_channel_t *ch = malloc(sizeof(*ch));
    ch->sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    // connect or bind...
    return ch;
}
 
int ipc_send_socket(ipc_channel_t *ch, const void *msg, size_t len) {
    return send(ch->sock_fd, msg, len, 0);
}
 
// --- Shared Memory Implementation ---
struct ipc_channel {
    void *shm_addr;
    sem_t *sem;
};
 
int ipc_send_shm(ipc_channel_t *ch, const void *msg, size_t len) {
    sem_wait(ch->sem);
    memcpy(ch->shm_addr, msg, len);
    sem_post(ch->sem);
    // Notify receiver somehow...
    return len;
}
 
// Caller code unchanged when switching implementations:
ipc_channel_t *ch = ipc_create("/var/run/myapp");
ipc_send(ch, &message, sizeof(message));