chadtmiller.com/monolith
An atproto PDS
0
0
// The benchmark's client (bench.mjs): requests sent from worker threads, so
// that what a server answers is not held to what one Node thread can send
// and read. Each thread has its own connections, kept alive.
//
// const pool = await openPool(4)
// const { times, statuses, bodies, total, firstError } = await pool.run(requests, at, { keep })
// await pool.close()
//
// A request is { method, url, headers, body } (body a string or bytes).
// `at` requests are in flight at once, spread over the threads; a thread
// sends its next as an answer comes, as many people each waiting on their
// own would. Each time is from sending a request to having its answer whole,
// in ms; a request that could not be sent has status 0. With `keep`, each
// answer's body comes back as text; without, only those of answers that are
// no 2xx.
//
// A server that closes each connection after its answer has the client open
// a connection a request, and each one closed holds its local port for a
// while (TIME_WAIT): at a few hundred a second the client's ports run out.
// Then the request waits for one and is sent again, timed from when it is
// sent; each such wait is counted (`portWaits`), and the table marks it.
import { Worker, isMainThread, parentPort } from 'node:worker_threads'
const ok2xx = (s) => s >= 200 && s < 300
// A request not answered in this long is given up, as status 0: a server
// that stalls stops the run with that, rather than hanging it.
export const TIMEOUT_MS = 120000
const PORT_WAIT_MS = 50
const PORT_WAITS_MAX = 1200
/// One request: its time, status and body, and how many times it waited
/// for a local port. Anything else that keeps it from being sent throws.
export async function timedFetch({ method, url, headers, body }) {
for (let waits = 0; ; waits++) {
const t = performance.now()
try {
const r = await fetch(url, { method, headers, body, signal: AbortSignal.timeout(TIMEOUT_MS) })
const buf = Buffer.from(await r.arrayBuffer())
return { ms: performance.now() - t, status: r.status, buf, waits }
} catch (e) {
if (!/EADDRNOTAVAIL/.test(String(e?.cause?.code ?? e?.cause?.message ?? e)) || waits === PORT_WAITS_MAX) throw e
await new Promise((ok) => setTimeout(ok, PORT_WAIT_MS))
}
}
}
if (!isMainThread && parentPort) {
parentPort.on('message', async ({ id, requests, at, keep }) => {
const times = new Float64Array(requests.length)
const statuses = new Uint16Array(requests.length)
const bodies = new Array(requests.length)
let portWaits = 0
let next = 0
await Promise.all(Array.from({ length: at }, async () => {
while (next < requests.length) {
const i = next++
const t = performance.now()
try {
const r = await timedFetch(requests[i])
times[i] = r.ms
statuses[i] = r.status
portWaits += r.waits
if (keep || !ok2xx(r.status)) bodies[i] = r.buf.toString('utf8')
} catch (e) {
times[i] = performance.now() - t
bodies[i] = String(e?.cause?.message ?? e?.message ?? e)
}
}
}))
parentPort.postMessage({ id, times, statuses, bodies, portWaits })
})
}
/// A pool of `threads` worker threads to send requests from.
export async function openPool(threads) {
const workers = await Promise.all(Array.from({ length: threads }, () => new Promise((ok, fail) => {
const w = new Worker(new URL(import.meta.url))
w.once('online', () => ok(w))
w.once('error', fail)
})))
let ids = 0
return {
threads,
/// `requests`, `at` at once: each one's time, status and body (above),
/// in the order given; how long they took together; how many times a
/// request waited for a local port; and the first answer that is no
/// 2xx, if any, as `firstError` ({ i, status, body }).
async run(requests, at, { keep = false } = {}) {
const active = Math.max(1, Math.min(threads, at, requests.length))
// Request i goes to thread i % active, and thread k sends its share
// of `at` at once.
const shares = Array.from({ length: active }, (_, k) => ({ k, idx: [], at: Math.floor(at / active) + (k < at % active ? 1 : 0) }))
requests.forEach((_, i) => shares[i % active].idx.push(i))
const times = new Float64Array(requests.length)
const statuses = new Uint16Array(requests.length)
const bodies = new Array(requests.length)
let portWaits = 0
const t = performance.now()
await Promise.all(shares.map(({ k, idx, at: a }) => new Promise((ok, fail) => {
const id = ++ids
const w = workers[k]
const on = (m) => {
if (m.id !== id) return
w.off('message', on)
w.off('error', fail)
idx.forEach((i, j) => {
times[i] = m.times[j]
statuses[i] = m.statuses[j]
if (m.bodies[j] !== undefined) bodies[i] = m.bodies[j]
})
portWaits += m.portWaits
ok()
}
w.on('message', on)
w.once('error', fail)
w.postMessage({ id, requests: idx.map((i) => requests[i]), at: a, keep })
})))
const total = performance.now() - t
const i = statuses.findIndex((s) => !ok2xx(s))
return { times, statuses, bodies, total, portWaits, firstError: i === -1 ? undefined : { i, status: statuses[i], body: (bodies[i] ?? '').slice(0, 300) } }
},
async close() {
await Promise.all(workers.map((w) => w.terminate()))
},
}
}