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

/*
 * Simplified view of what happens in the kernel when a blocking
 * system call is made by a process using user-level threads
 */
 
/* User-level thread calls read() */
void user_thread_537(void) {
    char buffer[4096];
    
    /* This looks innocent... */
    ssize_t n = read(fd, buffer, sizeof(buffer));
    /* ...but can freeze 999 other threads */
}
 
/* What happens in kernel (simplified) */
ssize_t sys_read(int fd, void *buf, size_t count) {
    struct file *f = get_file(fd);
    
    /* Check if data is available */
    if (!data_ready(f)) {
        /* Issue I/O request to device */
        submit_io_request(f, buf, count);
        
        /*
         * CRITICAL: This blocks the PROCESS.
         * 
         * current->state = TASK_INTERRUPTIBLE;
         * schedule();  // Remove from run queue, pick another process
         * 
         * ALL user-level threads in this process stop here.
         * The kernel doesn't know they exist.
         * The scheduler picks a completely different process.
         */
        wait_for_io_completion(f);
        
        /*
         * When I/O completes, process is woken up.
         * Whichever user-level thread was "current" continues.
         * Other user-level threads never knew they were frozen.
         */
    }
    
    return copy_data_to_user(f, buf, count);
}

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

"""
Throughput impact analysis for blocking problem
"""
 
# Scenario: 1000-thread web server
threads = 1000
requests_per_second_ideal = 10000  # 10 req/thread/sec
 
# Without blocking problem (kernel threads or non-blocking I/O)
# Each thread works independently
effective_throughput_ideal = requests_per_second_ideal
print(f"Ideal throughput: {effective_throughput_ideal} req/sec")
 
# With blocking problem: 
# Assume 5% of requests trigger a 10ms blocking call
blocking_probability = 0.05
block_duration_ms = 10
request_interval_ms = 100  # 10 req/sec means one every 100ms
 
# In any 100ms window, probability that at least one thread blocks:
# P(at least one blocks) ≈ 1 - (1 - 0.05)^active_threads_in_window
# With many threads active, this approaches certainty
 
# Expected blocking time per 100ms window:
# Multiple threads will hit blocking calls; they overlap
# Worst case: constant blocking as different threads take turns blocking
 
# Simplified model: if blocking events are uniformly distributed,
# and each blocks for 10ms, with 5% of 1000 threads blocking:
blocking_threads_per_100ms = threads * blocking_probability * (100 / 10)
# = 1000 * 0.05 * 10 = 500 blocking events per 100ms window
 
# With pure user-level threads, these DON'T overlap - they serialize!
# Each 10ms block stops ALL threads.
# If we have 50 blocking events in 100ms, we're blocked 500ms worth
# in a 100ms window = totally stalled
 
actual_blocked_time_pct = min(1.0, blocking_threads_per_100ms * block_duration_ms / 1000)
# = min(1.0, 500 * 10 / 1000) = min(1.0, 5.0) = 100% blocked!
 
print(f"
With blocking problem:")
print(f"  Blocking events per 100ms: ~50")
print(f"  Each block: 10ms, blocks ALL threads")
print(f"  Result: System nearly 100% stalled!")
print(f"  Effective throughput: ~0 req/sec")
 
print(f"
Conclusion: Even 5% blocking rate can completely")
print(f"stall a user-level threaded 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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
 
/*
 * Set a file descriptor to non-blocking mode
 * Returns 0 on success, -1 on failure
 */
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        return -1;
    }
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
 
/*
 * Non-blocking read wrapper for user-level threads
 * 
 * Returns:
 *   > 0  : Number of bytes read
 *   0    : EOF (connection closed)
 *   -1   : Would block (EAGAIN/EWOULDBLOCK) - try again later
 *   -2   : Actual error
 */
ssize_t nonblocking_read(int fd, void *buf, size_t count) {
    ssize_t n = read(fd, buf, count);
    
    if (n >= 0) {
        return n;  /* Success or EOF */
    }
    
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        return -1;  /* Would block - data not ready */
    }
    
    return -2;  /* Real error */
}
 
/*
 * User-level thread-aware read
 * 
 * Instead of blocking, we yield to other threads and retry.
 * The thread library's scheduler handles the polling.
 */
ssize_t thread_aware_read(int fd, void *buf, size_t count) {
    while (1) {
        ssize_t n = nonblocking_read(fd, buf, count);
        
        if (n >= 0) {
            return n;  /* Got data or EOF */
        }
        
        if (n == -1) {
            /* Would block - yield to other threads */
            register_fd_for_read_ready(fd, current_thread);
            thread_block();  /* Sleep until fd is readable */
            /* When we wake up, loop and try read again */
            continue;
        }
        
        /* n == -2: Real error */
        return -1;
    }
}
 
/*
 * Non-blocking connect with thread integration
 */
int thread_aware_connect(int sockfd, const struct sockaddr *addr, 
                         socklen_t addrlen) {
    /* Set non-blocking first */
    set_nonblocking(sockfd);
    
    int result = connect(sockfd, addr, addrlen);
    
    if (result == 0) {
        return 0;  /* Immediate success (rare for remote) */
    }
    
    if (errno == EINPROGRESS) {
        /* Connection in progress - wait for writability */
        register_fd_for_write_ready(sockfd, current_thread);
        thread_block();
        
        /* Check if connect succeeded */
        int error;
        socklen_t len = sizeof(error);
        getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len);
        
        if (error == 0) {
            return 0;  /* Success */
        }
        errno = error;
        return -1;
    }
    
    return -1;  /* Immediate failure */
}

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

/*
 * Jacketing: Transparent blocking call interception
 * 
 * These wrapper functions replace standard library functions,
 * making blocking operations thread-aware without changing
 * application code.
 */
 
#include <dlfcn.h>  /* For dlsym to get original function */
 
/* Original function pointers, loaded once at startup */
static ssize_t (*real_read)(int, void*, size_t) = NULL;
static ssize_t (*real_write)(int, const void*, size_t) = NULL;
static int (*real_accept)(int, struct sockaddr*, socklen_t*) = NULL;
 
__attribute__((constructor))
void init_jackets(void) {
    real_read = dlsym(RTLD_NEXT, "read");
    real_write = dlsym(RTLD_NEXT, "write");
    real_accept = dlsym(RTLD_NEXT, "accept");
}
 
/*
 * Jacketed read() - intercepts all read() calls
 * 
 * 1. Check if fd is non-blocking or would succeed
 * 2. If would block, register for events and sleep thread
 * 3. When ready, retry
 */
ssize_t read(int fd, void *buf, size_t count) {
    /* First, ensure fd is non-blocking */
    ensure_nonblocking(fd);
    
    while (1) {
        ssize_t n = real_read(fd, buf, count);
        
        if (n >= 0) {
            return n;  /* Success */
        }
        
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            /* Would block - yield to other threads */
            io_wait_read(fd);  /* Register and block user-thread */
            continue;          /* Retry after wake */
        }
        
        /* Real error */
        return -1;
    }
}
 
/*
 * Jacketed accept() - intercepts all accept() calls
 */
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
    ensure_nonblocking(sockfd);
    
    while (1) {
        int client = real_accept(sockfd, addr, addrlen);
        
        if (client >= 0) {
            /* Also make client socket non-blocking */
            ensure_nonblocking(client);
            return client;
        }
        
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            io_wait_read(sockfd);  /* Wait for connection */
            continue;
        }
        
        return -1;
    }
}
 
/*
 * io_wait_read() - Block user-level thread until fd is readable
 */
void io_wait_read(int fd) {
    /* Add fd to epoll interest list for current thread */
    struct epoll_event ev = {
        .events = EPOLLIN | EPOLLET,
        .data.ptr = current_thread
    };
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    
    /* Mark thread as blocked on I/O */
    current_thread->wait_reason = WAIT_IO_READ;
    current_thread->wait_fd = fd;
    
    /* Block this thread (not the process!) */
    thread_block();
    
    /* Woken up - remove from epoll */
    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
}

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

/*
 * Scheduler Activations - User-level scheduler integration
 * 
 * Simplified conceptual implementation showing the upcall handling
 */
 
/* Upcall handler - kernel calls this when thread blocks/unblocks */
void upcall_handler(int event_type, tcb_t *thread, void *aux) {
    switch (event_type) {
        
        case UPCALL_THREAD_BLOCKED:
            /*
             * A user-level thread made a blocking syscall.
             * Kernel has allocated us a new virtual processor.
             * We're running on that new processor now.
             * 
             * The blocked thread's state is saved by the kernel.
             * We need to schedule work for this processor.
             */
            
            /* Mark thread as blocked */
            thread->state = THREAD_BLOCKED_SYSCALL;
            thread->blocked_on = aux;  /* What it's waiting for */
            
            /* Schedule another thread on this virtual processor */
            tcb_t *next = dequeue_ready();
            if (next) {
                context_switch_to(next);
            } else {
                /* No ready threads - idle this processor */
                idle_virtual_processor();
            }
            break;
            
        case UPCALL_THREAD_UNBLOCKED:
            /*
             * A previously blocked thread can now continue.
             * Add it back to the ready queue.
             */
            thread->state = THREAD_READY;
            enqueue_ready(thread);
            
            /* Potentially preempt current thread if higher priority */
            maybe_preempt_current(thread);
            break;
            
        case UPCALL_PROCESSOR_PREEMPTED:
            /*
             * Kernel preempted one of our virtual processors.
             * Save state and adjust scheduling.
             */
            thread->state = THREAD_READY;
            enqueue_ready(thread);
            num_virtual_processors--;
            break;
            
        case UPCALL_PROCESSOR_GRANTED:
            /*
             * Kernel gave us back a virtual processor.
             * Schedule a thread on it.
             */
            num_virtual_processors++;
            tcb_t *to_run = dequeue_ready();
            if (to_run) {
                context_switch_to(to_run);
            }
            break;
    }
}

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

/*
 * Go's runtime handles blocking transparently
 * 
 * When a goroutine blocks on I/O, the runtime:
 * 1. Parks the goroutine (user-level block)
 * 2. Uses netpoller for async I/O internally  
 * 3. Keeps the kernel thread (M) running other goroutines
 * 4. When I/O ready, netpoller unparks the goroutine
 */
 
package main
 
import (
    "fmt"
    "net/http"
    "time"
)
 
func handler(w http.ResponseWriter, r *http.Request) {
    // This sleeps *only* this goroutine, not the thread
    time.Sleep(100 * time.Millisecond)
    
    // This network I/O uses netpoller - non-blocking internally
    resp, _ := http.Get("https://example.com")
    defer resp.Body.Close()
    
    // Other goroutines continue running on other Ms
    // or even on this same M after we park
    
    fmt.Fprintf(w, "Done!")
}
 
func main() {
    // GOMAXPROCS sets number of kernel threads (Ps)
    // Default is number of CPUs
    // Each P can run many goroutines (Gs)
    
    // 10000 concurrent handlers only need ~8 kernel threads
    // Blocking in one handler doesn't affect others
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}
 
/*
 * Key insight: Go wraps ALL blocking operations:
 * - Network I/O → netpoller (epoll/kqueue based)
 * - File I/O → often background goroutine on separate M
 * - Sleep → timer heap in runtime
 * - Channel ops → goroutine parking
 * 
 * The programmer writes blocking-style code;
 * the runtime makes it non-blocking underneath.
 */