Diffusion Ant (mir/inline-method) Code

ant/tests/hono_dispatch_repro.js
3fa05edd2fe3mir/inline-method

hono_dispatch_repro.js
View Options

			const TOTAL = Number(process.env.TOTAL \|\| 20000);
			const CONCURRENCY = Number(process.env.CONCURRENCY \|\| 64);
			const MODE = process.env.MODE \|\| "composeAwaitNext";

			function nowMs() {
			return performance.now();
			}

			function percentile(sorted, p) {
			if (sorted.length === 0) return 0;
			const index = Math.min(sorted.length - 1, Math.floor(sorted.length * p));
			return sorted[index];
			}

			function makeContext() {
			return {
			finalized: false,
			req: {
			routeIndex: -1
			},
			res: null,
			text(body, status = 200) {
			this.finalized = true;
			this.res = { body, status };
			return this.res;
			}
			};
			}

			function composeLike(middleware, onError, onNotFound) {
			return (context, next) => {
			let index = -1;
			return dispatch(0);

			async function dispatch(i) {
			if (i <= index) {
			throw new Error("next() called multiple times");
			}
			index = i;

			let res;
			let isError = false;
			let handler;

			if (middleware[i]) {
			handler = middleware[i];
			context.req.routeIndex = i;
			} else {
			handler = i === middleware.length && next \|\| void 0;
			}

			if (handler) {
			try {
			res = await handler(context, () => dispatch(i + 1));
			} catch (err) {
			if (err instanceof Error && onError) {
			res = await onError(err, context);
			isError = true;
			} else {
			throw err;
			}
			}
			} else if (context.finalized === false && onNotFound) {
			res = await onNotFound(context);
			}

			if (res && (context.finalized === false \|\| isError)) {
			context.res = res;
			}
			return context;
			}
			};
			}

			function routeSync(c) {
			return c.text("ok");
			}

			function routeResolved(c) {
			return Promise.resolve(c.text("ok"));
			}

			function routeAsync(c) {
			return (async () => c.text("ok"))();
			}

			function middlewareReturnNext(_c, next) {
			return next();
			}

			async function middlewareAwaitNext(_c, next) {
			return await next();
			}

			async function middlewareAwaitResolvedAround(_c, next) {
			await Promise.resolve();
			const out = await next();
			await Promise.resolve();
			return out;
			}

			function makeRunner(mode) {
			switch (mode) {
			case "directSync":
			return async () => routeSync(makeContext());
			case "directResolved":
			return async () => routeResolved(makeContext());
			case "directAsync":
			return async () => routeAsync(makeContext());
			case "composeRouteSync": {
			const app = composeLike([routeSync]);
			return async () => app(makeContext());
			}
			case "composeRouteResolved": {
			const app = composeLike([routeResolved]);
			return async () => app(makeContext());
			}
			case "composeRouteAsync": {
			const app = composeLike([routeAsync]);
			return async () => app(makeContext());
			}
			case "composeReturnNext": {
			const app = composeLike([middlewareReturnNext, routeSync]);
			return async () => app(makeContext());
			}
			case "composeAwaitNext": {
			const app = composeLike([middlewareAwaitNext, routeSync]);
			return async () => app(makeContext());
			}
			case "composeAwaitResolvedAround": {
			const app = composeLike([middlewareAwaitResolvedAround, routeSync]);
			return async () => app(makeContext());
			}
			case "composeReturnNextResolvedRoute": {
			const app = composeLike([middlewareReturnNext, routeResolved]);
			return async () => app(makeContext());
			}
			case "composeAwaitNextResolvedRoute": {
			const app = composeLike([middlewareAwaitNext, routeResolved]);
			return async () => app(makeContext());
			}
			case "composeReturnNextAsyncRoute": {
			const app = composeLike([middlewareReturnNext, routeAsync]);
			return async () => app(makeContext());
			}
			case "composeAwaitNextAsyncRoute": {
			const app = composeLike([middlewareAwaitNext, routeAsync]);
			return async () => app(makeContext());
			}
			default:
			throw new Error(`Unknown MODE: ${mode}`);
			}
			}

			async function main() {
			const runOne = makeRunner(MODE);
			const latencies = new Array(TOTAL);
			let nextIndex = 0;
			let completed = 0;
			const startedAt = nowMs();

			async function worker() {
			for (;;) {
			const index = nextIndex++;
			if (index >= TOTAL) return;

			const opStart = nowMs();
			await runOne();
			latencies[index] = nowMs() - opStart;
			completed++;
			}
			}

			const workers = [];
			for (let i = 0; i < CONCURRENCY; i++) {
			workers.push(worker());
			}
			await Promise.all(workers);

			const elapsedMs = nowMs() - startedAt;
			latencies.sort((a, b) => a - b);

			console.log(`mode=${MODE}`);
			console.log(`total=${TOTAL}`);
			console.log(`concurrency=${CONCURRENCY}`);
			console.log(`elapsed_ms=${elapsedMs.toFixed(3)}`);
			console.log(`avg_ms=${(elapsedMs / TOTAL).toFixed(3)}`);
			console.log(`rps=${(TOTAL / (elapsedMs / 1000)).toFixed(1)}`);
			console.log(`p50_ms=${percentile(latencies, 0.50).toFixed(3)}`);
			console.log(`p95_ms=${percentile(latencies, 0.95).toFixed(3)}`);
			console.log(`p99_ms=${percentile(latencies, 0.99).toFixed(3)}`);
			console.log(`completed=${completed}`);
			}

			main().catch((err) => {
			console.error(err && err.stack ? err.stack : String(err));
			process.exitCode = 1;
			});

Owner Packages

No Owners