Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

bench-utils.ts

205 lines4.8 KB

1export interface StartRequestHandler {
2 fetch: (request: Request) => Promise<Response> | Response
3}
4​
5export interface RunSsrRequestLoopOptions {
6 seed: number
7 iterations?: number
8}
9​
10export interface RunRequestLoopOptions {
11 seed: number
12 concurrency: number
13 totalRequests: number
14 buildRequest: (random: () => number, index: number) => Request
15 validateResponse?: (response: Response, request: Request) => void
17​
18const requestInit = {
19 method: 'GET',
20 headers: {
21 accept: 'text/html',
22 },
23} satisfies RequestInit
24​
25function createDeterministicRandom(seed: number) {
26 let state = seed >>> 0
27​
28 return () => {
29 state = (state * 1664525 + 1013904223) >>> 0
30 return state / 0x100000000
31 }
33​
34function randomSegment(random: () => number) {
35 return Math.floor(random() * 1_000_000_000).toString(36)
37​
38export { createDeterministicRandom, randomSegment }
39​
40export async function drainResponse(response: Response) {
41 const reader = response.body?.getReader()
42​
43 if (!reader) {
44 return
45 }
46​
47 try {
48 while (true) {
49 const result = await reader.read()
50​
51 if (result.done) {
52 break
53 }
54 }
55 } finally {
56 reader.releaseLock()
57 }
59​
60function randomSearchValue(random: () => number) {
61 return `q-${randomSegment(random)}`
63​
64function randomRequestUrl(random: () => number) {
65 const a = randomSegment(random)
66 const b = randomSegment(random)
67 const c = randomSegment(random)
68 const d = randomSegment(random)
69 const q = randomSearchValue(random)
70​
71 return `http://localhost/${a}/${b}/${c}/${d}?q=${q}`
73​
74export async function runSsrRequestLoop(
75 handler: StartRequestHandler,
76 { seed, iterations = 10 }: RunSsrRequestLoopOptions,
77) {
78 const random = createDeterministicRandom(seed)
79 const pendingBodyReads: Array<Promise<void>> = []
80​
81 for (let index = 0; index < iterations; index++) {
82 const requestUrl = randomRequestUrl(random)
83 const response = await handler.fetch(new Request(requestUrl, requestInit))
84​
85 if (response.status !== 200) {
86 await Promise.allSettled(pendingBodyReads)
87​
88 throw new Error(
89 `Request failed with non-200 status ${response.status} (${requestUrl})`,
90 )
91 }
92​
93 pendingBodyReads.push(drainResponse(response))
94 }
95​
96 await Promise.all(pendingBodyReads)
98​
99export async function runRequestLoop(
100 handler: StartRequestHandler,
101 {
102 seed,
103 concurrency,
104 totalRequests,
105 buildRequest,
106 validateResponse,
107 }: RunRequestLoopOptions,
108) {
109 const requestSequences = buildRequestSequences({
110 seed,
111 concurrency,
112 totalRequests,
113 buildRequest,
114 })
115 const validate =
116 validateResponse ??
117 ((response: Response, request: Request) => {
118 if (response.status !== 200) {
119 throw new Error(
120 `Request failed with non-200 status ${response.status} (${request.url})`,
121 )
122 }
123 })
124​
125 let startWorkers = () => {}
126 const startBarrier = new Promise<void>((resolve) => {
127 startWorkers = resolve
128 })
129​
130 const workers = requestSequences.map(async (requests) => {
131 await startBarrier
132​
133 for (const request of requests) {
134 const response = await handler.fetch(request)
135 let validationFailure: { error: unknown } | undefined
136​
137 try {
138 validate(response, request)
139 } catch (error) {
140 validationFailure = { error }
141 }
142​
143 await drainResponse(response)
144​
145 if (validationFailure) {
146 throw validationFailure.error
147 }
148 }
149 })
150​
151 startWorkers()
152 const results = await Promise.allSettled(workers)
153 const failedWorker = results.find(
154 (result): result is PromiseRejectedResult => result.status === 'rejected',
155 )
156​
157 if (failedWorker) {
158 throw failedWorker.reason
159 }
161​
162export type BuildRequestSequencesOptions = Pick<
163 RunRequestLoopOptions,
164 'seed' | 'concurrency' | 'totalRequests' | 'buildRequest'
166​
167/**
168 * Build the entire seeded workload before any request starts, then partition
169 * it round-robin so completion timing can never change a worker's next input.
170 */
171export function buildRequestSequences({
172 seed,
173 concurrency,
174 totalRequests,
175 buildRequest,
176}: BuildRequestSequencesOptions): Array<Array<Request>> {
177 assertPositiveInteger('concurrency', concurrency)
178 assertPositiveInteger('totalRequests', totalRequests)
179​
180 if (concurrency > totalRequests) {
181 throw new RangeError(
182 `concurrency (${concurrency}) cannot exceed totalRequests (${totalRequests})`,
183 )
184 }
185​
186 const random = createDeterministicRandom(seed)
187 const requestSequences = Array.from(
188 { length: concurrency },
189 () => new Array<Request>(),
190 )
191​
192 for (let index = 0; index < totalRequests; index++) {
193 requestSequences[index % concurrency]!.push(buildRequest(random, index))
194 }
195​
196 return requestSequences
198​
199function assertPositiveInteger(name: string, value: number) {
200 if (!Number.isSafeInteger(value) || value < 1) {
201 throw new RangeError(
202 `${name} must be a positive integer; received ${value}`,
203 )
204 }