In this lesson, you will learn how to visualize "event loop lag"—the delay between when an asynchronous task is scheduled and when it actually executes—by tracing the underlying event notification mechanisms in Linux.
In asynchronous runtimes like Node.js or Python's asyncio, the event loop typically rests on a system call like epoll_wait (or select/poll). When a task is ready to run, the kernel notifies the runtime, which then processes the event. However, if the event loop is blocked by long-running synchronous code, the runtime cannot respond to these notifications, causing an execution delay known as "loop lag."
Visualizing the Gap
To quantify this, we look for the delta between the time an event is ready in the kernel and the time the application actually wakes up to process it. While runtimes provide internal timers, observing this at the system level requires tracing the epoll_wait cycle.
Consider a scenario where an event loop is busy performing CPU-intensive work. We can use bpftrace to hook into the return of epoll_wait. By tracking the timestamp when the thread wakes up from the kernel and comparing it to when the loop expected to wake up, we can identify "hiccups."
# Conceptual probe: tracing the time spent in epoll_wait
# against expected scheduling intervals
bpftrace -e 'tracepoint:syscalls:sys_exit_epoll_wait {
@start[tid] = nsecs;
}
tracepoint:syscalls:sys_enter_epoll_wait /@start[tid]/ {
@latency = hist(nsecs - @start[tid]);
delete(@start[tid]);
}'
When latency histograms show significant outliers, it indicates that the event loop is being starved by synchronous blocks (e.g., blocking I/O or heavy computation on the main thread). By correlating these spikes with perf metrics or tracepoints, we can distinguish between kernel-level scheduling contention and application-level logic bottlenecks. If the gap is wide even when the system load is low, the culprit is almost certainly code occupying the event loop thread, preventing it from calling back into epoll_wait to handle the next batch of ready file descriptors.
Key Takeaway: Event loop lag is measured by the delta between expected event processing time and actual system-level wakeup; spikes in this metric indicate that synchronous, non-yielding code is starving the event loop.