Merge pull request #382 from bsv-blockchain/housekeeping

Housekeeping

Author: ty-everett

benchmarks/atomic-beef-bench.js

@@ -1,7 +1,7 @@
-import { performance } from 'perf_hooks'
 import Transaction from '../dist/esm/src/transaction/Transaction.js'
 import PrivateKey from '../dist/esm/src/primitives/PrivateKey.js'
 import P2PKH from '../dist/esm/src/script/templates/P2PKH.js'
+import { runBenchmark } from './lib/benchmark-runner.js'
 
 async function buildChain (depth) {
   const privateKey = new PrivateKey(1)
@@ -34,26 +34,6 @@ async function buildChain (depth) {
 
   return currentTx
 }
-
-async function measure (fn, iterations = 5) {
-  const times = []
-  for (let i = 0; i < iterations; i++) {
-    const start = performance.now()
-    const result = fn()
-    if (result instanceof Promise) {
-      await result
-    }
-    const end = performance.now()
-    times.push(end - start)
-  }
-  const total = times.reduce((sum, t) => sum + t, 0)
-  return {
-    average: total / times.length,
-    min: Math.min(...times),
-    max: Math.max(...times)
-  }
-}
-
 async function run () {
   const depth = Number.parseInt(process.argv[2] ?? '200', 10)
   const iterations = Number.parseInt(process.argv[3] ?? '5', 10)
@@ -64,12 +44,15 @@ async function run () {
   const initialSerialized = finalTx.toAtomicBEEF()
   Transaction.fromAtomicBEEF(initialSerialized)
 
-  const toStats = await measure(() => finalTx.toAtomicBEEF(), iterations)
   const serialized = finalTx.toAtomicBEEF()
-  const fromStats = await measure(() => Transaction.fromAtomicBEEF(serialized), iterations)
-
-  console.log(`Transaction.toAtomicBEEF avg: ${toStats.average.toFixed(2)}ms (min ${toStats.min.toFixed(2)}ms, max ${toStats.max.toFixed(2)}ms)`) 
-  console.log(`Transaction.fromAtomicBEEF avg: ${fromStats.average.toFixed(2)}ms (min ${fromStats.min.toFixed(2)}ms, max ${fromStats.max.toFixed(2)}ms)`) 
+  await runBenchmark('Transaction.toAtomicBEEF', () => finalTx.toAtomicBEEF(), {
+    minSampleMs: 200,
+    samples: Math.max(5, iterations)
+  })
+  await runBenchmark('Transaction.fromAtomicBEEF', () => Transaction.fromAtomicBEEF(serialized), {
+    minSampleMs: 200,
+    samples: Math.max(5, iterations)
+  })
 }
 
 run().catch((err) => {

benchmarks/bignumber-bench.js

@@ -1,12 +1,5 @@
-import { performance } from 'perf_hooks'
 import BigNumber from '../dist/esm/src/primitives/BigNumber.js'
-
-function benchmark (name, fn) {
-  const start = performance.now()
-  fn()
-  const end = performance.now()
-  console.log(`${name}: ${(end - start).toFixed(2)}ms`)
-}
+import { runBenchmark } from './lib/benchmark-runner.js'
 
 const digits = Number(process.argv[2] ?? 20000)
 const mulIterations = Number(process.argv[3] ?? 5)
@@ -15,14 +8,27 @@ const largeHex = 'f'.repeat(digits)
 const a = new BigNumber(largeHex, 16)
 const b = new BigNumber(largeHex, 16)
 
-benchmark('mul large numbers', () => {
-  for (let i = 0; i < mulIterations; i++) {
-    a.mul(b)
-  }
-})
+async function main () {
+  await runBenchmark('mul large numbers', () => {
+    for (let i = 0; i < mulIterations; i++) {
+      a.mul(b)
+    }
+  }, {
+    minSampleMs: 500,
+    samples: 10
+  })
+
+  await runBenchmark('add large numbers', () => {
+    for (let i = 0; i < addIterations; i++) {
+      a.add(b)
+    }
+  }, {
+    minSampleMs: 400,
+    samples: 10
+  })
+}
 
-benchmark('add large numbers', () => {
-  for (let i = 0; i < addIterations; i++) {
-    a.add(b)
-  }
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
 })

benchmarks/bn-serialization-bench.js

@@ -1,12 +1,5 @@
-import { performance } from 'perf_hooks'
 import BigNumber from '../dist/esm/src/primitives/BigNumber.js'
-
-function benchmark (name, fn) {
-  const start = performance.now()
-  fn()
-  const end = performance.now()
-  console.log(`${name}: ${(end - start).toFixed(2)}ms`)
-}
+import { runBenchmark } from './lib/benchmark-runner.js'
 
 const digits = Number(process.argv[2] ?? 200000)
 const iterations = Number(process.argv[3] ?? 1)
@@ -15,22 +8,31 @@ const bn = new BigNumber(largeHex, 16)
 const little = bn.toSm('little')
 const big = bn.toSm('big')
 
-benchmark('toSm big', () => {
-  for (let i = 0; i < iterations; i++) bn.toSm('big')
-})
+async function main () {
+  const options = { minSampleMs: 400, samples: 8 }
 
-benchmark('toSm little', () => {
-  for (let i = 0; i < iterations; i++) bn.toSm('little')
-})
+  await runBenchmark('toSm big', () => {
+    for (let i = 0; i < iterations; i++) bn.toSm('big')
+  }, options)
 
-benchmark('fromSm big', () => {
-  for (let i = 0; i < iterations; i++) BigNumber.fromSm(big)
-})
+  await runBenchmark('toSm little', () => {
+    for (let i = 0; i < iterations; i++) bn.toSm('little')
+  }, options)
 
-benchmark('fromSm little', () => {
-  for (let i = 0; i < iterations; i++) BigNumber.fromSm(little, 'little')
-})
+  await runBenchmark('fromSm big', () => {
+    for (let i = 0; i < iterations; i++) BigNumber.fromSm(big)
+  }, options)
+
+  await runBenchmark('fromSm little', () => {
+    for (let i = 0; i < iterations; i++) BigNumber.fromSm(little, 'little')
+  }, options)
+
+  await runBenchmark('fromScriptNum', () => {
+    for (let i = 0; i < iterations; i++) BigNumber.fromScriptNum(little)
+  }, options)
+}
 
-benchmark('fromScriptNum', () => {
-  for (let i = 0; i < iterations; i++) BigNumber.fromScriptNum(little)
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
 })

benchmarks/lib/benchmark-runner.js

@@ -0,0 +1,87 @@
+import { performance } from 'perf_hooks'
+
+function numberFromEnv (key, fallback) {
+  const value = Number(process.env[key])
+  return Number.isFinite(value) && value > 0 ? value : fallback
+}
+
+const DEFAULTS = {
+  warmupIterations: numberFromEnv('BENCH_WARMUP', 2),
+  samples: numberFromEnv('BENCH_SAMPLES', 8),
+  minSampleMs: numberFromEnv('BENCH_MIN_SAMPLE_MS', 250),
+  minIterations: numberFromEnv('BENCH_MIN_ITERATIONS', 1)
+}
+
+async function maybeAwait (result) {
+  if (result != null && typeof result.then === 'function') {
+    await result
+  }
+}
+
+async function measureSample (fn, minSampleMs, minIterations) {
+  let iterations = 0
+  let elapsed = 0
+  do {
+    const start = performance.now()
+    await maybeAwait(fn())
+    elapsed += performance.now() - start
+    iterations++
+  } while (elapsed < minSampleMs || iterations < minIterations)
+
+  return {
+    average: elapsed / iterations,
+    iterations,
+    elapsed
+  }
+}
+
+function computeStats (values) {
+  const total = values.reduce((sum, value) => sum + value, 0)
+  const average = total / values.length
+  const min = Math.min(...values)
+  const max = Math.max(...values)
+  const variance = values.length > 1
+    ? values.reduce((sum, value) => sum + Math.pow(value - average, 2), 0) / values.length
+    : 0
+  return {
+    average,
+    min,
+    max,
+    stddev: Math.sqrt(variance),
+    samples: values.length
+  }
+}
+
+function logStats (name, stats, iterations) {
+  const avgIterations = iterations.reduce((sum, value) => sum + value, 0) / iterations.length
+  console.log(
+    `${name}: ${stats.average.toFixed(2)}ms avg (min ${stats.min.toFixed(2)}ms, max ${stats.max.toFixed(2)}ms, ` +
+    `±${stats.stddev.toFixed(2)}ms, ~${avgIterations.toFixed(1)} runs/sample)`
+  )
+}
+
+export async function runBenchmark (name, fn, options = {}) {
+  const warmupIterations = Math.max(0, Math.floor(options.warmupIterations ?? DEFAULTS.warmupIterations))
+  const samples = Math.max(1, Math.floor(options.samples ?? DEFAULTS.samples))
+  const minSampleMs = Math.max(1, options.minSampleMs ?? DEFAULTS.minSampleMs)
+  const minIterations = Math.max(1, Math.floor(options.minIterations ?? DEFAULTS.minIterations))
+
+  for (let i = 0; i < warmupIterations; i++) {
+    await maybeAwait(fn())
+  }
+
+  const sampleValues = []
+  const sampleIterations = []
+  for (let i = 0; i < samples; i++) {
+    const { average, iterations } = await measureSample(fn, minSampleMs, minIterations)
+    sampleValues.push(average)
+    sampleIterations.push(iterations)
+  }
+
+  const stats = computeStats(sampleValues)
+  logStats(name, stats, sampleIterations)
+  return {
+    ...stats,
+    sampleIterations
+  }
+}

benchmarks/reader-writer-bench.js

@@ -1,19 +1,12 @@
-import { performance } from 'perf_hooks'
 import { Writer, Reader } from '../dist/esm/src/primitives/utils.js'
+import { runBenchmark } from './lib/benchmark-runner.js'
 
 function data (len, start = 0) {
   const arr = new Array(len)
   for (let i = 0; i < len; i++) arr[i] = (start + i) & 0xff
   return arr
 }
 
-function benchmark (name, fn) {
-  const start = performance.now()
-  fn()
-  const end = performance.now()
-  console.log(`${name}: ${(end - start).toFixed(2)}ms`)
-}
-
 const largePayloads = [data(2 * 1024 * 1024, 0), data(2 * 1024 * 1024, 1), data(2 * 1024 * 1024, 2)]
 const smallPayloads = Array.from({ length: 3000 }, (_, i) => data(100, i))
 const mediumPayloads = Array.from({ length: 400 }, (_, i) => data(10 * 1024, i))
@@ -82,7 +75,15 @@ function rwMedium () {
   }
 }
 
-benchmark('mixed ops', mixedOps)
-benchmark('large payloads', rwLarge)
-benchmark('3000 small payloads', rwSmall)
-benchmark('400 medium payloads', rwMedium)
+async function main () {
+  const options = { minSampleMs: 300, samples: 9 }
+  await runBenchmark('mixed ops', mixedOps, options)
+  await runBenchmark('large payloads', rwLarge, options)
+  await runBenchmark('3000 small payloads', rwSmall, options)
+  await runBenchmark('400 medium payloads', rwMedium, options)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

benchmarks/script-serialization-bench.js

@@ -1,45 +1,51 @@
-import { performance } from 'perf_hooks'
 import { randomBytes, randomFillSync } from 'crypto'
 // Provide browser-like crypto for Random
 globalThis.self = { crypto: { getRandomValues: (arr) => randomFillSync(arr) } }
 import SymmetricKey from '../dist/esm/src/primitives/SymmetricKey.js'
+import { runBenchmark } from './lib/benchmark-runner.js'
 
 function rand (n) {
   return [...randomBytes(n)]
 }
 
-function benchmark (name, fn) {
-  const start = performance.now()
-  fn()
-  const end = performance.now()
-  console.log(`${name}: ${(end - start).toFixed(2)}ms`)
-}
-
 const key = SymmetricKey.fromRandom()
 const largeMsg = rand(2 * 1024 * 1024)
 const smallMsgs = Array.from({ length: 50 }, () => rand(100))
 const mediumMsgs = Array.from({ length: 200 }, () => rand(1024))
 
 let enc
-benchmark('encrypt large 2MB', () => {
-  enc = key.encrypt(largeMsg)
-})
-benchmark('decrypt large 2MB', () => {
-  key.decrypt(enc)
-})
-
-benchmark('encrypt 50 small', () => {
-  for (const m of smallMsgs) key.encrypt(m)
-})
 const encSmall = smallMsgs.map(m => key.encrypt(m))
-benchmark('decrypt 50 small', () => {
-  for (const m of encSmall) key.decrypt(m)
-})
-
-benchmark('encrypt 200 medium', () => {
-  for (const m of mediumMsgs) key.encrypt(m)
-})
 const encMedium = mediumMsgs.map(m => key.encrypt(m))
-benchmark('decrypt 200 medium', () => {
-  for (const m of encMedium) key.decrypt(m)
+
+async function main () {
+  const heavyOptions = { minSampleMs: 250, samples: 5, warmupIterations: 1 }
+  const lightOptions = { minSampleMs: 250, samples: 9, warmupIterations: 1 }
+  await runBenchmark('encrypt large 2MB', () => {
+    enc = key.encrypt(largeMsg)
+  }, heavyOptions)
+
+  await runBenchmark('decrypt large 2MB', () => {
+    key.decrypt(enc)
+  }, heavyOptions)
+
+  await runBenchmark('encrypt 50 small', () => {
+    for (const m of smallMsgs) key.encrypt(m)
+  }, lightOptions)
+
+  await runBenchmark('decrypt 50 small', () => {
+    for (const m of encSmall) key.decrypt(m)
+  }, lightOptions)
+
+  await runBenchmark('encrypt 200 medium', () => {
+    for (const m of mediumMsgs) key.encrypt(m)
+  }, lightOptions)
+
+  await runBenchmark('decrypt 200 medium', () => {
+    for (const m of encMedium) key.decrypt(m)
+  }, lightOptions)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
 })