auto* impl = hs::webserver_test_access::impl(ws);

constexpr std::size_t kPhaseIdx =

static_cast<std::size_t>(hs::hook_phase::response_sent);

auto& gate = impl->hooks_.any_hooks_[kPhaseIdx];

// measure_median_ns's default 10 000-iteration warmup primes the

// branch predictor. The true thermal / instruction-cache warmup

// happens during the first outer round (1 M loads), which dwarfs the

// explicit pre-loop — the median of 51 rounds is robust to 1-2 high

// outlier early rounds.

//

// label=nullptr keeps this bench's historical unlabeled output line

// (" median=..."), which CI may parse.

return measure_median_ns(

nullptr,

[&]() {

const bool v = gate.load(std::memory_order_relaxed);

do_not_optimize(v);

},

outer, inner);

if constexpr (kSanitizerBuild) {

std::printf("bench_hook_overhead: skipped (sanitizer build "

"would distort ns/call)\n");

return 0;

}

// OUTER=51 gives a stable median (26th value when sorted, i.e. the

// exact midpoint) and a meaningful p99 (50th value). The extra 40

// rounds cost < 40 ms on any modern host at 1 M iterations each and

// are well worth the statistical reliability on noisy CI cores.

constexpr std::size_t OUTER = 51;

constexpr std::size_t INNER = 1'000'000;

// (a) Zero hooks registered.

std::printf("bench_hook_overhead (a): zero hooks at response_sent\n");

double median_a = 0.0;

{

hs::webserver ws_a{hs::create_webserver(0)};

median_a = measure_gate_cost(ws_a, OUTER, INNER);

}

// (b) One observation hook registered. The dispatch gate now

// observes `true`; the load cost itself is identical, the only

// visible diff is branch-predictor state.

std::printf("bench_hook_overhead (b): one observation hook at response_sent\n");

double median_b = 0.0;

{

hs::webserver ws_b{hs::create_webserver(0)};

auto h = ws_b.add_hook(hs::hook_phase::response_sent,

std::function<void(const hs::response_sent_ctx&)>(

[](const hs::response_sent_ctx&) {}));

median_b = measure_gate_cost(ws_b, OUTER, INNER);

(void)h; // keep the registration alive across the measure

}

// hook_baseline_ns is the no-hooks gate-load median (HOOK_BASELINE_NS in

// the design docs), measured in this same run so the relative gate

// auto-tracks runner speed.

const double hook_baseline_ns = median_a;

// Relative ceiling: 2 x baseline. At the sub-nanosecond magnitudes

// these gate loads run at, 2x of a tiny baseline is itself tiny, and

// pure measurement jitter (a single retired-instruction difference per

// 1M-iteration round) could otherwise false-trip the gate. A small

// additive noise floor (kRelativeGateNoiseFloorNs) keeps the gate from

// firing on sub-ns sampling noise while still failing hard the moment a

// real, attributable hook-bus regression appears.

constexpr double kRelativeGateNoiseFloorNs = 2.0;

const double relative_gate_ns =

kRelativeGateFactor * hook_baseline_ns + kRelativeGateNoiseFloorNs;

std::printf("\nbench_hook_overhead summary:\n");

std::printf(" (a) zero hooks median = %.3f ns/call (HOOK_BASELINE_NS)\n",

median_a);

std::printf(" (b) one hook median = %.3f ns/call\n", median_b);

std::printf(" absolute ceiling on (a) = %.3f ns/call\n",

kAbsoluteGateNsCeiling);

std::printf(" relative ceiling on (b) = %.3f ns/call "

"(%.1f x %.3f + %.1f floor)\n",

relative_gate_ns, kRelativeGateFactor, hook_baseline_ns,

kRelativeGateNoiseFloorNs);

int rc = 0;

// Absolute sanity bound on (a): catches a baseline blow-up.

if (median_a > kAbsoluteGateNsCeiling) {

std::printf("FAIL: (a) gate-load median %.3f ns exceeds absolute "

"ceiling %.3f ns -- the baseline gate load regressed\n",

median_a, kAbsoluteGateNsCeiling);

rc = 1;

}

// Relative gate on (b): registering a hook must not blow up the gate

// microcost.

if (median_b > relative_gate_ns) {

std::printf("FAIL: (b) gate-load median %.3f ns exceeds 2x "

"HOOK_BASELINE_NS (= %.3f ns) -- the zero-cost-when-unused "

"claim is at risk\n",

median_b, relative_gate_ns);

rc = 1;

}

if (rc == 0) {

std::printf("PASS: (a) within absolute ceiling and (b) within "

"2x HOOK_BASELINE_NS\n");

}

return rc;