In `@ctx_test.go`:
- Around line 8511-8544: Benchmarks like Benchmark_Ctx_Accepts_Parallel and
Benchmark_Ctx_AcceptsCharsets_Parallel currently share a single *DefaultCtx /
*fasthttp.RequestCtx and a shared result variable across goroutines, causing
data races; fix by acquiring a fresh ctx per goroutine (inside the RunParallel
loop or per worker) using app.AcquireCtx or acquireDefaultCtxForBenchmark, keep
result variables (e.g., res) local to the goroutine, call c.Accepts /
c.AcceptsCharsets on that per-goroutine ctx, and release it after use (e.g.,
app.ReleaseCtx(c) or the appropriate teardown) so no shared mutable ctx/state is
accessed concurrently.

In `@router_test.go`:
- Around line 2187-2202: Benchmark_Route_Match_Parallel currently shares the
mutable variables match and params across goroutines causing data races; fix by
making match and params local to each worker inside the b.RunParallel closure
(e.g., declare local vars like matchLocal and paramsLocal inside the pb loop and
call route.match with &paramsLocal), then after the parallel section perform a
single non-parallel invocation to assert correctness using parsed.params (or run
one sequential check using route.match and a fresh params slice) so benchmarks
remain race-free; apply the same change to the other two similar benchmarks that
use params/match.
- Around line 2018-2028: Benchmark_App_RebuildTree_Parallel races because it
mutates shared App state (app.routesRefreshed and app.RebuildTree) concurrently;
either create a fresh App per parallel worker inside b.RunParallel (instantiate
New() and registerDummyRoutes for each goroutine) or serialize access by
protecting the mutation and call to RebuildTree with a sync.Mutex around the
critical section (use a package-local mutex referenced in the benchmark),
ensuring Benchmark_App_RebuildTree_Parallel no longer mutates the same App
concurrently.
- Around line 2149-2168: Benchmark_Router_Next_Parallel currently shares a
single DefaultCtx (c) and result vars across goroutines; move the context
acquisition into the RunParallel closure by calling
acquireDefaultCtxForRouterBenchmark(b, app, request) (or creating a fresh
RequestCtx/Request) inside the b.RunParallel func so each goroutine gets its own
DefaultCtx, make res and err local to the goroutine, and then after
b.RunParallel perform a single non-parallel check (create one DefaultCtx and
call app.next) to assert require.NoError and require.True and verify
c.indexRoute equals 4.
- Around line 2031-2050: The benchmark reuses a single fasthttp.RequestCtx
across goroutines in Benchmark_App_MethodNotAllowed_Parallel (and the other
listed benchmarks), causing data races; change each benchmark to allocate and
initialize a new *fasthttp.RequestCtx inside the b.RunParallel loop (or inside
the pb.Next iteration) rather than reusing the shared c variable — follow the
same per-iteration allocation/initialization pattern used in
Benchmark_Router_Next_Default_Parallel so each parallel worker constructs its
own RequestCtx, sets method and URI, and then calls appHandler(c).
- Around line 2287-2307: Benchmark_Router_GitHub_API_Parallel has a data race
because c, match, and err are shared across goroutines; move the
fasthttp.RequestCtx variable c and the locals match and err inside the
b.RunParallel closure so each goroutine gets its own instances, set the request
method and URI inside the closure before calling
acquireDefaultCtxForRouterBenchmark, call app.next and app.ReleaseCtx with those
goroutine-local vars, and remove the require.NoError and require.True assertions
at the end of the benchmark since parallel benchmark iterations shouldn't
perform correctness checks; refer to symbols
Benchmark_Router_GitHub_API_Parallel, c, match, err,
acquireDefaultCtxForRouterBenchmark, app.next, app.ReleaseCtx, and
routesFixture.TestRoutes to locate where to change.

In `@router_test.go`:
- Around line 2177-2192: The benchmark shares a single fasthttp.RequestCtx
(fctx) across goroutines causing a data race; inside
Benchmark_Router_Next_Default_Immutable_Parallel move creation and setup of the
request context into the b.RunParallel closure (or into the per-goroutine loop)
so each worker uses its own local fasthttp.RequestCtx, e.g. create a local fctx,
set MethodGet and SetRequestURI("/") before calling h(fctx) in the pb.Next loop
to eliminate shared state.
- Around line 2052-2070: Benchmark_Router_NotFound_Parallel is using a single
shared fasthttp.RequestCtx (c) across goroutines causing a data race; move the
RequestCtx creation and request setup inside the b.RunParallel closure so each
goroutine/iteration uses its own local c. Specifically, in
Benchmark_Router_NotFound_Parallel, allocate a new c := &fasthttp.RequestCtx{}
inside the pb loop, set c.Request.Header.SetMethod("DELETE") and
c.URI().SetPath("/this/route/does/not/exist") there, then call appHandler(c);
keep appHandler (from New()/registerDummyRoutes) as-is. Ensure any assertions
that read c.Response are done on per-iteration locals or removed/adjusted so
they don't reference a shared ctx after RunParallel.