public:

hs::http_response render_get(const hs::http_request&) override {

return hs::http_response::string("ok");

}

std::vector<std::string> skip_paths) {

// A no-op auth_handler so the auth surface is engaged.

auto auth = [](const hs::http_request&)

-> std::optional<hs::http_response> { return std::nullopt; };

auto ws = std::make_unique<hs::webserver>(

hs::create_webserver(8080)

.start_method(hs::http::http_utils::INTERNAL_SELECT)

.auth_handler(auth)

.auth_skip_paths(std::move(skip_paths)));

ws->register_path("/api/v1/users/me", std::make_shared<noop_resource>());

// Resource with restricted method set so 405 path exercises

// serialize_allow_methods. Only GET is allowed.

auto restricted = std::make_shared<noop_resource>();

restricted->disallow_all();

restricted->set_allowing(hs::http_method::get, true);

ws->register_path("/api/v1/restricted", restricted);

return ws;

using httpserver::detail::http_request_impl;

using httpserver::detail::arguments_accumulator;

using impl_alloc_t =

std::pmr::polymorphic_allocator<http_request_impl>;

// Backing buffer zeroed once; reused across all inner iterations

// by constructing a fresh monotonic_buffer_resource each call.

alignas(std::max_align_t) std::array<std::byte, 65536> buf{};

// defence-in-depth: ensures the compiler treats buf as potentially

// read by the monotonic_buffer_resource.

do_not_optimize(buf);

return measure_median_ns(

label,

[&]() {

// Fresh monotonic_buffer_resource resets the bump pointer

// to buf.data() without touching the bytes -- cheap.

std::pmr::monotonic_buffer_resource arena(

buf.data(), buf.size(), std::pmr::null_memory_resource());

impl_alloc_t alloc(&arena);

auto* p = alloc.new_object<http_request_impl>(

nullptr, nullptr, alloc);

arguments_accumulator aa;

aa.unescaper = nullptr;

aa.arguments = &p->unescaped_args;

aa.max_args_count = 64;

aa.max_args_bytes = 64 * 128;

http_request_impl::build_request_args(

&aa, MHD_GET_ARGUMENT_KIND, "k", value);

do_not_optimize(p->unescaped_args);

alloc.delete_object(p);

},

OUTER, INNER);

if constexpr (kSanitizerBuild) {

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

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

return 0;

}

// Medians for the six measurements, lifted out of their per-scope

// blocks so the gate at the end of main() can compare each against

// its committed baseline.

double med_canonicalize = 0.0;

double med_skip_auth_nonempty = 0.0;

double med_skip_auth_empty = 0.0;

double med_serialize_allow_405 = 0.0;

double med_build_args_pct2f = 0.0;

double med_build_args_plain = 0.0;

// ----- (1) canonicalize: lookup_v2 on a canonical path. -----

{

auto ws = make_bench_webserver({"/public", "/health"});

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

static const std::string kPath("/api/v1/users/me");

// Warm the cache: subsequent lookups hit the cache tier, so

// canonicalize_lookup_path is what dominates the visible work.

{

auto warm = impl->lookup_v2(hs::http_method::get, kPath);

do_not_optimize(warm);

}

std::printf("bench_warm_path (1): canonicalize "

"(/api/v1/users/me cache-hit)\n");

med_canonicalize = measure_median_ns(

"canonicalize",

[&]() {

auto r = impl->lookup_v2(hs::http_method::get, kPath);

do_not_optimize(r);

},

OUTER, INNER);

}

// ----- (2) should_skip_auth on a non-empty list. -----

{

auto ws = make_bench_webserver({"/public", "/health"});

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

static const std::string kPath("/api/v1/users/me");

std::printf("bench_warm_path (2): should_skip_auth "

"(non-empty skip list)\n");

med_skip_auth_nonempty = measure_median_ns(

"should_skip_auth_nonempty",

[&]() {

bool r = impl->should_skip_auth(kPath);

do_not_optimize(r);

},

OUTER, INNER);

}

// ----- (3) should_skip_auth on an empty list (the common case

// for servers with no auth_handler configured -- but the bench

// still installs an auth_handler so the dispatch surface engages

// it). This is the production-typical case for servers that

// either don't configure skip paths at all, or configure

// auth_skip_paths({}) explicitly. -----

{

auto ws = make_bench_webserver({});

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

static const std::string kPath("/api/v1/users/me");

std::printf("bench_warm_path (3): should_skip_auth "

"(empty skip list)\n");

med_skip_auth_empty = measure_median_ns(

"should_skip_auth_empty",

[&]() {

bool r = impl->should_skip_auth(kPath);

do_not_optimize(r);

},

OUTER, INNER);

}

// ----- (4) serialize_allow_405: cost of building the Allow:

// header value on a 405. Drive serialize_allow_methods directly

// to isolate the format cost without spinning up MHD. -----

{

auto ws = make_bench_webserver({});

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

// Build a fresh resource with a non-trivial mask.

noop_resource r;

r.disallow_all();

r.set_allowing(hs::http_method::get, true);

r.set_allowing(hs::http_method::head, true);

r.set_allowing(hs::http_method::post, true);

std::printf("bench_warm_path (4): serialize_allow_405 "

"(GET, HEAD, POST mask)\n");

med_serialize_allow_405 = measure_median_ns(

"serialize_allow_405",

[&]() {

std::string s = impl->serialize_allow_methods(

r.get_allowed_methods());

do_not_optimize(s);

},

OUTER, INNER_405);

}

// ----- (5) build_request_args with a %2F-containing value,

// one insert per fresh per-request arena. See run_build_args_bench

// above for the shared setup and the reasoning behind it. -----

{

// Long enough to exceed std::string SSO on libc++ and libstdc++.

// Contains "%2F" so the default unescape path does real work.

static const char* kValuePct2f =

"a%2Fbcdefghijklmnopqrstuvwxyz_padding_to_force_heap";

std::printf("bench_warm_path (5): build_request_args "

"(%%2F unescape via arena, fresh impl per call)\n");

med_build_args_pct2f =

run_build_args_bench("build_request_args_pct2f", kValuePct2f);

}

// ----- (6) baseline with no percent-encoded sequences.

// Same fresh-impl-per-call structure as (5) so the timings are

// directly comparable. The median for (5) should land within noise

// of this baseline. -----

{

static const char* kValuePlain =

"abcdefghijklmnopqrstuvwxyz_no_escape_baseline_padding";

std::printf("bench_warm_path (6): build_request_args "

"(no-escape baseline, fresh impl per call)\n");

med_build_args_plain =

run_build_args_bench("build_request_args_plain", kValuePlain);

}

#if !defined(__APPLE__)

// The baselines below for this platform are

// conservative, uncalibrated TODO placeholders (~3x the

// apple-silicon medians, see bench_baseline.hpp) -- surface that in

// the bench output/CI logs so the reduced gating confidence is visible

// even when nobody is reading bench_baseline.hpp's comments.

std::printf("\nNOTE: warm-path baselines on this platform are "

"uncalibrated TODO(TASK-084) placeholders (~3x "

"apple-silicon medians); the regression gate below has "

"reduced confidence until TASK-084 calibrates them.\n");

#endif

// ----- Summary + gates -----

// Each median is compared against its committed per-platform baseline

// (bench_baseline.hpp). A median more than kAllowedRegressionRatio

// (5%) over baseline fails the bench.

//

// Noise floor: for sub-10 ns measurements (e.g. WARM_SHOULD_SKIP_AUTH_EMPTY_NS

// baseline = 2 ns) a pure 5% ratio produces an allowed window of only 0.1 ns,

// which is below steady_clock resolution on many platforms. We add an absolute

// additive floor so the gate ceiling is at least baseline + kAbsoluteNoiseFloorNs

// regardless of the ratio, matching the pattern used in bench_hook_overhead.

constexpr double kAbsoluteNoiseFloorNs = 5.0;

namespace bb = httpserver::bench_baseline;

std::printf("\nbench_warm_path summary (baselines from "

"bench_baseline.hpp, +%.0f%% or +%.0f ns floor allowed):\n",

100.0 * (bb::kAllowedRegressionRatio - 1.0),

kAbsoluteNoiseFloorNs);

int rc = 0;

const auto check = [&](const char* label, double measured,

double baseline) {

// Use the larger of the ratio-based ceiling and the absolute noise

// floor so sub-ns timer quantization cannot false-trip the gate.

const double ratio_ceiling = baseline * bb::kAllowedRegressionRatio;

const double floor_ceiling = baseline + kAbsoluteNoiseFloorNs;

const double allowed = std::max(ratio_ceiling, floor_ceiling);

const double pct = 100.0 * (measured / baseline - 1.0);

std::printf(" %-26s median=%8.3f ns baseline=%8.3f ns %+6.1f%%\n",

label, measured, baseline, pct);

if (measured > allowed) {

std::printf("FAIL: %s median %.3f ns exceeds gate ceiling %.3f ns "

"(baseline*%.2f=%.3f, baseline+%.0fns=%.3f, "

"regression %+.1f%%)\n",

label, measured, allowed,

bb::kAllowedRegressionRatio, ratio_ceiling,

kAbsoluteNoiseFloorNs, floor_ceiling, pct);

rc = 1;

}

};

check("canonicalize", med_canonicalize, bb::WARM_CANONICALIZE_NS);

check("should_skip_auth_nonempty", med_skip_auth_nonempty,

bb::WARM_SHOULD_SKIP_AUTH_NONEMPTY_NS);

check("should_skip_auth_empty", med_skip_auth_empty,

bb::WARM_SHOULD_SKIP_AUTH_EMPTY_NS);

check("serialize_allow_405", med_serialize_allow_405,

bb::WARM_SERIALIZE_ALLOW_405_NS);

check("build_request_args_pct2f", med_build_args_pct2f,

bb::WARM_BUILD_REQUEST_ARGS_PCT2F_NS);

check("build_request_args_plain", med_build_args_plain,

bb::WARM_BUILD_REQUEST_ARGS_PLAIN_NS);

if (rc == 0) {

std::printf("PASS: all warm-path medians within gate "

"(+%.0f%% or +%.0fns floor over baseline)\n",

100.0 * (bb::kAllowedRegressionRatio - 1.0),

kAbsoluteNoiseFloorNs);

}

return rc;