Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

2.7 KB
Raw Blame
import assert from 'node:assert/strict'
import { execFileSync } from 'node:child_process'
import { readFileSync } from 'node:fs'
import { dirname, resolve } from 'node:path'
import { performance } from 'node:perf_hooks'
import { build } from 'esbuild'
import { buildCounterbalancedSchedule } from './counterbalanced-benchmark-schedule.mjs'

const baseline = process.argv[2] ?? '20ab9950654'
const file = 'mobile/src/transport/connection-log-buffer.ts'
async function load(contents) {
  const result = await build({
    stdin: { contents, loader: 'ts', resolveDir: dirname(resolve(file)) },
    bundle: true,
    platform: 'node',
    format: 'esm',
    write: false,
    tsconfigRaw: {}
  })
  return import(
    `data:text/javascript;base64,${Buffer.from(result.outputFiles[0].text).toString('base64')}`
  )
}
const before = await load(
  execFileSync('git', ['show', `${baseline}:${file}`], { encoding: 'utf8' })
)
const after = await load(readFileSync(file, 'utf8'))
const drain = () => new Promise((resolve) => setImmediate(resolve))
async function run(module, count, startup) {
  let calls = 0
  let bytes = 0
  let stored = ''
  const store = module.createConnectionLogStore(200, {
    load: async () => [],
    save: async (_host, snapshot) => {
      stored = JSON.stringify(snapshot)
      calls++
      bytes += Buffer.byteLength(stored)
    }
  })
  if (!startup) {
    await store.hydrate('a')
    await drain()
    calls = 0
    bytes = 0
  }
  const start = performance.now()
  for (let i = 0; i < count; i++) {
    store.append('a', { id: `${i}`, ts: i, level: 'info', message: `connection event ${i}` })
  }
  await drain()
  return { ms: performance.now() - start, calls, bytes, stored }
}
const results = []
for (const count of [1, 25, 200, 1000]) {
  for (const startup of [false, true]) {
    const arms = { before, after }
    const initialBefore = await run(before, count, startup)
    const initialAfter = await run(after, count, startup)
    assert.equal(initialAfter.stored, initialBefore.stored)
    const samples = { before: [], after: [] }
    for (const pair of buildCounterbalancedSchedule(10, 'before', 'after')) {
      for (const arm of pair) {
        samples[arm].push((await run(arms[arm], count, startup)).ms)
      }
    }
    const median = (values) => {
      const sorted = [...values].sort((a, b) => a - b)
      return (sorted[4] + sorted[5]) / 2
    }
    results.push({
      count,
      startup,
      before: {
        calls: initialBefore.calls,
        bytes: initialBefore.bytes,
        ms: median(samples.before)
      },
      after: { calls: initialAfter.calls, bytes: initialAfter.bytes, ms: median(samples.after) }
    })
  }
}
console.log(
  JSON.stringify({ baseline, node: process.version, platform: process.platform, results }, null, 2)
)