Kernel-Level Threads

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// Measure actual memory consumption of threads
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/resource.h>
 
#define NUM_THREADS 1000
 
// Get resident set size (actual physical memory used)
long get_rss_kb() {
    FILE *file = fopen("/proc/self/statm", "r");
    if (!file) return -1;
    
    long size, rss;
    fscanf(file, "%ld %ld", &size, &rss);
    fclose(file);
    
    return rss * 4;  // Pages to KB (assuming 4KB pages)
}
 
void *thread_func(void *arg) {
    // Thread does minimal work, just waits
    pause();  // Sleep forever
    return NULL;
}
 
int main() {
    pthread_t threads[NUM_THREADS];
    
    printf("Initial RSS: %ld KB\n", get_rss_kb());
    
    // Create threads with custom (small) stacks
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr, 64 * 1024);  // 64 KB stack
    
    for (int i = 0; i < NUM_THREADS; i++) {
        if (pthread_create(&threads[i], &attr, thread_func, NULL) != 0) {
            printf("Failed to create thread %d\n", i);
            break;
        }
        
        // Report progress
        if ((i + 1) % 100 == 0) {
            printf("After %d threads: RSS = %ld KB (%.1f KB/thread)\n",
                   i + 1, get_rss_kb(),
                   (double)get_rss_kb() / (i + 1));
        }
    }
    
    printf("Final RSS: %ld KB for %d threads\n", get_rss_kb(), NUM_THREADS);
    printf("Approximate per-thread overhead: %.1f KB\n", 
           (double)get_rss_kb() / NUM_THREADS);
    
    // Sample output on Linux 5.x:
    // Initial RSS: 4000 KB
    // After 100 threads: RSS = 10400 KB (104.0 KB/thread)
    // After 500 threads: RSS = 50000 KB (100.0 KB/thread)
    // After 1000 threads: RSS = 100000 KB (100.0 KB/thread)
    //
    // ~100 KB per thread with 64 KB user stack
    // = 64 KB user stack + ~8 KB kernel stack + ~15 KB task_struct + overhead
    
    // Note: With default 8 MB stacks, each thread would consume 
    // more virtual address space but similar physical memory
    // (if they don't actually use the full stack).
    
    sleep(5);  // Keep threads alive briefly
    
    return 0;
}

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// Measure context switch overhead using ping-pong between threads
#define _GNU_SOURCE
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <time.h>
 
#define ITERATIONS 100000
 
int pipe_fd[2][2];  // Two pairs of pipes for bidirectional communication
char buffer[1];
 
void *thread_func(void *arg) {
    // Pin to CPU 1
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(1, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
    
    for (int i = 0; i < ITERATIONS; i++) {
        // Read from pipe 0 (blocks until main thread writes)
        read(pipe_fd[0][0], buffer, 1);
        // Write to pipe 1 (wakes main thread)
        write(pipe_fd[1][1], buffer, 1);
    }
    
    return NULL;
}
 
int main() {
    pipe(pipe_fd[0]);  // Main → Thread
    pipe(pipe_fd[1]);  // Thread → Main
    
    // Pin main thread to CPU 0
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(0, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
    
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    
    // Let thread start
    sched_yield();
    
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (int i = 0; i < ITERATIONS; i++) {
        // Write to pipe 0 (wakes other thread)
        write(pipe_fd[0][1], buffer, 1);
        // Read from pipe 1 (blocks until other thread writes)
        read(pipe_fd[1][0], buffer, 1);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    
    pthread_join(thread, NULL);
    
    double total_ns = (end.tv_sec - start.tv_sec) * 1e9 + 
                      (end.tv_nsec - start.tv_nsec);
    
    // Each iteration involves 2 context switches
    // (main → other, other → main)
    double per_switch_ns = total_ns / (ITERATIONS * 2);
    
    printf("Total time: %.2f ms\n", total_ns / 1e6);
    printf("Per context switch: %.2f μs\n", per_switch_ns / 1000);
    printf("Context switches per second: %.0f\n", 1e9 / per_switch_ns);
    
    // Typical output on modern Linux:
    // Per context switch: 1.5-5.0 μs
    // (Includes pipe I/O overhead, so actual switch is faster)
    
    return 0;
}

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// Test how performance degrades with increasing thread count
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
 
volatile long counter = 0;
volatile int running = 1;
 
void *busy_thread(void *arg) {
    long local_counter = 0;
    
    while (running) {
        local_counter++;  // Busy work
    }
    
    __sync_fetch_and_add(&counter, local_counter);
    return NULL;
}
 
void test_with_threads(int num_threads, int num_cpus) {
    pthread_t threads[num_threads];
    counter = 0;
    running = 1;
    
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    // Create threads
    for (int i = 0; i < num_threads; i++) {
        pthread_create(&threads[i], NULL, busy_thread, NULL);
    }
    
    // Let them run for 1 second
    sleep(1);
    
    running = 0;
    
    for (int i = 0; i < num_threads; i++) {
        pthread_join(threads[i], NULL);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    
    double elapsed = (end.tv_sec - start.tv_sec) + 
                     (end.tv_nsec - start.tv_nsec) / 1e9;
    
    double per_cpu = (double)counter / num_cpus;
    double efficiency = per_cpu / (counter / num_threads) * 100;
    
    printf("Threads: %4d | Work: %12ld | Per-CPU: %.0f (%.1f%% of ideal)\n",
           num_threads, counter, per_cpu, 
           (num_threads <= num_cpus) ? 100.0 : 
               (double)counter / (counter / num_cpus * num_threads) * 100);
}
 
int main() {
    int num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
    printf("System has %d CPUs\n\n", num_cpus);
    
    // Test with varying thread counts
    test_with_threads(1, num_cpus);
    test_with_threads(num_cpus, num_cpus);
    test_with_threads(num_cpus * 2, num_cpus);
    test_with_threads(num_cpus * 4, num_cpus);
    test_with_threads(num_cpus * 10, num_cpus);
    test_with_threads(num_cpus * 100, num_cpus);
    
    // Expected pattern:
    // - Threads = CPUs: Best throughput
    // - Threads = 2x CPUs: Slight overhead from switching
    // - Threads = 10x CPUs: Noticeable overhead
    // - Threads = 100x CPUs: Significant overhead, diminishing returns
    
    return 0;
}

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
47

#!/bin/bash
# Check thread-related limits on Linux
 
echo "=== System-Wide Limits ==="
 
# Maximum number of threads system-wide
echo "threads-max: $(cat /proc/sys/kernel/threads-max)"
# Default is typically: RAM(KB) / 128 (or similar formula)
 
# Maximum number of PIDs (limits threads since each thread has a TID)
echo "pid_max: $(cat /proc/sys/kernel/pid_max)"
# Default: 32768 on 32-bit, up to 4194304 on 64-bit
 
echo ""
echo "=== Per-User Limits ==="
 
# Maximum processes per user (ulimit -u)
ulimit -u
# This limits threads too (NPROC limit)
 
# To change: edit /etc/security/limits.conf or use ulimit -u
 
echo ""
echo "=== Memory Limits ==="
 
# Virtual memory per process (stack space multiplied by thread count)
ulimit -v  # -1 means unlimited
 
# Stack size per thread
ulimit -s  # Typically 8192 KB (8 MB)
 
echo ""
echo "=== Calculating Practical Maximum ==="
 
# With 8 MB stacks, a 32-bit process with 3 GB user space:
# 3 GB / 8 MB = 384 threads maximum (just due to address space!)
 
# With 64-bit and reduced 64 KB stacks:
# Limited by threads-max, pid_max, or memory - whichever is smallest
 
# Example: 16 GB RAM system, 128 bytes per thread-max unit
# threads-max ≈ 16 GB / 128 = ~130,000 threads
 
echo ""
echo "=== Current Thread Count ==="
ps -eL | wc -l
# Shows all threads on system

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// Find practical thread limit on current system
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
 
void *empty_func(void *arg) {
    pause();  // Sleep forever
    return NULL;
}
 
int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    
    // Use minimal stack size to maximize thread count
    size_t stack_size = 16 * 1024;  // 16 KB minimum
    pthread_attr_setstacksize(&attr, stack_size);
    
    printf("Attempting to create threads with %zu KB stacks...\n", 
           stack_size / 1024);
    
    int count = 0;
    int failed = 0;
    
    while (!failed) {
        pthread_t thread;
        int ret = pthread_create(&thread, &attr, empty_func, NULL);
        
        if (ret != 0) {
            printf("\nFailed to create thread %d: %s\n", 
                   count + 1, strerror(ret));
            failed = 1;
        } else {
            count++;
            if (count % 1000 == 0) {
                printf("Created %d threads...\n", count);
            }
        }
    }
    
    printf("\nMaximum threads created: %d\n", count);
    printf("Approximate memory used: %d MB\n", 
           (int)(count * (stack_size + 20 * 1024) / (1024 * 1024)));
    
    // Don't exit - keeps threads alive for inspection
    // (In practice, you'd cleanup here)
    
    printf("Press Ctrl+C to exit...\n");
    pause();
    
    return 0;
}
 
/*
 * Typical results:
 * 
 * 16 GB RAM Linux system, 16 KB stacks:
 *   Maximum threads: ~60,000-80,000
 *   Limited by: threads-max or OUT_OF_MEMORY
 *
 * 4 GB RAM system:
 *   Maximum threads: ~15,000-25,000
 *   Limited by: ENOMEM (no memory for kernel structures)
 *
 * 32-bit process:
 *   Maximum threads: ~300-500 (address space exhaustion)
 *   Even with small stacks, virtual space is limited
 */

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
47
48
49

// Setting appropriate stack sizes
#include <pthread.h>
#include <stdio.h>
 
void *worker(void *arg) {
    // Typical thread: uses a few KB of stack for local variables
    char local_buffer[4096];  // 4 KB
    // ... do work ...
    return NULL;
}
 
int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    
    // Option 1: Set specific size (with PTHREAD_STACK_MIN guard)
    size_t stack_size = 64 * 1024;  // 64 KB
    pthread_attr_setstacksize(&attr, stack_size);
    
    // Option 2: Query default and reduce
    size_t default_size;
    pthread_attr_getstacksize(&attr, &default_size);
    printf("Default stack size: %zu KB\n", default_size / 1024);
    
    // Create thread with custom stack
    pthread_t thread;
    pthread_create(&thread, &attr, worker, NULL);
    pthread_join(thread, NULL);
    
    pthread_attr_destroy(&attr);
    
    // Caution: Too small causes stack overflow!
    // Always test under realistic workloads
    // Use guard pages (default) to catch overflow
    
    return 0;
}
 
/*
 * Sizing guidelines:
 * - Simple workers with few local vars: 32-64 KB
 * - Typical application code: 64-256 KB
 * - Deep recursion or large buffers: 512 KB+
 * - Unknown/general purpose: 1-2 MB (still less than 8 MB default)
 *
 * Trade-off:
 *   Small stacks → More threads possible, risk of overflow
 *   Large stacks → Fewer threads, safer
 */

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
47

# Python example: Threads vs. AsyncIO for I/O-bound work
 
import asyncio
import threading
import time
import aiohttp
import requests
 
URLS = ["https://example.com"] * 100
 
# === APPROACH 1: Thread per request ===
def fetch_with_threads():
    def fetch(url):
        requests.get(url)
    
    threads = [threading.Thread(target=fetch, args=(url,)) for url in URLS]
    
    start = time.time()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    print(f"Threads: {time.time() - start:.2f}s, Memory: ~{len(URLS) * 100}KB")
    # 100 threads × ~100 KB = ~10 MB memory overhead
    # Works fine for 100 requests
    # Fails or becomes slow for 10,000 requests
 
# === APPROACH 2: Async with limited threads ===
async def fetch_with_async():
    async def fetch(session, url):
        async with session.get(url) as response:
            await response.text()
    
    start = time.time()
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in URLS]
        await asyncio.gather(*tasks)
    
    print(f"Async: {time.time() - start:.2f}s, Memory: ~{len(URLS) * 1}KB")
    # 100 coroutines × ~1 KB = ~100 KB overhead
    # Uses only a few threads (managed by event loop)
    # Scales easily to 10,000+ concurrent requests
 
# Key insight:
# For I/O-bound work, async is 100x more memory efficient
# For CPU-bound work, threads (via ProcessPoolExecutor) are still needed

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# Thread capacity planning calculations
 
class ThreadCapacityPlanner:
    def __init__(
        self,
        system_ram_gb: float,
        num_cpus: int,
        stack_size_kb: int = 64,
        kernel_overhead_kb: int = 25
    ):
        self.system_ram_gb = system_ram_gb
        self.num_cpus = num_cpus
        self.stack_size_kb = stack_size_kb
        self.kernel_overhead_kb = kernel_overhead_kb
    
    def max_threads_by_memory(self) -> int:
        """Maximum threads before exhausting memory"""
        available_kb = self.system_ram_gb * 1024 * 1024 * 0.5  # Use 50% for threads
        per_thread_kb = self.stack_size_kb + self.kernel_overhead_kb
        return int(available_kb / per_thread_kb)
    
    def optimal_threads_cpu_bound(self) -> int:
        """Optimal thread count for CPU-bound work"""
        return self.num_cpus  # Or 2x for hyperthreading
    
    def optimal_threads_io_bound(
        self, 
        avg_io_wait_ms: float,
        avg_cpu_work_ms: float
    ) -> int:
        """Optimal thread count for I/O-bound work (Little's Law)"""
        # Threads = CPUs × (1 + io_wait / cpu_work)
        return int(self.num_cpus * (1 + avg_io_wait_ms / avg_cpu_work_ms))
    
    def thread_pool_size(
        self,
        requests_per_second: float,
        avg_response_time_ms: float
    ) -> int:
        """Thread pool size for given throughput (Little's Law)"""
        # Concurrent requests = arrival_rate × service_time
        return int(requests_per_second * (avg_response_time_ms / 1000)) + 1
 
# Example usage
planner = ThreadCapacityPlanner(
    system_ram_gb=16,
    num_cpus=8,
    stack_size_kb=64
)
 
print(f"Max threads by memory: {planner.max_threads_by_memory():,}")
# ~85,000 threads (but probably hit other limits first)
 
print(f"Optimal for CPU-bound: {planner.optimal_threads_cpu_bound()}")
# 8 threads
 
print(f"Optimal for I/O-bound (100ms IO, 10ms CPU): "
      f"{planner.optimal_threads_io_bound(100, 10)}")
# 88 threads
 
print(f"Pool size for 1000 req/s, 50ms response: "
      f"{planner.thread_pool_size(1000, 50)}")
# 51 threads