Context-Switch Microbench: Pipe Ping-Pong Process vs Thread

Intro — what this post promises

A context switch is what you pay when the kernel (or a userspace scheduler) stops one runnable task and starts another. Folklore quotes “a few microseconds.” This lab forces switches with a pipe ping-pong and measures round-trip latency.

This is a hands-on lab with measured numbers:

1. Process↔process pipe ping-pong RTT and implied switch rate.
2. Thread↔thread pipe ping-pong (same pattern, one address space).
3. threading.Event vs asyncio.Event ping-pong.
4. sched_yield and a userspace control.
5. CPU hogs: p50 stays flat while p95/mean blow out.

Related links:

• Pipe vs tmpfile IPC localhost lab
• ProcessPool vs ThreadPool GIL localhost lab
• epoll vs select FD_SETSIZE localhost lab
• Why your average latency graph is lying (p50 / p95 / p99)

Lab honesty (1 Oct 2026 IST): Shared Linux lab box (8 cores, kernel 6.12). Python 3.13.5 pipes + events. No Docker. No GPU. No API keys. Affiliates: 0. This is a Python microbench, not lmbench C numbers.

Verdict up front: process pipe RTT p50 ≈ 3.2 µs (~0.50M sw/s if 2 switches/RTT); thread pipe ≈ 2.85 µs; threading.Event ≈ 9.3 µs; asyncio.Event ≈ 5.3 µs; under 6 CPU hogs, p50 stayed ~3.6 µs while p95 ≈ 19 µs.

What we compared

Related links:

• pipe(7) — Linux man-pages
• sched_yield(2)

Lab topology

Parent writes 1 byte on pipe1 → child blocks-in-read then writes pipe2 → parent reads
Timed unit = one RTT (typically ~2 forced switches)
Also: Event ping-pong; sched_yield loop; 0/2/6 busy-loop hog processes

Assumption we label explicitly: 1 RTT ≈ 2 switches for the pipe arms. Rates are approximate.

Arm A/B — pipe ping-pong

n=20 000 timed RTTs (after warmup):

Same pattern; threads were ~13% faster p50 on this box (no TLB/mm switch). Stability×3 median p50: process 3.35 µs, thread 2.84 µs.

Child /proc/<pid>/status voluntary switches ≈ 0.8/op on the interference runs — the wakeups are real, not imaginary.

Related links:

• Pipe vs tmpfile IPC localhost lab

Arm C/D — Event ping-pong

threading.Event was the slowest ping-pong here — heavier than the pipe path. Asyncio was mid-pack: cooperative ≠ free; you still pay Python scheduling even when the kernel stays out.

Arm E — yield and userspace floor

A lone sched_yield is not a two-task switch benchmark — often nothing else is runnable. Treat it as a syscall floor, not “context switch cost.”

Arm F — CPU interference (why p95 matters)

Process pipe RTT with busy-loop hogs:

Median barely moved. p95 and mean took the hit — the classic “average latency graph is lying” failure mode under load.

Related links:

• Why your average latency graph is lying (p50 / p95 / p99)

How to read these numbers

• Pipe RTT is a forced switch microbench, not your app’s p99.
• Process vs thread here is close; the bigger jump was Event vs pipe.
• Asyncio Event avoids kernel ctx switches but still costs microseconds in CPython.
• Under CPU contention, publish p95/p99, not only p50.

Pitfalls we hit (or avoided)

1. Calling sched_yield a context-switch benchmark — needs a competing runnable task.
2. Using only parent /proc/self voluntary counts — child’s switches live under the child pid.
3. Reporting M sw/s without the 2-switches/RTT assumption — we label it.
4. Comparing to C lmbench headlines — different runtime; do not paste those as ours.
5. Trusting p50 under load — Arm F’s p95 is the story.

Practical checklist

• When claiming switch cost, show method (pipe/Event) + p50/p95 + core count.
• Separate kernel switches from userspace scheduler hops (asyncio).
• Under shared hosts, watch tails when runnable count rises.
• Prefer fewer blocking hops on latency-critical paths; batch work per wake.
• Keep microbench evidence next to any “µs context switch” slide.

Verdict

Python pipe ping-pong on this box: process RTT p50 ≈ 3.2 µs (~0.50M sw/s); thread pipe ≈ 2.85 µs; threading.Event ≈ 9.3 µs; asyncio.Event ≈ 5.3 µs. With 6 CPU hogs, p50 stayed ~3.6 µs while p95 climbed to ~19 µs.

Evidence path on the lab box: lab-evidence/29-context-switch/results/. Affiliates: 0.