Benchmark Results (kernel 2.6.27, x86-32, 100,000 operations)

Visual: Relative Speed (100% = fastest = clone())

Why is fork() Slower Than vfork() and clone()?

Copy-on-Write (CoW) — fork() Is Lazy, Not Zero-Cost

fork() does not copy actual memory pages immediately — it uses Copy-on-Write. Both parent and child share the same physical pages, marked read-only. When either writes to a page, a fault occurs and the kernel copies that page for the writer. The cost of fork() is marking page table entries read-only, which grows linearly with process size.

Example 1 — Benchmark fork() vs vfork() Speed

/* bench_fork_vfork.c — Measure 10,000 fork() and vfork() calls */
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <unistd.h>

#define ITERATIONS 10000

static double elapsed_ms(struct timeval *start, struct timeval *end)
{
    return (end->tv_sec  - start->tv_sec)  * 1000.0 +
           (end->tv_usec - start->tv_usec) / 1000.0;
}

static void bench_fork(void)
{
    struct timeval t1, t2;
    gettimeofday(&t1, NULL);

    for (int i = 0; i < ITERATIONS; i++) {
        pid_t pid = fork();
        if (pid == 0) _exit(0);         /* Child exits immediately */
        waitpid(pid, NULL, 0);          /* Parent waits */
    }

    gettimeofday(&t2, NULL);
    printf("fork():  %6.1f ms for %d iterations  (%5.0f/sec)\n",
           elapsed_ms(&t1, &t2), ITERATIONS,
           ITERATIONS / (elapsed_ms(&t1, &t2) / 1000.0));
}

static void bench_vfork(void)
{
    struct timeval t1, t2;
    gettimeofday(&t1, NULL);

    for (int i = 0; i < ITERATIONS; i++) {
        pid_t pid = vfork();
        if (pid == 0) _exit(0);         /* Child exits immediately */
        waitpid(pid, NULL, 0);
    }

    gettimeofday(&t2, NULL);
    printf("vfork(): %6.1f ms for %d iterations  (%5.0f/sec)\n",
           elapsed_ms(&t1, &t2), ITERATIONS,
           ITERATIONS / (elapsed_ms(&t1, &t2) / 1000.0));
}

int main(void)
{
    printf("Benchmarking process creation (%d iterations each)...\n\n",
           ITERATIONS);
    bench_fork();
    bench_vfork();

    /* Allocate extra heap to simulate a larger process */
    void *extra = malloc(10 * 1024 * 1024);   /* 10 MB */
    if (!extra) { perror("malloc"); return 1; }
    printf("\n--- After allocating 10 MB extra heap ---\n\n");
    bench_fork();
    bench_vfork();

    free(extra);
    return 0;
}
/* Compile: gcc -O2 -o bench bench_fork_vfork.c
   Run:     ./bench
   Expected: vfork() ~constant; fork() much slower after heap grows */

Example 2 — fork+exec vs vfork+exec (The Real Story)

When you add exec() after fork/vfork, the difference shrinks dramatically — exec() itself is expensive (disk I/O, dynamic linking). This example measures the full fork-exec lifecycle.

/* bench_exec.c — Compare fork+exec vs vfork+exec */
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <unistd.h>

#define ITERATIONS 1000
/* /bin/true: a program that does nothing and exits */
#define PROG "/bin/true"

static double elapsed_ms(struct timeval *a, struct timeval *b)
{
    return (b->tv_sec - a->tv_sec) * 1000.0
         + (b->tv_usec - a->tv_usec) / 1000.0;
}

int main(void)
{
    struct timeval t1, t2;
    char *args[] = { PROG, NULL };

    /* --- fork() + exec() --- */
    gettimeofday(&t1, NULL);
    for (int i = 0; i < ITERATIONS; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            execv(PROG, args);
            _exit(127);
        }
        waitpid(pid, NULL, 0);
    }
    gettimeofday(&t2, NULL);
    double fork_exec_ms = elapsed_ms(&t1, &t2);

    /* --- vfork() + exec() --- */
    gettimeofday(&t1, NULL);
    for (int i = 0; i < ITERATIONS; i++) {
        pid_t pid = vfork();
        if (pid == 0) {
            execv(PROG, args);
            _exit(127);
        }
        waitpid(pid, NULL, 0);
    }
    gettimeofday(&t2, NULL);
    double vfork_exec_ms = elapsed_ms(&t1, &t2);

    printf("fork()  + exec(): %7.1f ms  (%5.0f/sec)\n",
           fork_exec_ms,  ITERATIONS / (fork_exec_ms  / 1000.0));
    printf("vfork() + exec(): %7.1f ms  (%5.0f/sec)\n",
           vfork_exec_ms, ITERATIONS / (vfork_exec_ms / 1000.0));
    printf("Ratio: %.1fx\n", fork_exec_ms / vfork_exec_ms);
    printf("(Ratio is much smaller than without exec — exec dominates)\n");

    return 0;
}
/* Compile: gcc -O2 -o bench_exec bench_exec.c
   Run:     ./bench_exec  */

What clone() Flags Were Used in the Benchmark?

/* The clone() benchmark used these flags (sharing most resources): */
int flags = CLONE_VM     |   /* share virtual memory — no page table copy */
            CLONE_VFORK  |   /* suspend parent like vfork() */
            CLONE_FS     |   /* share filesystem attributes */
            CLONE_SIGHAND|   /* share signal dispositions */
            CLONE_FILES;     /* share file descriptor table */

/* This is why clone() was slightly faster than vfork():
   vfork() still copies the fd table and signal dispositions.
   clone() with CLONE_FILES + CLONE_SIGHAND skips those copies. */

Interview Questions