orez 0.2.26 → 0.2.29

package/src/bench/proxy-throughput.bench.ts

@@ -1,343 +0,0 @@
-/**
- * benchmark: proxy throughput
- *
- * measures raw query throughput through the TCP proxy pipeline:
- *   TCP socket → main thread proxy → worker thread → PGlite WASM → back
- *
- * tests both serial and concurrent query patterns to expose
- * single-thread bottlenecks and mutex contention.
- *
- * run: bun src/bench/proxy-throughput.bench.ts
- */
-
-import { createConnection, type Socket } from 'node:net'
-
-import { startZeroLite } from '../index.js'
-
-import type { PGlite } from '@electric-sql/pglite'
-
-const textEncoder = new TextEncoder()
-const textDecoder = new TextDecoder()
-
-// --- wire protocol helpers ---
-
-function buildSimpleQuery(sql: string): Uint8Array {
-  const queryBytes = textEncoder.encode(sql + '\0')
-  const buf = new Uint8Array(5 + queryBytes.length)
-  buf[0] = 0x51 // 'Q'
-  new DataView(buf.buffer).setInt32(1, 4 + queryBytes.length)
-  buf.set(queryBytes, 5)
-  return buf
-}
-
-function buildStartupMessage(user: string, database: string): Buffer {
-  const params = `user\0${user}\0database\0${database}\0\0`
-  const paramsBytes = Buffer.from(params, 'utf-8')
-  const len = 4 + 4 + paramsBytes.length // length + protocol version + params
-  const buf = Buffer.alloc(len)
-  buf.writeInt32BE(len, 0)
-  buf.writeInt32BE(196608, 4) // protocol 3.0
-  paramsBytes.copy(buf, 8)
-  return buf
-}
-
-function buildPasswordMessage(password: string): Buffer {
-  const passBytes = Buffer.from(password + '\0', 'utf-8')
-  const len = 4 + passBytes.length
-  const buf = Buffer.alloc(1 + len)
-  buf[0] = 0x70 // 'p'
-  buf.writeInt32BE(len, 1)
-  passBytes.copy(buf, 5)
-  return buf
-}
-
-// read messages from socket until we get ReadyForQuery (0x5a)
-function readUntilReady(socket: Socket): Promise<Buffer[]> {
-  return new Promise((resolve, reject) => {
-    const messages: Buffer[] = []
-    let buffer = Buffer.alloc(0)
-    const timeout = setTimeout(
-      () => reject(new Error('timeout waiting for ReadyForQuery')),
-      10000
-    )
-
-    const onData = (data: Buffer) => {
-      buffer = Buffer.concat([buffer, data])
-      // parse complete messages
-      while (buffer.length >= 5) {
-        const msgType = buffer[0]
-        const msgLen = buffer.readInt32BE(1)
-        const totalLen = 1 + msgLen
-        if (buffer.length < totalLen) break
-        const msg = buffer.subarray(0, totalLen)
-        messages.push(Buffer.from(msg))
-        buffer = buffer.subarray(totalLen)
-        if (msgType === 0x5a) {
-          // ReadyForQuery
-          clearTimeout(timeout)
-          socket.off('data', onData)
-          resolve(messages)
-          return
-        }
-      }
-    }
-    socket.on('data', onData)
-    socket.on('error', (err) => {
-      clearTimeout(timeout)
-      reject(err)
-    })
-  })
-}
-
-async function connectPg(
-  port: number,
-  user: string,
-  password: string,
-  database = 'postgres'
-): Promise<Socket> {
-  const socket = await new Promise<Socket>((resolve, reject) => {
-    const s = createConnection({ host: '127.0.0.1', port }, () => resolve(s))
-    s.setMaxListeners(0) // suppress MaxListenersExceeded warnings for benchmarks
-    s.on('error', reject)
-  })
-  socket.setNoDelay(true)
-
-  // startup
-  socket.write(buildStartupMessage(user, database))
-
-  // wait for auth request
-  await new Promise<void>((resolve) => {
-    const onData = (data: Buffer) => {
-      if (data[0] === 0x52) {
-        // AuthenticationCleartextPassword
-        socket.off('data', onData)
-        resolve()
-      }
-    }
-    socket.on('data', onData)
-  })
-
-  // send password
-  socket.write(buildPasswordMessage(password))
-
-  // wait for ReadyForQuery
-  await readUntilReady(socket)
-  return socket
-}
-
-async function sendQuery(
-  socket: Socket,
-  sql: string
-): Promise<{ messages: Buffer[]; elapsed: number }> {
-  const t0 = performance.now()
-  socket.write(buildSimpleQuery(sql))
-  const messages = await readUntilReady(socket)
-  return { messages, elapsed: performance.now() - t0 }
-}
-
-// --- benchmarks ---
-
-interface BenchResult {
-  name: string
-  ops: number
-  totalMs: number
-  opsPerSec: number
-  avgLatencyMs: number
-  p50Ms: number
-  p99Ms: number
-}
-
-function percentile(sorted: number[], p: number): number {
-  const idx = Math.ceil(sorted.length * p) - 1
-  return sorted[Math.max(0, idx)]
-}
-
-function formatResult(r: BenchResult) {
-  return [
-    `  ${r.name}`,
-    `    ops:        ${r.ops}`,
-    `    total:      ${r.totalMs.toFixed(1)}ms`,
-    `    throughput:  ${r.opsPerSec.toFixed(0)} ops/sec`,
-    `    avg latency: ${r.avgLatencyMs.toFixed(2)}ms`,
-    `    p50:        ${r.p50Ms.toFixed(2)}ms`,
-    `    p99:        ${r.p99Ms.toFixed(2)}ms`,
-  ].join('\n')
-}
-
-async function benchSerial(
-  socket: Socket,
-  sql: string,
-  ops: number,
-  name: string
-): Promise<BenchResult> {
-  const latencies: number[] = []
-  const t0 = performance.now()
-  for (let i = 0; i < ops; i++) {
-    const { elapsed } = await sendQuery(socket, sql)
-    latencies.push(elapsed)
-  }
-  const totalMs = performance.now() - t0
-  latencies.sort((a, b) => a - b)
-  return {
-    name,
-    ops,
-    totalMs,
-    opsPerSec: (ops / totalMs) * 1000,
-    avgLatencyMs: totalMs / ops,
-    p50Ms: percentile(latencies, 0.5),
-    p99Ms: percentile(latencies, 0.99),
-  }
-}
-
-async function benchConcurrent(
-  sockets: Socket[],
-  sql: string,
-  opsPerSocket: number,
-  name: string
-): Promise<BenchResult> {
-  const allLatencies: number[] = []
-  const t0 = performance.now()
-  await Promise.all(
-    sockets.map(async (socket) => {
-      for (let i = 0; i < opsPerSocket; i++) {
-        const { elapsed } = await sendQuery(socket, sql)
-        allLatencies.push(elapsed)
-      }
-    })
-  )
-  const totalMs = performance.now() - t0
-  const ops = sockets.length * opsPerSocket
-  allLatencies.sort((a, b) => a - b)
-  return {
-    name,
-    ops,
-    totalMs,
-    opsPerSec: (ops / totalMs) * 1000,
-    avgLatencyMs: allLatencies.reduce((s, v) => s + v, 0) / ops,
-    p50Ms: percentile(allLatencies, 0.5),
-    p99Ms: percentile(allLatencies, 0.99),
-  }
-}
-
-async function run() {
-  console.log('\n=== Proxy Throughput Benchmark ===\n')
-
-  const pgPort = 25000 + Math.floor(Math.random() * 1000)
-  const zeroPort = pgPort + 100
-  const dataDir = `.orez-bench-proxy-${Date.now()}`
-
-  console.log(`starting orez (pg:${pgPort}, skipZero)...`)
-  const result = await startZeroLite({
-    pgPort,
-    zeroPort,
-    dataDir,
-    logLevel: 'error',
-    skipZeroCache: true, // pure proxy benchmark, no zero-cache overhead
-  })
-
-  const db = result.db as PGlite
-  const user = 'user'
-  const password = 'password'
-
-  try {
-    // set up test table
-    await db.exec(`
-      CREATE TABLE bench_rows (
-        id SERIAL PRIMARY KEY,
-        value TEXT,
-        num INTEGER
-      );
-      INSERT INTO bench_rows (value, num)
-      SELECT 'row-' || i, i FROM generate_series(1, 1000) AS i;
-    `)
-
-    // warmup
-    const warmupSocket = await connectPg(pgPort, user, password)
-    for (let i = 0; i < 50; i++) {
-      await sendQuery(warmupSocket, 'SELECT 1')
-    }
-    warmupSocket.destroy()
-
-    const results: BenchResult[] = []
-
-    // --- serial benchmarks (1 connection) ---
-    console.log('running serial benchmarks...')
-    const s1 = await connectPg(pgPort, user, password)
-
-    results.push(await benchSerial(s1, 'SELECT 1', 500, 'serial: SELECT 1 (ping)'))
-    results.push(
-      await benchSerial(
-        s1,
-        'SELECT * FROM bench_rows LIMIT 10',
-        500,
-        'serial: SELECT 10 rows'
-      )
-    )
-    results.push(
-      await benchSerial(s1, 'SELECT * FROM bench_rows', 200, 'serial: SELECT 1000 rows')
-    )
-    results.push(
-      await benchSerial(
-        s1,
-        "INSERT INTO bench_rows (value, num) VALUES ('x', 1)",
-        200,
-        'serial: INSERT'
-      )
-    )
-
-    s1.destroy()
-
-    // --- concurrent benchmarks (multiple connections, same db) ---
-    console.log('running concurrent benchmarks...')
-    const concSockets: Socket[] = []
-    for (let i = 0; i < 4; i++) {
-      concSockets.push(await connectPg(pgPort, user, password))
-    }
-
-    results.push(
-      await benchConcurrent(concSockets, 'SELECT 1', 200, 'concurrent 4x: SELECT 1')
-    )
-    results.push(
-      await benchConcurrent(
-        concSockets,
-        'SELECT * FROM bench_rows LIMIT 10',
-        200,
-        'concurrent 4x: SELECT 10 rows'
-      )
-    )
-
-    for (const s of concSockets) s.destroy()
-
-    // --- report ---
-    console.log('\n=== Results ===\n')
-    for (const r of results) {
-      console.log(formatResult(r))
-      console.log()
-    }
-
-    // summary: serial vs concurrent throughput ratio
-    const serialPing = results.find((r) => r.name.includes('serial: SELECT 1'))!
-    const concPing = results.find((r) => r.name.includes('concurrent 4x: SELECT 1'))!
-    const serialReal = results.find((r) => r.name.includes('serial: SELECT 10'))!
-    const concReal = results.find((r) => r.name.includes('concurrent 4x: SELECT 10'))!
-    const pingRatio = concPing.opsPerSec / serialPing.opsPerSec
-    const realRatio = concReal.opsPerSec / serialReal.opsPerSec
-    console.log(`  === scaling analysis (ideal = 4.0x with 4 connections) ===`)
-    console.log(
-      `  ping (no mutex/pglite):  ${pingRatio.toFixed(2)}x  ← main thread parallelism`
-    )
-    console.log(`  real queries (mutex):    ${realRatio.toFixed(2)}x  ← bottleneck here`)
-    console.log()
-  } finally {
-    await result.stop()
-    const { rmSync } = await import('node:fs')
-    try {
-      rmSync(dataDir, { recursive: true, force: true })
-    } catch {}
-  }
-}
-
-run().catch((err) => {
-  console.error('benchmark failed:', err)
-  process.exit(1)
-})

package/src/bench/serial-mutations.bench.ts

@@ -1,270 +0,0 @@
-/**
- * benchmark: serial mutations with connected client
- *
- * measures the time for N mutations to be fully replicated
- * to a connected websocket client.
- *
- * run: bun src/bench/serial-mutations.bench.ts
- */
-
-import WebSocket from 'ws'
-
-import { startZeroLite } from '../index.js'
-import {
-  ensureTablesInPublications,
-  installAllowAllPermissions,
-} from '../integration/test-permissions.js'
-import { installChangeTracking } from '../replication/change-tracker.js'
-
-import type { PGlite } from '@electric-sql/pglite'
-
-const SYNC_PROTOCOL_VERSION = 49
-const NUM_MUTATIONS = 100
-
-// test schema
-const CLIENT_SCHEMA = {
-  tables: {
-    bench_items: {
-      columns: {
-        id: { type: 'string' },
-        value: { type: 'string' },
-        num: { type: 'number' },
-      },
-      primaryKey: ['id'],
-    },
-  },
-}
-
-function encodeSecProtocols(
-  initConnectionMessage: unknown,
-  authToken: string | undefined
-): string {
-  const payload = JSON.stringify({ initConnectionMessage, authToken })
-  return encodeURIComponent(Buffer.from(payload, 'utf-8').toString('base64'))
-}
-
-class Queue<T> {
-  private items: T[] = []
-  private waiters: Array<{
-    resolve: (v: T) => void
-    timer?: ReturnType<typeof setTimeout>
-  }> = []
-
-  enqueue(item: T) {
-    const waiter = this.waiters.shift()
-    if (waiter) {
-      if (waiter.timer) clearTimeout(waiter.timer)
-      waiter.resolve(item)
-    } else {
-      this.items.push(item)
-    }
-  }
-
-  dequeue(fallback?: T, timeoutMs = 10000): Promise<T> {
-    if (this.items.length > 0) {
-      return Promise.resolve(this.items.shift()!)
-    }
-    return new Promise<T>((resolve) => {
-      const waiter: { resolve: (v: T) => void; timer?: ReturnType<typeof setTimeout> } = {
-        resolve,
-      }
-      if (fallback !== undefined) {
-        waiter.timer = setTimeout(() => {
-          const idx = this.waiters.indexOf(waiter)
-          if (idx >= 0) this.waiters.splice(idx, 1)
-          resolve(fallback)
-        }, timeoutMs)
-      }
-      this.waiters.push(waiter)
-    })
-  }
-}
-
-async function waitForZero(port: number, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`http://localhost:${port}/`)
-      if (res.ok || res.status === 404) return
-    } catch {}
-    await new Promise((r) => setTimeout(r, 500))
-  }
-  throw new Error(`zero-cache not ready on port ${port} after ${timeoutMs}ms`)
-}
-
-async function runBenchmark() {
-  console.log(`\n=== Serial Mutations Benchmark (${NUM_MUTATIONS} mutations) ===\n`)
-
-  const testPgPort = 24000 + Math.floor(Math.random() * 1000)
-  const testZeroPort = testPgPort + 100
-  const dataDir = `.orez-bench-${Date.now()}`
-
-  console.log(`starting orez on pg:${testPgPort} zero:${testZeroPort}`)
-  const result = await startZeroLite({
-    pgPort: testPgPort,
-    zeroPort: testZeroPort,
-    dataDir,
-    logLevel: 'info',
-    skipZeroCache: false,
-  })
-
-  const db = result.db
-  const zeroPort = result.zeroPort
-
-  try {
-    // create test table
-    await db.exec(`
-      CREATE TABLE IF NOT EXISTS bench_items (
-        id TEXT PRIMARY KEY,
-        value TEXT,
-        num INTEGER
-      );
-    `)
-
-    // add table to publication and install permissions
-    await ensureTablesInPublications(db, ['bench_items'])
-    await installChangeTracking(db)
-    await installAllowAllPermissions(db, ['bench_items'])
-
-    if (result.resetZeroFull) {
-      await result.resetZeroFull()
-    } else if (result.restartZero) {
-      await result.restartZero()
-    }
-
-    console.log('waiting for zero-cache...')
-    await waitForZero(zeroPort, 90000)
-    console.log('zero-cache ready')
-
-    // connect websocket client
-    const downstream = new Queue<unknown>()
-    const cg = `bench-cg-${Date.now()}`
-    const cid = `bench-client-${Date.now()}`
-    const secProtocol = encodeSecProtocols(
-      [
-        'initConnection',
-        {
-          desiredQueriesPatch: [
-            {
-              op: 'put',
-              hash: 'q1',
-              ast: { table: 'bench_items', orderBy: [['id', 'asc']] },
-            },
-          ],
-          clientSchema: CLIENT_SCHEMA,
-        },
-      ],
-      undefined
-    )
-
-    const ws = new WebSocket(
-      `ws://localhost:${zeroPort}/sync/v${SYNC_PROTOCOL_VERSION}/connect` +
-        `?clientGroupID=${cg}&clientID=${cid}&wsid=ws1&schemaVersion=1&baseCookie=&ts=${Date.now()}&lmid=0`,
-      secProtocol
-    )
-
-    ws.on('message', (data) => {
-      downstream.enqueue(JSON.parse(data.toString()))
-    })
-
-    // wait for connection
-    await new Promise<void>((resolve, reject) => {
-      ws.on('open', resolve)
-      ws.on('error', reject)
-      setTimeout(() => reject(new Error('ws connect timeout')), 5000)
-    })
-    console.log('websocket connected')
-
-    // drain initial pokes
-    let settled = false
-    const timeout = Date.now() + 30000
-    while (!settled && Date.now() < timeout) {
-      const msg = (await downstream.dequeue('timeout' as any, 3000)) as any
-      if (msg === 'timeout') {
-        settled = true
-      } else if (Array.isArray(msg) && msg[0] === 'pokeEnd') {
-        const next = (await downstream.dequeue('timeout' as any, 2000)) as any
-        if (next === 'timeout') {
-          settled = true
-        }
-      }
-    }
-    console.log('initial sync complete, starting benchmark...\n')
-
-    // ========== BENCHMARK: Serial Mutations ==========
-    const receivedIds = new Set<string>()
-    const startTime = performance.now()
-
-    // insert mutations serially
-    for (let i = 0; i < NUM_MUTATIONS; i++) {
-      const id = `bench-${i}`
-      await db.query(`INSERT INTO bench_items (id, value, num) VALUES ($1, $2, $3)`, [
-        id,
-        `value-${i}`,
-        i,
-      ])
-    }
-    const insertEndTime = performance.now()
-    console.log(`inserts completed in ${(insertEndTime - startTime).toFixed(1)}ms`)
-
-    // wait for all mutations to be replicated
-    const replicationTimeout = Date.now() + 60000
-    while (receivedIds.size < NUM_MUTATIONS && Date.now() < replicationTimeout) {
-      const msg = (await downstream.dequeue('timeout' as any, 1000)) as any
-      if (
-        msg !== 'timeout' &&
-        Array.isArray(msg) &&
-        msg[0] === 'pokePart' &&
-        msg[1]?.rowsPatch
-      ) {
-        for (const row of msg[1].rowsPatch) {
-          if (row.op === 'put' && row.tableName === 'bench_items' && row.value?.id) {
-            receivedIds.add(row.value.id)
-          }
-        }
-      }
-    }
-    const endTime = performance.now()
-
-    ws.close()
-
-    // results
-    const totalMs = endTime - startTime
-    const insertMs = insertEndTime - startTime
-    const replicationMs = endTime - insertEndTime
-    const perMutation = totalMs / NUM_MUTATIONS
-
-    console.log(`\n=== Results ===`)
-    console.log(`total time: ${totalMs.toFixed(1)}ms`)
-    console.log(
-      `insert time: ${insertMs.toFixed(1)}ms (${(insertMs / NUM_MUTATIONS).toFixed(1)}ms/op)`
-    )
-    console.log(`replication time: ${replicationMs.toFixed(1)}ms`)
-    console.log(`per mutation (end-to-end): ${perMutation.toFixed(1)}ms`)
-    console.log(`mutations received: ${receivedIds.size}/${NUM_MUTATIONS}`)
-    console.log(`throughput: ${(1000 / perMutation).toFixed(1)} mutations/sec`)
-
-    if (receivedIds.size < NUM_MUTATIONS) {
-      console.log(`\nWARNING: not all mutations were replicated!`)
-      const missing = []
-      for (let i = 0; i < NUM_MUTATIONS; i++) {
-        if (!receivedIds.has(`bench-${i}`)) missing.push(i)
-      }
-      console.log(
-        `missing: ${missing.slice(0, 10).join(', ')}${missing.length > 10 ? '...' : ''}`
-      )
-    }
-  } finally {
-    await result.stop()
-    // cleanup
-    const { rmSync } = await import('node:fs')
-    try {
-      rmSync(dataDir, { recursive: true, force: true })
-    } catch {}
-  }
-}
-
-runBenchmark().catch((err) => {
-  console.error('benchmark failed:', err)
-  process.exit(1)
-})