perf(reactor): RX-epoll receive path, no epoll_ctl per keep-alive request

[gg582]

Why

When cwist can't get an io_uring ring, it falls back to epoll (CWIST_REACTOR_BACKEND=epoll, or a container whose seccomp profile blocks io_uring_setup). Docker's default profile does this, which matters for the the-benchmarker comparison in #319. On the epoll path, each keep-alive request cost four syscalls:

per request (strace, 1 worker, wrk -c64)	io_uring	epoll (before)	epoll (this PR)
sendmsg	1	1	1
recvfrom	0	1	1
epoll_ctl	0	2 (ADD → EEXIST, then MOD)	0 (132 in total, all per connection)
wait (io_uring_enter / epoll_wait)	~0.03	~0.02	~0.02

Two problems on the old path:

• The one-shot re-arm always tried EPOLL_CTL_ADD first, so every keep-alive request failed one epoll_ctl before the MOD.
• EPOLLONESHOT needs a MOD on every request anyway.

What

• RX-epoll. reactor_rx.h's receive contract (cwist_reactor_recv_arm plus the completion handler) is now served on epoll as well.
  • The connection's fd stays registered edge-triggered: EPOLLIN|EPOLLRDHUP|EPOLLET, no EPOLLONESHOT, user_data = fd << 1 | 1.
  • On readiness, the reactor recv()s into the armed buffer and calls the same rx_cb. http.c is unchanged.
  • No stranded bytes: if a receive fills the buffer, or an edge arrives while nothing is armed, the fd is queued and received before the next wait (epoll_wait gets a zero timeout).
  • Thread rule: arms are accepted on the reactor's run thread only. Off-thread arms return false, and the existing POLL fallback re-arms from the run thread.
  • Leaving RX mode: any cwist_reactor_add/_mod/_del of the fd takes it back to the one-shot path, and the next RX arm registers it again. Both MOD and ADD report an already-readable fd, so no edge is lost when switching.
  • -EAGAIN is never reported: the receive stays armed until bytes, EOF or an error arrive.
• Registration hint. A process-wide per-fd state table, with chunks allocated lazily: 24 B per fd in the ranges actually used.
  • One-shot re-arms of an already-registered fd go straight to EPOLL_CTL_MOD.
  • The accept path resets the state of each fresh fd (cwist_reactor_fd_forget).
  • Every state is only a hint with an ENOENT/EEXIST fallback. RX mode is trusted only for the same connection pointer.
• Knob. CWIST_RX_EPOLL=0 restores the old one-shot path. It's documented in docs/runtime-config.md (plus the ko mirror).
• Comment only: the RX comment in the public http.h struct. The layout is unchanged and check_api_baseline passes.

Numbers

Contract app from benchmarks/web-frameworks (GET /), CWIST_WORKERS=4, server on 2 physical cores (cpus 0,1,6,7), wrk -t8 on the other 4, Ryzen 5600X. Each value is the median of 3 interleaved rounds:

conns	epoll before	epoll after	io_uring before	io_uring after
64 req/s	330k	356k (+8%)	347k	347k
64 P50	0.181 ms	0.166 ms (−8%)	0.173 ms	0.176 ms
512 req/s	324k	355k (+10%)	364k	361k
512 P50	1.53 ms	1.40 ms (−9%)	1.34 ms	1.36 ms

A second, noisier pass (4 rounds, with other load on the desktop) showed the same relative change: epoll +7% / +9% / +8% req/s at 64 / 256 / 512 conns, with P50 down 10% / 9% / 9%. io_uring stayed within noise.

So epoll is now within a few percent of io_uring at 512 conns, and ahead of it at 64.

Tests

• New tests/test_rx_epoll.c (wired into TEST_TARGETS, runs under TSan). It includes reactor.c and counts epoll_ctl calls, like test_reactor_wake.c does. It covers:
  • off-thread arms are refused
  • 200 keep-alive receives with zero epoll_ctl after the first arm
  • 100 bytes through a 10-byte buffer with no new edges
  • bytes that arrive while unarmed reach the next arm
  • one-shot cwist_reactor_add takes the fd over, and RX registers it again afterwards
  • a new connection pointer on the same fd registers again
  • EOF
  • cwist_reactor_fd_forget
• Local runs:
  • make test: passes in full both with CWIST_REACTOR_BACKEND=epoll and on the default backend.
  • test_rx_epoll: clean under TSan and under ASan/UBSan.
  • check_test_wiring, check_env_knobs, check_api_baseline and cwist audit --gate all pass.

Refs #319.