API Side-by-Side Comparison

Performance: Why POSIX Wins on Uncontended Cases

On Linux, POSIX semaphores (and pthreads mutexes) are implemented using futexes (fast userspace mutexes). A futex only makes a kernel system call when there is actual contention. When the semaphore is free (value > 0 for wait, or no waiters for post), the operation is handled entirely in userspace using atomic CPU instructions — no kernel involvement at all.

System V semaphores always go through a kernel system call (semop()), even when uncontended. This makes them significantly slower in tight loops.

Benchmark Example: Measuring the Difference

This program (inspired by TLPI Exercise 53-4) measures POSIX semaphore increment+decrement throughput. Run a similar program with semop() to compare.

#include <stdio.h>
#include <time.h>
#include <semaphore.h>

#define ITERATIONS 1000000

int main(void)
{
    sem_t sem;
    struct timespec start, end;
    long elapsed_ns;

    sem_init(&sem, 0, 1);

    clock_gettime(CLOCK_MONOTONIC, &start);

    for (int i = 0; i < ITERATIONS; i++) {
        sem_wait(&sem);
        sem_post(&sem);
    }

    clock_gettime(CLOCK_MONOTONIC, &end);

    elapsed_ns = (end.tv_sec - start.tv_sec) * 1000000000L
               + (end.tv_nsec - start.tv_nsec);

    printf("POSIX semaphore: %d iterations in %ld ms\n",
           ITERATIONS, elapsed_ns / 1000000);
    printf("Average: %.1f ns per wait+post pair\n",
           (double)elapsed_ns / ITERATIONS);

    sem_destroy(&sem);
    return 0;
}
/* Typical output on Linux:
   POSIX semaphore: 1000000 iterations in 12 ms
   Average: 12.3 ns per wait+post pair */

System V Only: SEM_UNDO — Automatic Rollback on Process Exit

One feature unique to System V semaphores is the SEM_UNDO flag for semop(). When used, the kernel records each operation and automatically undoes it when the process exits — even if the process crashes. This prevents semaphores from being left in a locked state.

POSIX semaphores have no equivalent. If a process dies holding a POSIX semaphore, the semaphore stays in its current state. Other processes waiting on it will block forever. This must be handled at the application level (e.g., using sem_timedwait with a timeout, or a watchdog process).

/* System V SEM_UNDO example */
#include <sys/sem.h>

struct sembuf op;
op.sem_num = 0;
op.sem_op  = -1;          /* decrement (lock) */
op.sem_flg = SEM_UNDO;    /* undo on exit: kernel restores value if we crash */
semop(semid, &op, 1);

/* ... critical section ... */

op.sem_op  = 1;           /* increment (unlock) */
op.sem_flg = SEM_UNDO;
semop(semid, &op, 1);

When to Use Which

POSIX Semaphore vs POSIX Mutex (pthread_mutex)

For thread synchronization within a single process, pthread mutexes are generally preferred over semaphores. Here is why:

Complete Example: System V vs POSIX for the Same Problem

Both programs solve the same problem: a simple binary lock around a counter. Compare the API complexity.

System V version

#include <stdio.h>
#include <sys/sem.h>
#include <sys/ipc.h>

/* Required union for semctl */
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main(void)
{
    int semid;
    struct sembuf lock_op   = { 0, -1, 0 };
    struct sembuf unlock_op = { 0,  1, 0 };
    union semun arg;

    /* Create a set of 1 semaphore */
    semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
    if (semid == -1) { perror("semget"); return 1; }

    /* Set initial value to 1 */
    arg.val = 1;
    semctl(semid, 0, SETVAL, arg);

    /* Lock */
    semop(semid, &lock_op, 1);
    printf("Inside critical section.\n");
    /* Unlock */
    semop(semid, &unlock_op, 1);

    /* Remove semaphore */
    semctl(semid, 0, IPC_RMID);
    return 0;
}

POSIX version — same logic, far simpler

#include <stdio.h>
#include <semaphore.h>

int main(void)
{
    sem_t sem;

    sem_init(&sem, 0, 1);   /* initial value = 1 */

    sem_wait(&sem);          /* lock */
    printf("Inside critical section.\n");
    sem_post(&sem);          /* unlock */

    sem_destroy(&sem);
    return 0;
}

Chapter 53 Summary