orca/tests/tools/benchmarks/startup-time-bench.mjs

#!/usr/bin/env node
/**
 * Orca startup-time benchmark.
 *
 * Launches the built app (out/) against a synthetic userData fixture that
 * mimics a long-lived real profile (tens of thousands of Chromium cache
 * files — the documented pathological case for the win32 startup ACL grant),
 * parses `ORCA_STARTUP_DIAGNOSTICS=1` milestone lines from stderr, and
 * reports per-phase timings across iterations.
 *
 * Usage:
 *   node tests/tools/benchmarks/startup-time-bench.mjs --label baseline
 *     [--iterations 5] [--files 28000] [--fixture-dir <path>]
 *     [--state-profile none|restored-local-tabs] [--session-tabs 200]
 *     [--ssh-unreachable-targets 1]
 *     [--github-repos 3] [--gh-hang-ms 30000]
 *     [--wait-for-event renderer-startup-hydration-done]
 *     [--exe <path-to-packaged-Orca>] [--timeout-ms 240000]
 *
 * Issue #7225 freeze reproduction: `--github-repos N` seeds N git repos with
 * GitHub remotes and no configured username, so repo hydration reaches the
 * `gh` login probe; `--gh-hang-ms` puts a fake `gh` on PATH that hangs like a
 * blackholed api.github.com. The child it spawns survives the probe's timeout
 * kill while holding the inherited stdio pipe — the exact mechanism that
 * turns a 2.5s execSync timeout into a minutes-long main-thread stall.
 *
 * Prereq (when not using --exe): `pnpm build:electron-vite` so out/ exists.
 * Results: tests/tools/benchmarks/results/startup-<label>-<timestamp>.json
 */
import { spawn, spawnSync } from 'node:child_process'
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
import { createRequire } from 'node:module'
import os from 'node:os'
import { delimiter, join, resolve } from 'node:path'
import { writePersistedStateFixture } from './startup-bench-state-fixture.mjs'

const scriptDir = import.meta.dirname
const repoRoot = resolve(scriptDir, '..', '..', '..')
const require = createRequire(import.meta.url)

function parseArgs(argv) {
  const args = {
    label: 'run',
    iterations: 5,
    files: 28000,
    fixtureDir: null,
    exe: null,
    timeoutMs: 240000,
    stateProfile: 'none',
    sessionTabs: 0,
    // Seed TEST-NET-3 targets connected at shutdown so startup attempts reconnect, modeling one unreachable host delaying local terminals.
    sshUnreachableTargets: 0,
    githubRepos: 0,
    ghHangMs: 0,
    waitForEvent: 'did-finish-load',
    // Linger after did-finish-load to capture trailing/background milestones such as async Windows ACL work.
    lingerMs: 500
  }
  for (let i = 2; i < argv.length; i++) {
    const next = () => argv[++i]
    switch (argv[i]) {
      case '--label':
        args.label = next()
        break
      case '--iterations':
        args.iterations = Number(next())
        break
      case '--files':
        args.files = Number(next())
        break
      case '--fixture-dir':
        args.fixtureDir = next()
        break
      case '--exe':
        args.exe = next()
        break
      case '--timeout-ms':
        args.timeoutMs = Number(next())
        break
      case '--state-profile':
        args.stateProfile = next()
        break
      case '--session-tabs':
        args.sessionTabs = Number(next())
        break
      case '--ssh-unreachable-targets':
        args.sshUnreachableTargets = Number(next())
        break
      case '--github-repos':
        args.githubRepos = Number(next())
        break
      case '--gh-hang-ms':
        args.ghHangMs = Number(next())
        break
      case '--wait-for-event':
        args.waitForEvent = next()
        break
      case '--linger-ms':
        args.lingerMs = Number(next())
        break
      default:
        throw new Error(`Unknown argument: ${argv[i]}`)
    }
  }
  return args
}

// Seed tiny Chromium/Orca cache files; count/tree shape drives icacls walk cost, contents do not.
function ensureFixture(fixtureDir, options) {
  const { fileCount, stateProfile, sessionTabs, githubRepos, sshUnreachableTargets } = options
  const manifestPath = join(fixtureDir, 'bench-fixture-manifest.json')
  if (existsSync(manifestPath)) {
    try {
      const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'))
      if (
        manifest.files === fileCount &&
        manifest.stateProfile === stateProfile &&
        manifest.sessionTabs === sessionTabs &&
        (manifest.githubRepos ?? 0) === githubRepos &&
        (manifest.sshUnreachableTargets ?? 0) === sshUnreachableTargets
      ) {
        console.log(`[fixture] reusing ${fixtureDir} (${fileCount} files, state=${stateProfile})`)
        return
      }
    } catch {
      // fall through and rebuild
    }
  }
  console.log(`[fixture] creating ${fixtureDir} with ~${fileCount} synthetic files…`)
  const buckets = [
    ['Cache', 'Cache_Data'],
    ['Code Cache', 'js'],
    ['Code Cache', 'wasm'],
    ['GPUCache'],
    ['DawnGraphiteCache'],
    ['blob_storage', 'blobs'],
    ['Service Worker', 'CacheStorage'],
    ['terminal-scrollback-snapshots']
  ]
  const payload = 'x'.repeat(1024)
  let written = 0
  const started = Date.now()
  for (let b = 0; written < fileCount; b = (b + 1) % buckets.length) {
    const dir = join(fixtureDir, ...buckets[b], `g${Math.floor(written / 512)}`)
    mkdirSync(dir, { recursive: true })
    const batch = Math.min(512, fileCount - written)
    for (let i = 0; i < batch; i++) {
      writeFileSync(join(dir, `f_${String(written + i).padStart(6, '0')}`), payload)
    }
    written += batch
  }
  const persistedStateBytes = writePersistedStateFixture(fixtureDir, {
    stateProfile,
    sessionTabs,
    githubRepos,
    sshUnreachableTargets
  })
  writeFileSync(
    manifestPath,
    JSON.stringify({
      files: fileCount,
      stateProfile,
      sessionTabs,
      githubRepos,
      sshUnreachableTargets,
      persistedStateBytes,
      createdAt: Date.now()
    })
  )
  console.log(`[fixture] done in ${((Date.now() - started) / 1000).toFixed(1)}s`)
}

// Hang fake gh in a child holding inherited stdio, reproducing blackholed API children outliving the parent’s execSync timeout.
function writeGhShim(fixtureDir, ghHangMs) {
  if (!ghHangMs) {
    return null
  }
  const shimDir = join(fixtureDir, 'gh-shim')
  mkdirSync(shimDir, { recursive: true })
  const hangSeconds = Math.max(1, Math.ceil(ghHangMs / 1000))
  if (process.platform === 'win32') {
    // ping -n K waits K-1 seconds between K probes of localhost.
    writeFileSync(
      join(shimDir, 'gh.cmd'),
      `@echo off\r\nping -n ${hangSeconds + 1} 127.0.0.1\r\nexit /b 1\r\n`
    )
  } else {
    const shimPath = join(shimDir, 'gh')
    writeFileSync(shimPath, `#!/bin/sh\nsleep ${hangSeconds}\nexit 1\n`)
    spawnSync('chmod', ['+x', shimPath], { stdio: 'ignore' })
  }
  return shimDir
}

function buildLaunchEnvironment({ fixtureDir, githubRepos, ghShimDir }) {
  // Isolate Codex home and rollout migration work inside the fixture to keep timings/profile effects controlled.
  const isolatedHome = join(fixtureDir, 'home')
  mkdirSync(isolatedHome, { recursive: true })
  const env = {
    ...process.env,
    ORCA_STARTUP_DIAGNOSTICS: '1',
    ORCA_E2E_USER_DATA_DIR: fixtureDir,
    HOME: isolatedHome,
    USERPROFILE: isolatedHome,
    ORCA_E2E_HOME_DIR: isolatedHome,
    ORCA_E2E_HEADLESS: '1'
  }
  delete env.CODEX_HOME
  delete env.ORCA_CODEX_HOME
  if (ghShimDir) {
    env.PATH = `${ghShimDir}${delimiter}${env.PATH ?? ''}`
  }
  if (githubRepos > 0) {
    // Keep the developer's real github.user/user.username out of the run so
    // repo hydration deterministically falls through to the gh probe.
    const emptyGitConfig = join(fixtureDir, 'bench-empty-gitconfig')
    if (!existsSync(emptyGitConfig)) {
      writeFileSync(emptyGitConfig, '')
    }
    env.GIT_CONFIG_GLOBAL = emptyGitConfig
    env.GIT_CONFIG_NOSYSTEM = '1'
  }
  return env
}

function killProcessTree(proc) {
  if (process.platform === 'win32') {
    if (proc.exitCode === null && proc.signalCode === null) {
      spawnSync('taskkill', ['/PID', String(proc.pid), '/T', '/F'], { stdio: 'ignore' })
    }
    return
  }
  // Kill the detached launcher group: surviving Electron helpers retain stderr and prevent EOF/harness exit.
  try {
    process.kill(-proc.pid, 'SIGKILL')
  } catch {
    try {
      proc.kill('SIGKILL')
    } catch {
      // already gone
    }
  }
}

function parseStartupLine(line) {
  const match = /^\[startup\] (\S+)(.*)$/.exec(line)
  if (!match) {
    return null
  }
  const details = {}
  const detailText = match[2].trim()
  if (detailText) {
    for (const pair of detailText.match(/(\S+?)=("[^"]*"|\S+)/g) ?? []) {
      const eq = pair.indexOf('=')
      const key = pair.slice(0, eq)
      let value = pair.slice(eq + 1)
      try {
        value = JSON.parse(value)
      } catch {
        // keep raw string
      }
      details[key] = value
    }
  }
  return { event: match[1], details }
}

function runIteration({ exe, timeoutMs, lingerMs, waitForEvent, launchEnv }) {
  return new Promise((resolvePromise) => {
    // Resolve electron package’s platform executable; hardcoded electron.exe breaks macOS/Linux.
    const command = exe ?? require('electron')
    const commandArgs = exe ? [] : [repoRoot]
    const events = []
    const startedAt = process.hrtime.bigint()
    const child = spawn(command, commandArgs, {
      env: launchEnv,
      stdio: ['ignore', 'ignore', 'pipe'],
      // Own a process group so teardown can reap all Electron helpers.
      detached: process.platform !== 'win32'
    })
    let finished = false
    let buffer = ''
    const finish = (outcome) => {
      if (finished) {
        return
      }
      finished = true
      clearTimeout(timer)
      // Linger for trailing diagnostics/background work, including async ACL grant.
      setTimeout(() => {
        killProcessTree(child)
        resolvePromise({ outcome, events })
      }, lingerMs)
    }
    const timer = setTimeout(() => finish('timeout'), timeoutMs)
    child.stderr.setEncoding('utf-8')
    child.stderr.on('data', (chunk) => {
      buffer += chunk
      let newlineIndex = buffer.indexOf('\n')
      while (newlineIndex !== -1) {
        const line = buffer.slice(0, newlineIndex).trimEnd()
        buffer = buffer.slice(newlineIndex + 1)
        newlineIndex = buffer.indexOf('\n')
        const parsed = parseStartupLine(line)
        if (!parsed) {
          continue
        }
        const harnessMs = Number(process.hrtime.bigint() - startedAt) / 1e6
        events.push({ ...parsed, harnessMs: Math.round(harnessMs * 10) / 10 })
        if (parsed.event === waitForEvent) {
          finish('ok')
        }
      }
    })
    child.on('exit', () => finish('early-exit'))
    child.on('error', () => finish('spawn-error'))
  })
}

function eventTime(events, name, key) {
  const entry = events.find((event) => event.event === name)
  if (!entry) {
    return null
  }
  return key === 't'
    ? typeof entry.details.t === 'number'
      ? entry.details.t
      : null
    : entry.harnessMs
}

function derivePhases(events) {
  const aclStart = eventTime(events, 'acl-grant-start', 't')
  const aclDone = eventTime(events, 'acl-grant-done', 't')
  return {
    startupJsonParseMs: delta(
      events,
      'persistence-json-parse-start',
      'persistence-json-parse-done'
    ),
    startupStoreLoadMs: delta(events, 'persistence-load-start', 'persistence-load-done'),
    spawnToAppReady: eventTime(events, 'app-ready', 'harness'),
    appReadyToServices: delta(events, 'app-ready', 'services-initialized'),
    servicesToI18n: delta(events, 'services-initialized', 'i18n-ready'),
    i18nToOpenWindow: delta(events, 'i18n-ready', 'open-main-window-start'),
    daemonInitMs: delta(events, 'daemon-init-start', 'daemon-init-done'),
    aclGrantMs: aclStart !== null && aclDone !== null ? aclDone - aclStart : null,
    windowCreatedToLoadStart: delta(events, 'window-created', 'load-start'),
    windowCreatedToLoaded: delta(events, 'window-created', 'did-finish-load'),
    totalToWindowCreated: eventTime(events, 'window-created', 'harness'),
    totalToDidFinishLoad: eventTime(events, 'did-finish-load', 'harness'),
    didFinishLoadToWorkspaceReady: delta(
      events,
      'did-finish-load',
      'renderer-startup-hydration-done'
    ),
    totalToWorkspaceReady: eventTime(events, 'renderer-startup-hydration-done', 'harness'),
    // Measure terminal restoration’s SSH reconnect and former main hydration barrier.
    rendererSshReconnectMs: eventDetailsNumber(events, 'renderer-ssh-reconnect-done', 'durationMs'),
    rendererStartupBarrierMs:
      eventDetailsNumber(events, 'renderer-git-environment-barrier-await-done', 'durationMs') ??
      eventDetailsNumber(events, 'renderer-first-window-services-await-done', 'durationMs'),
    rendererReconnectTerminalsMs:
      eventDetailsNumber(events, 'renderer-reconnect-terminals-done', 'durationMs') ??
      delta(
        events,
        'renderer-first-window-services-await-done',
        'renderer-reconnect-terminals-done'
      ),
    // Record worst event-loop stall as the direct #7225 freeze measurement.
    maxEventLoopStallMs: maxEventDetailsNumber(events, 'event-loop-stall', 'maxGapMs')
  }
}

function maxEventDetailsNumber(events, name, key) {
  let max = null
  for (const event of events) {
    if (event.event !== name) {
      continue
    }
    const value = event.details[key]
    if (typeof value === 'number' && (max === null || value > max)) {
      max = value
    }
  }
  return max
}

function eventDetailsNumber(events, name, key) {
  const value = events.find((event) => event.event === name)?.details[key]
  return typeof value === 'number' ? value : null
}

function delta(events, from, to) {
  const a = eventTime(events, from, 't')
  const b = eventTime(events, to, 't')
  return a !== null && b !== null ? b - a : null
}

function median(values) {
  const usable = values.filter((value) => typeof value === 'number').sort((a, b) => a - b)
  if (usable.length === 0) {
    return null
  }
  const mid = Math.floor(usable.length / 2)
  return usable.length % 2 ? usable[mid] : (usable[mid - 1] + usable[mid]) / 2
}

// Results are committed as PR evidence — keep home-anchored paths out of them.
function sanitizeLocalPath(value) {
  if (typeof value !== 'string') {
    return value
  }
  const home = os.homedir()
  return value.startsWith(home) ? `~${value.slice(home.length)}` : value
}

function formatMs(value) {
  if (value === null) {
    return 'n/a'
  }
  return value >= 1000 ? `${(value / 1000).toFixed(2)}s` : `${Math.round(value)}ms`
}

async function main() {
  const args = parseArgs(process.argv)
  if (!['none', 'restored-local-tabs'].includes(args.stateProfile)) {
    throw new Error(`Unknown state profile: ${args.stateProfile}`)
  }
  const fixtureDir = resolve(
    args.fixtureDir ??
      join(
        os.tmpdir(),
        'orca-startup-bench',
        `userdata-${args.files}-${args.stateProfile}-${args.sessionTabs}-gh${args.githubRepos}-ssh${args.sshUnreachableTargets}`
      )
  )
  mkdirSync(fixtureDir, { recursive: true })
  ensureFixture(fixtureDir, {
    fileCount: args.files,
    stateProfile: args.stateProfile,
    sessionTabs: args.sessionTabs,
    githubRepos: args.githubRepos,
    sshUnreachableTargets: args.sshUnreachableTargets
  })
  const ghShimDir = writeGhShim(fixtureDir, args.ghHangMs)
  const launchEnv = buildLaunchEnvironment({
    fixtureDir,
    githubRepos: args.githubRepos,
    ghShimDir
  })

  if (!args.exe && !existsSync(join(repoRoot, 'out', 'main', 'index.js'))) {
    throw new Error('out/main/index.js missing — run `pnpm build:electron-vite` first')
  }

  const iterations = []
  for (let i = 0; i < args.iterations; i++) {
    process.stdout.write(`[bench] iteration ${i + 1}/${args.iterations}… `)
    const result = await runIteration({
      exe: args.exe,
      timeoutMs: args.timeoutMs,
      lingerMs: args.lingerMs,
      waitForEvent: args.waitForEvent,
      launchEnv
    })
    const phases = derivePhases(result.events)
    iterations.push({ ...result, phases })
    console.log(
      `${result.outcome} total=${formatMs(phases.totalToDidFinishLoad)} acl=${formatMs(phases.aclGrantMs)} maxStall=${formatMs(phases.maxEventLoopStallMs)}`
    )
    // Let the OS settle between launches (process teardown, file handles).
    await new Promise((resolveSleep) => setTimeout(resolveSleep, 1500))
  }

  const phaseNames = Object.keys(iterations[0]?.phases ?? {})
  const summary = {}
  for (const name of phaseNames) {
    summary[name] = median(iterations.map((iteration) => iteration.phases[name]))
  }

  const resultsDir = join(scriptDir, 'results')
  mkdirSync(resultsDir, { recursive: true })
  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
  const outPath = join(resultsDir, `startup-${args.label}-${stamp}.json`)
  writeFileSync(
    outPath,
    JSON.stringify(
      {
        label: args.label,
        platform: process.platform,
        arch: process.arch,
        cpus: os.cpus()[0]?.model,
        fixtureDir: sanitizeLocalPath(fixtureDir),
        fixtureFiles: args.files,
        stateProfile: args.stateProfile,
        sessionTabs: args.sessionTabs,
        githubRepos: args.githubRepos,
        ghHangMs: args.ghHangMs,
        waitForEvent: args.waitForEvent,
        exe: sanitizeLocalPath(args.exe),
        iterations,
        summaryMedianMs: summary
      },
      null,
      2
    )
  )

  console.log(`\n[bench] label=${args.label} (medians over ${iterations.length} runs)`)
  console.log('| phase | median |')
  console.log('|---|---|')
  for (const name of phaseNames) {
    console.log(`| ${name} | ${formatMs(summary[name])} |`)
  }
  console.log(`\n[bench] results written to ${outPath}`)
}

main().catch((error) => {
  console.error(error)
  process.exit(1)
})