perf: parse, chunk and hash documents in a worker thread and add startup and document-parse benchmarks

2026-10-03 13:54:24 +08:00
parent 9d03217f99
commit 10c5162811
15 changed files with 1787 additions and 33 deletions
@@ -0,0 +1,109 @@
+// Document parse benchmark (PERF-15/16, P7). Bundles the production parser
+// client and worker with esbuild, then imports synthetic large documents
+// (hash -> parse -> chunk, as Knowledge import does) twice per round: inline on
+// the main thread, then through the parse worker. Records the main event-loop
+// max block with perf_hooks.monitorEventLoopDelay.
+//
+//   node build/run-document-parse-perf.cjs
+//   GB_DOCPERF_ROUNDS=3 GB_DOCPERF_NODE=1 (skip Electron) GB_DOCPERF_OUTPUT=file.json
+const { buildSync } = require('esbuild')
+const { mkdirSync, rmSync, writeFileSync } = require('node:fs')
+const { join, resolve } = require('node:path')
+const { monitorEventLoopDelay, performance } = require('node:perf_hooks')
+
+const root = resolve(__dirname, '..')
+
+// Measure on the project's Electron (the production runtime), like perf:knowledge.
+if (process.env.GB_DOCPERF_NODE !== '1') {
+  let electron
+  let version
+  try { electron = require('electron'); version = require('electron/package.json').version } catch { electron = undefined }
+  if (typeof electron === 'string' && process.versions.electron !== version) {
+    const { status } = require('node:child_process').spawnSync(electron, [__filename], {
+      stdio: 'inherit', env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' }
+    })
+    process.exit(status ?? 1)
+  }
+}
+
+const rounds = Number(process.env.GB_DOCPERF_ROUNDS || 3)
+// Under node_modules so the external pdfjs-dist resolves from the repository.
+const directory = join(root, 'node_modules', '.cache', `goodbuddy-document-parse-perf-${process.pid}`)
+mkdirSync(directory, { recursive: true })
+const harness = join(directory, 'harness.cjs')
+const workerBundle = join(directory, 'document-parse-worker.cjs')
+const harnessSource = join(directory, 'harness.ts')
+writeFileSync(harnessSource, [
+  `export * from ${JSON.stringify(join(root, 'src/main/document-parse-client.ts'))}`,
+  `export * from ${JSON.stringify(join(root, 'tests/support/document-parse-worker-fixture.ts'))}`
+].join('\n'))
+for (const [entry, outfile] of [[harnessSource, harness], [join(root, 'src/main/document-parse-worker.ts'), workerBundle]]) {
+  buildSync({
+    entryPoints: [entry], bundle: true, platform: 'node', format: 'cjs', target: 'node22',
+    outfile, logLevel: 'error', external: ['pdfjs-dist', 'electron', 'esbuild']
+  })
+}
+const {
+  DocumentParseWorkerClient, chunkDocumentOffMain, parseDocumentOffMain, sha256OffMain,
+  createDocx, createLargePdf, sentenceGenerator
+} = require(harness)
+
+const settings = {
+  version: 1, mode: 'structure', targetCharacters: 1600, overlapCharacters: 100,
+  parentCharacters: 1600, childCharacters: 400, contextualIndexingEnabled: false
+}
+const round = value => Math.round(value * 10) / 10
+
+async function importOnce(name, buffer, client) {
+  await sha256OffMain(buffer, client)
+  const parsed = await parseDocumentOffMain(name, buffer, undefined, client)
+  return (await chunkDocumentOffMain(parsed, settings, client)).length
+}
+
+async function measure(name, buffer, client) {
+  await importOnce(name, buffer, client) // warm modules / worker
+  await new Promise(resolve => setTimeout(resolve, 50))
+  const histogram = monitorEventLoopDelay({ resolution: 5 })
+  histogram.enable()
+  // The histogram only measures from its first timer tick on; a block that
+  // starts before that tick (the inline path is all microtasks) is not seen.
+  await new Promise(resolve => setTimeout(resolve, 30))
+  const started = performance.now()
+  const chunks = await importOnce(name, buffer, client)
+  const wallMs = performance.now() - started
+  await new Promise(resolve => setTimeout(resolve, 20))
+  histogram.disable()
+  return { maxMs: round(histogram.max / 1e6), p99Ms: round(histogram.percentile(99) / 1e6), wallMs: round(wallMs), chunks }
+}
+
+async function main() {
+  console.log(`[docperf] runtime: node ${process.version}${process.versions.electron ? ` (electron ${process.versions.electron})` : ''}`)
+  const sentence = sentenceGenerator(11)
+  const inputs = [
+    { name: 'large.pdf', buffer: createLargePdf(500, 60) },
+    { name: 'large.docx', buffer: createDocx(Array.from({ length: 4000 }, () => sentence(25))) },
+    { name: 'large.md', buffer: Buffer.from(Array.from({ length: 4000 }, (_, index) => `${index % 50 === 0 ? '## Section\n' : ''}${sentence(60)}.`).join('\n')) }
+  ]
+  const client = new DocumentParseWorkerClient(workerBundle)
+  const results = []
+  try {
+    for (const input of inputs) {
+      for (let index = 0; index < rounds; index += 1) {
+        // Alternate inline / worker within each round (P7).
+        const inline = await measure(input.name, input.buffer, undefined)
+        const worker = await measure(input.name, input.buffer, client)
+        if (worker.chunks !== inline.chunks) throw new Error(`chunk count mismatch for ${input.name}`)
+        results.push({ input: input.name, bytes: input.buffer.byteLength, round: index + 1, inline, worker })
+        console.log(`[docperf] ${input.name} round ${index + 1}: Main loop max ${inline.maxMs} -> ${worker.maxMs} ms; wall ${inline.wallMs} / ${worker.wallMs} ms; ${inline.chunks} chunks`)
+      }
+    }
+  } finally {
+    client.close()
+  }
+  const output = process.env.GB_DOCPERF_OUTPUT
+  if (output) writeFileSync(output, JSON.stringify({ kind: 'goodbuddy-document-parse-benchmark', node: process.version, results }, null, 2))
+  console.table(results.map(r => ({ input: r.input, round: r.round, 'loop max inline/worker ms': `${r.inline.maxMs} / ${r.worker.maxMs}`, 'wall inline/worker ms': `${r.inline.wallMs} / ${r.worker.wallMs}` })))
+}
+main().catch(error => { process.exitCode = 1; console.error(error) }).finally(() => {
+  rmSync(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+})