@fairyhunter13/opentui-core 0.1.114 → 0.1.116

package/src/benchmark/native-span-feed-benchmark.ts

@@ -1,596 +0,0 @@
-import { dlopen, FFIType, suffix } from "bun:ffi"
-import { setRenderLibPath } from "../zig.js"
-
-if (!process.env.NATIVE_SPAN_FEED_LIB) {
-  process.env.NATIVE_SPAN_FEED_LIB = "bench"
-}
-const { NativeSpanFeed } = await import("../NativeSpanFeed.ts")
-
-const args = process.argv.slice(2)
-
-function getArg(name: string): string | null {
-  const prefix = `--${name}=`
-  for (const arg of args) {
-    if (arg.startsWith(prefix)) return arg.slice(prefix.length)
-  }
-  return null
-}
-
-function hasFlag(name: string): boolean {
-  return args.includes(`--${name}`)
-}
-
-const totalBytes = BigInt(getArg("bytes") ?? "100000")
-const iterationsArg = getArg("iters")
-const iterations = Number(iterationsArg ?? "1000")
-const commitEvery = Number(getArg("commit") ?? "0")
-const chunkSize = Number(getArg("chunk") ?? String(64 * 1024))
-const initialChunks = Number(getArg("initial") ?? "2")
-const autoArg = getArg("auto")
-const autoCommitOnFull = autoArg ? autoArg !== "0" : true
-const writeStdout = hasFlag("stdout")
-const patternArg = getArg("pattern")
-const patternTypeArg = getArg("pattern-type")
-const patternSizeArg = getArg("pattern-size")
-const reuseStream = hasFlag("reuse")
-const suiteName = getArg("suite")
-const suiteIterations = suiteName === "quick" && iterationsArg === null ? 20000 : iterations
-const memSampleArg = getArg("mem-sample")
-const memEnabled = hasFlag("mem") || memSampleArg !== null
-const memSampleEvery = memSampleArg ? Number(memSampleArg) : 1
-const jsonArg = getArg("json")
-const jsonDefault = suiteName ? `latest-${suiteName}-bench-run.json` : "latest-bench-run.json"
-const jsonPath = jsonArg ?? (hasFlag("json") ? jsonDefault : null)
-
-const libVariant = process.env.NATIVE_SPAN_FEED_LIB
-const libBase = libVariant === "bench" ? "native_span_feed_bench" : (libVariant ?? "native_span_feed")
-const libPath = new URL(`../zig/zig-out/lib/lib${libBase}.${suffix}`, import.meta.url).pathname
-
-setRenderLibPath(libPath)
-
-const benchLib = dlopen(libPath, {
-  benchProduce: {
-    args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.u32],
-    returns: FFIType.i32,
-  },
-  benchProduceWrite: {
-    args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.u32],
-    returns: FFIType.i32,
-  },
-})
-
-const encoder = new TextEncoder()
-
-type PatternSpec =
-  | { type: "ansi"; size?: number }
-  | { type: "ascii"; size?: number }
-  | { type: "binary"; size?: number }
-  | { type: "random"; size?: number }
-  | { type: "string"; value: string; size?: number }
-
-/**
- * Producer API: "reserve" (zero-copy) or "write" (copy).
- */
-type ProducerAPI = "reserve" | "write"
-
-type Scenario = {
-  name: string
-  bytes: bigint
-  iters: number
-  chunkSize: number
-  initialChunks: number
-  autoCommitOnFull: boolean
-  commitEvery: number
-  pattern?: PatternSpec
-  reuseStream: boolean
-  producerAPI: ProducerAPI
-}
-
-type ScenarioResult = {
-  name: string
-  producerAPI: ProducerAPI
-  bytesPerIter: bigint
-  iters: number
-  bytesTotal: bigint
-  avgMs: number
-  medianMs: number
-  p95Ms: number
-  minMs: number
-  maxMs: number
-  throughputMBps: number
-  elapsedMs: number
-  memory?: {
-    start: MemorySample
-    end: MemorySample
-    delta: MemorySample
-    peak: MemorySample
-    samples: number
-  }
-  options: {
-    chunkSize: number
-    initialChunks: number
-    autoCommitOnFull: boolean
-    commitEvery: number
-    reuseStream: boolean
-    pattern?: PatternSpec
-  }
-}
-
-type MemorySample = {
-  rss: number
-  heapTotal: number
-  heapUsed: number
-  external: number
-  arrayBuffers: number
-}
-
-const KB = 1024n
-const MB = 1024n * KB
-const kb = (value: number) => BigInt(value) * KB
-const mb = (value: number) => BigInt(value) * MB
-const patternSizeSmall = 64
-const patternSizeMedium = 1024
-const patternSizeLarge = 32768
-
-function repeatPattern(base: Uint8Array, size: number): Uint8Array {
-  if (size <= base.byteLength) return base.subarray(0, size)
-  const out = new Uint8Array(size)
-  let offset = 0
-  while (offset < size) {
-    const slice = base.subarray(0, Math.min(base.byteLength, size - offset))
-    out.set(slice, offset)
-    offset += slice.byteLength
-  }
-  return out
-}
-
-function buildPattern(spec?: PatternSpec): Uint8Array | null {
-  if (!spec) return null
-  const size = spec.size ?? 0
-  switch (spec.type) {
-    case "ansi": {
-      const base = encoder.encode("\x1b[32mnative-span-feed\x1b[0m\n")
-      return size > 0 ? repeatPattern(base, size) : base
-    }
-    case "ascii": {
-      const base = encoder.encode("native-span-feed\n")
-      return size > 0 ? repeatPattern(base, size) : base
-    }
-    case "string": {
-      const base = encoder.encode(spec.value)
-      return size > 0 ? repeatPattern(base, size) : base
-    }
-    case "binary": {
-      const len = size > 0 ? size : 4096
-      const out = new Uint8Array(len)
-      for (let i = 0; i < len; i += 1) out[i] = i & 0xff
-      return out
-    }
-    case "random": {
-      const len = size > 0 ? size : 4096
-      const out = new Uint8Array(len)
-      crypto.getRandomValues(out)
-      return out
-    }
-  }
-}
-
-function readMemory(): MemorySample {
-  const usage = process.memoryUsage()
-  return {
-    rss: usage.rss ?? 0,
-    heapTotal: usage.heapTotal ?? 0,
-    heapUsed: usage.heapUsed ?? 0,
-    external: usage.external ?? 0,
-    arrayBuffers: usage.arrayBuffers ?? 0,
-  }
-}
-
-function updatePeak(current: MemorySample, peak: MemorySample): void {
-  peak.rss = Math.max(peak.rss, current.rss)
-  peak.heapTotal = Math.max(peak.heapTotal, current.heapTotal)
-  peak.heapUsed = Math.max(peak.heapUsed, current.heapUsed)
-  peak.external = Math.max(peak.external, current.external)
-  peak.arrayBuffers = Math.max(peak.arrayBuffers, current.arrayBuffers)
-}
-
-function diffMemory(start: MemorySample, end: MemorySample): MemorySample {
-  return {
-    rss: end.rss - start.rss,
-    heapTotal: end.heapTotal - start.heapTotal,
-    heapUsed: end.heapUsed - start.heapUsed,
-    external: end.external - start.external,
-    arrayBuffers: end.arrayBuffers - start.arrayBuffers,
-  }
-}
-
-function formatBytes(value: number): string {
-  const mb = value / (1024 * 1024)
-  return `${mb.toFixed(2)}MB`
-}
-
-function createStreamForScenario(
-  scenario: Scenario,
-  onDataBytes: (len: number) => void,
-): ReturnType<typeof NativeSpanFeed.create> {
-  const stream = NativeSpanFeed.create({
-    chunkSize: scenario.chunkSize,
-    initialChunks: scenario.initialChunks,
-    autoCommitOnFull: scenario.autoCommitOnFull,
-  })
-
-  if (writeStdout) {
-    stream.onData((data) => {
-      process.stdout.write(data)
-    })
-  }
-
-  stream.onData((data) => {
-    onDataBytes(data.byteLength)
-  })
-
-  return stream
-}
-
-type BaseScenario = Omit<Scenario, "producerAPI">
-
-function withAPIs(bases: BaseScenario[]): Scenario[] {
-  const out: Scenario[] = []
-  for (const base of bases) {
-    out.push({ ...base, producerAPI: "reserve" })
-    out.push({ ...base, name: `write/${base.name}`, producerAPI: "write" })
-  }
-  return out
-}
-
-function makeScenarios(baseIters: number, reuse: boolean): Scenario[] {
-  const quick: BaseScenario[] = [
-    {
-      name: "ansi_64k",
-      bytes: kb(64),
-      iters: Math.max(20000, baseIters),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ansi", size: patternSizeSmall },
-      reuseStream: reuse,
-    },
-    {
-      name: "ascii_64k",
-      bytes: kb(64),
-      iters: Math.max(20000, baseIters),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeSmall },
-      reuseStream: reuse,
-    },
-    {
-      name: "binary_64k",
-      bytes: kb(64),
-      iters: Math.max(20000, baseIters),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "binary", size: patternSizeSmall },
-      reuseStream: reuse,
-    },
-    {
-      name: "random_64k",
-      bytes: kb(64),
-      iters: Math.max(20000, baseIters),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "random", size: patternSizeSmall },
-      reuseStream: reuse,
-    },
-  ]
-
-  const defaultBase: BaseScenario[] = [
-    ...quick,
-    {
-      name: "medium_1mb",
-      bytes: mb(1),
-      iters: Math.max(500, Math.floor(baseIters / 10)),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeMedium },
-      reuseStream: reuse,
-    },
-    {
-      name: "binary_1mb",
-      bytes: mb(1),
-      iters: Math.max(500, Math.floor(baseIters / 10)),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "binary", size: patternSizeMedium },
-      reuseStream: reuse,
-    },
-    {
-      name: "random_1mb",
-      bytes: mb(1),
-      iters: Math.max(500, Math.floor(baseIters / 10)),
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "random", size: patternSizeMedium },
-      reuseStream: reuse,
-    },
-    {
-      name: "commit_4k",
-      bytes: kb(256),
-      iters: baseIters,
-      chunkSize: 64 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: false,
-      commitEvery: 4096,
-      pattern: { type: "ascii", size: patternSizeMedium },
-      reuseStream: reuse,
-    },
-    {
-      name: "large_32mb",
-      bytes: mb(32),
-      iters: Math.max(100, Math.floor(baseIters / 50)),
-      chunkSize: 1024 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-    {
-      name: "binary_32mb",
-      bytes: mb(32),
-      iters: Math.max(100, Math.floor(baseIters / 50)),
-      chunkSize: 1024 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "binary", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-    {
-      name: "random_32mb",
-      bytes: mb(32),
-      iters: Math.max(100, Math.floor(baseIters / 50)),
-      chunkSize: 1024 * 1024,
-      initialChunks: 2,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "random", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-    {
-      name: "single_chunk_32mb",
-      bytes: mb(32),
-      iters: Math.max(100, Math.floor(baseIters / 100)),
-      chunkSize: 32 * 1024 * 1024,
-      initialChunks: 1,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-    {
-      name: "huge_chunk_8mb",
-      bytes: mb(64),
-      iters: Math.max(100, Math.floor(baseIters / 200)),
-      chunkSize: 8 * 1024 * 1024,
-      initialChunks: 1,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-  ]
-
-  const largeBase: BaseScenario[] = [
-    ...defaultBase,
-    {
-      name: "very_large_128mb",
-      bytes: mb(128),
-      iters: Math.max(100, Math.floor(baseIters / 500)),
-      chunkSize: 8 * 1024 * 1024,
-      initialChunks: 1,
-      autoCommitOnFull: true,
-      commitEvery: 0,
-      pattern: { type: "ascii", size: patternSizeLarge },
-      reuseStream: reuse,
-    },
-  ]
-
-  if (suiteName === "quick") return withAPIs(quick)
-  if (suiteName === "large") return withAPIs(largeBase)
-  if (suiteName === "all") return withAPIs(largeBase)
-  return withAPIs(defaultBase)
-}
-
-function buildPatternSpec(): PatternSpec | undefined {
-  if (patternTypeArg) {
-    const size = patternSizeArg ? Number(patternSizeArg) : undefined
-    if (patternTypeArg === "ansi") return { type: "ansi", size }
-    if (patternTypeArg === "ascii") return { type: "ascii", size }
-    if (patternTypeArg === "binary") return { type: "binary", size }
-    if (patternTypeArg === "random") return { type: "random", size }
-  }
-  if (patternArg) {
-    const size = patternSizeArg ? Number(patternSizeArg) : undefined
-    return { type: "string", value: patternArg, size }
-  }
-  return undefined
-}
-
-function runScenario(scenario: Scenario): ScenarioResult {
-  let received = 0n
-  const memSamples: MemorySample[] = []
-  const memStart = memEnabled ? readMemory() : null
-  const memPeak = memStart ? { ...memStart } : null
-  const onDataBytes = (len: number) => {
-    received += BigInt(len)
-  }
-  let stream: ReturnType<typeof NativeSpanFeed.create> | null = scenario.reuseStream
-    ? createStreamForScenario(scenario, onDataBytes)
-    : null
-  const pattern = buildPattern(scenario.pattern)
-  const patternPtr = pattern ?? null
-  const patternLen = pattern ? BigInt(pattern.byteLength) : 0n
-  const durations: number[] = []
-  let totalElapsed = 0
-
-  for (let i = 0; i < scenario.iters; i += 1) {
-    if (!stream) stream = createStreamForScenario(scenario, onDataBytes)
-    const before = received
-    const start = performance.now()
-    const produceFn =
-      scenario.producerAPI === "write" ? benchLib.symbols.benchProduceWrite : benchLib.symbols.benchProduce
-    const status = produceFn(stream.streamPtr, scenario.bytes, patternPtr, patternLen, scenario.commitEvery)
-    const elapsedMs = performance.now() - start
-    totalElapsed += elapsedMs
-    durations.push(elapsedMs)
-
-    if (status !== 0) {
-      console.error(
-        `${scenario.producerAPI === "write" ? "benchProduceWrite" : "benchProduce"} failed: ${status} scenario=${scenario.name}`,
-      )
-      process.exit(1)
-    }
-
-    const produced = received - before
-    if (produced !== scenario.bytes) {
-      console.error(`unexpected byte count scenario=${scenario.name} got=${produced} expected=${scenario.bytes}`)
-    }
-
-    if (!scenario.reuseStream && stream) {
-      stream.close()
-      stream = null
-    }
-
-    if (memEnabled && memSampleEvery > 0 && i % memSampleEvery === 0) {
-      const sample = readMemory()
-      memSamples.push(sample)
-      if (memPeak) updatePeak(sample, memPeak)
-    }
-  }
-
-  if (stream) stream.close()
-
-  const memEnd = memEnabled ? readMemory() : null
-  if (memEnd && memPeak) updatePeak(memEnd, memPeak)
-
-  const sorted = [...durations].sort((a, b) => a - b)
-  const count = durations.length
-  const avg = count > 0 ? totalElapsed / count : 0
-  const median = count > 0 ? (sorted[Math.floor(count / 2)] ?? 0) : 0
-  const p95 = count > 0 ? (sorted[Math.floor(count * 0.95)] ?? 0) : 0
-  const min = count > 0 ? (sorted[0] ?? 0) : 0
-  const max = count > 0 ? (sorted[count - 1] ?? 0) : 0
-
-  const totalSeconds = totalElapsed / 1000
-  const totalBytesAll = received
-  const totalMb = Number(totalBytesAll) / (1024 * 1024)
-  const mbps = totalSeconds > 0 ? totalMb / totalSeconds : 0
-
-  let memSummary = ""
-  if (memStart && memEnd && memPeak) {
-    const delta = diffMemory(memStart, memEnd)
-    memSummary =
-      ` memDeltaRss=${formatBytes(delta.rss)}` +
-      ` memDeltaHeap=${formatBytes(delta.heapUsed)}` +
-      ` memDeltaExt=${formatBytes(delta.external)}` +
-      ` memDeltaAB=${formatBytes(delta.arrayBuffers)}` +
-      ` memPeakRss=${formatBytes(memPeak.rss)}`
-  }
-
-  console.log(
-    `scenario=${scenario.name} api=${scenario.producerAPI} iters=${scenario.iters} bytesPerIter=${scenario.bytes} bytesTotal=${totalBytesAll} avgMs=${avg.toFixed(3)} medianMs=${median.toFixed(3)} p95Ms=${p95.toFixed(3)} minMs=${min.toFixed(3)} maxMs=${max.toFixed(3)} throughputMBps=${mbps.toFixed(2)}${memSummary}`,
-  )
-
-  return {
-    name: scenario.name,
-    producerAPI: scenario.producerAPI,
-    bytesPerIter: scenario.bytes,
-    iters: scenario.iters,
-    bytesTotal: totalBytesAll,
-    avgMs: Number(avg.toFixed(6)),
-    medianMs: Number(median.toFixed(6)),
-    p95Ms: Number(p95.toFixed(6)),
-    minMs: Number(min.toFixed(6)),
-    maxMs: Number(max.toFixed(6)),
-    throughputMBps: Number(mbps.toFixed(6)),
-    elapsedMs: Number(totalElapsed.toFixed(6)),
-    memory:
-      memStart && memEnd && memPeak
-        ? {
-            start: memStart,
-            end: memEnd,
-            delta: diffMemory(memStart, memEnd),
-            peak: memPeak,
-            samples: memSamples.length,
-          }
-        : undefined,
-    options: {
-      chunkSize: scenario.chunkSize,
-      initialChunks: scenario.initialChunks,
-      autoCommitOnFull: scenario.autoCommitOnFull,
-      commitEvery: scenario.commitEvery,
-      reuseStream: scenario.reuseStream,
-      pattern: scenario.pattern,
-    },
-  }
-}
-
-function createSingleScenario(): Scenario {
-  const apiArg = getArg("api")
-  return {
-    name: "custom",
-    bytes: totalBytes,
-    iters: iterations,
-    chunkSize,
-    initialChunks,
-    autoCommitOnFull,
-    commitEvery,
-    pattern: buildPatternSpec(),
-    reuseStream,
-    producerAPI: apiArg === "write" ? "write" : "reserve",
-  }
-}
-
-const results: ScenarioResult[] = []
-const runId = new Date().toISOString()
-
-if (suiteName) {
-  const scenarios = makeScenarios(suiteIterations, reuseStream)
-  for (const scenario of scenarios) {
-    results.push(runScenario(scenario))
-  }
-} else {
-  results.push(runScenario(createSingleScenario()))
-}
-
-if (jsonPath) {
-  const payload = {
-    runId,
-    suite: suiteName ?? "custom",
-    args: args.slice(),
-    results,
-  }
-  const json = JSON.stringify(
-    payload,
-    (_key, value) => {
-      if (typeof value === "bigint") return value.toString()
-      return value
-    },
-    2,
-  )
-  await Bun.write(jsonPath, json)
-}