A Kernel Scheduling Entity (KSE) is the unit of work that the kernel’s scheduler manages. The kernel allocates CPU time to KSEs. In traditional single-threaded Unix, a KSE and a process were the same thing.

When threading was added to Unix, a new question arose: how should user-space threads (pthreads) map onto these kernel-visible KSEs? The answer defines the thread implementation model.

In the M:1 model, all threads map onto a single kernel scheduling entity. The kernel sees only one process. All thread management (creation, scheduling, synchronisation) happens entirely in user space via the threading library.

In the 1:1 model, each user thread maps to its own KSE. The kernel knows about every thread and schedules them individually.

The M:N model tries to combine the best of M:1 and 1:1. Multiple user threads map onto fewer KSEs. The library multiplexes user threads onto a pool of KSEs.

On Linux (1:1 model), threads actually run on different CPU cores simultaneously. This example uses CPU affinity to pin threads to specific cores and verifies parallel execution.

/*
 * ep_parallel_threads.c — Show true parallelism (1:1 model, multiple cores)
 * Compile: gcc -o ep_parallel_threads ep_parallel_threads.c -lpthread
 *
 * On a multicore system, you'll see both threads running simultaneously.
 * On M:1, only one would run at a time.
 */
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <time.h>

static volatile long counter_a = 0;
static volatile long counter_b = 0;

struct thread_arg {
    int cpu_id;        /* which CPU to run on */
    volatile long *counter; /* which counter to increment */
    const char *name;
};

void *cpu_bound_thread(void *arg)
{
    struct thread_arg *ta = (struct thread_arg *)arg;
    cpu_set_t cpuset;

    /* Pin this thread to a specific CPU */
    CPU_ZERO(&cpuset);
    CPU_SET(ta->cpu_id, &cpuset);
    int ret = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
    if (ret != 0)
        printf("[%s] Warning: could not set CPU affinity\n", ta->name);
    else
        printf("[%s] Pinned to CPU %d\n", ta->name, ta->cpu_id);

    /* Busy-work loop: count as fast as possible for 1 second */
    struct timespec start, now;
    clock_gettime(CLOCK_MONOTONIC, &start);
    while (1) {
        clock_gettime(CLOCK_MONOTONIC, &now);
        double elapsed = (now.tv_sec - start.tv_sec)
                       + (now.tv_nsec - start.tv_nsec) / 1e9;
        if (elapsed >= 1.0) break;
        (*ta->counter)++;
    }
    printf("[%s] Counted to: %ld\n", ta->name, *ta->counter);
    return NULL;
}

int main(void)
{
    pthread_t tid_a, tid_b;
    struct thread_arg arg_a = { .cpu_id = 0, .counter = &counter_a, .name = "ThreadA" };
    struct thread_arg arg_b = { .cpu_id = 1, .counter = &counter_b, .name = "ThreadB" };

    int ncpus = (int)sysconf(_SC_NPROCESSORS_ONLN);
    printf("[Main] CPUs available: %d\n", ncpus);
    printf("[Main] Creating two CPU-bound threads (Linux 1:1 model)\n");

    pthread_create(&tid_a, NULL, cpu_bound_thread, &arg_a);
    pthread_create(&tid_b, NULL, cpu_bound_thread, &arg_b);

    pthread_join(tid_a, NULL);
    pthread_join(tid_b, NULL);

    printf("[Main] Combined count: %ld\n", counter_a + counter_b);
    printf("[Main] In M:1 model, both threads would share 1 CPU;\n");
    printf("[Main] in 1:1 model they run truly in parallel.\n");
    return 0;
}

This example illustrates conceptually why a blocking syscall is fatal in M:1 but harmless in 1:1. We simulate it by having one thread block on read() (from a pipe with no writer) while another thread should continue working.

/*
 * ep_blocking_syscall.c — Simulate blocking syscall impact
 * In 1:1 (Linux): Thread B keeps running while Thread A blocks.
 * In M:1: Thread B would also freeze (kernel sees 1 process sleeping).
 *
 * Compile: gcc -o ep_blocking_syscall ep_blocking_syscall.c -lpthread
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

static int pipe_fds[2];  /* pipe: [0]=read end, [1]=write end */

/* Thread A: blocks on read() — simulates I/O wait */
void *blocking_thread(void *arg)
{
    char buf[64];
    printf("[ThreadA] About to call read() — will block until data arrives\n");
    ssize_t n = read(pipe_fds[0], buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("[ThreadA] Read: '%s'\n", buf);
    }
    printf("[ThreadA] Done\n");
    return NULL;
}

/* Thread B: CPU work — should NOT be affected by Thread A's blocking */
void *cpu_thread(void *arg)
{
    printf("[ThreadB] Doing CPU work (should NOT block even though Thread A is blocked)\n");
    long sum = 0;
    for (long i = 0; i < 200000000L; i++)  /* ~0.5s of work */
        sum += i;
    printf("[ThreadB] CPU work done. sum = %ld\n", sum);
    return NULL;
}

int main(void)
{
    pthread_t tid_a, tid_b;

    if (pipe(pipe_fds) != 0) { perror("pipe"); exit(1); }

    printf("[Main] Creating threads. Linux uses 1:1 model.\n");
    printf("[Main] Thread A will block on read(); Thread B should run freely.\n\n");

    pthread_create(&tid_a, NULL, blocking_thread, NULL);
    pthread_create(&tid_b, NULL, cpu_thread, NULL);

    /* Wait for Thread B to finish */
    pthread_join(tid_b, NULL);
    printf("\n[Main] Thread B finished — proves it was NOT blocked by Thread A.\n");
    printf("[Main] Now writing to pipe to unblock Thread A...\n");

    /* Unblock Thread A */
    write(pipe_fds[1], "wake up!", 8);
    pthread_join(tid_a, NULL);

    close(pipe_fds[0]);
    close(pipe_fds[1]);
    printf("[Main] All done.\n");
    return 0;
}