// Measures roundtrip channel throughput (main → worker → main) with
// 1 up to availableParallelism() workers. The worker is a passthrough
// streaming moroutine that yields each item back unchanged.
// Requires Node v24+.
//
// Run: node examples/benchmark/main.ts

import { availableParallelism } from 'node:os';
import { workers, channel } from '../../src/index.ts';
import { passthrough } from './work.ts';

const ITEMS = 100_000;
const MAX_WORKERS = availableParallelism();

async function bench(numWorkers: number): Promise<number> {
  async function* source() {
    for (let i = 0; i < ITEMS; i++) yield i;
  }

  const data = channel(source());

  using run = workers(numWorkers);
  const tasks = Array.from({ length: numWorkers }, () => passthrough(data));
  const streams = tasks.map((t) => run(t));

  const start = performance.now();
  let count = 0;
  await Promise.all(
    streams.map(async (s) => {
      for await (const _ of s) count++;
    }),
  );
  const elapsed = performance.now() - start;

  return count / (elapsed / 1000);
}

console.log(`Roundtrip throughput: ${ITEMS.toLocaleString()} items, 1–${MAX_WORKERS} workers\n`);

for (let n = 1; n <= MAX_WORKERS; n++) {
  const ips = await bench(n);
  const bar = '#'.repeat(Math.round(ips / 1000));
  console.log(
    `  ${String(n).padStart(2)} worker${n === 1 ? ' ' : 's'}  ${Math.round(ips).toLocaleString().padStart(8)} items/s  ${bar}`,
  );
}