sig verification pool test

Author: acolytec3

packages/vm/src/worker/signatureWorker.ts

@@ -0,0 +1,25 @@
+import { ecrecover } from '@ethereumjs/util'
+import { parentPort } from 'worker_threads'
+
+interface SignatureTask {
+  msgHash: Uint8Array
+  v: bigint
+  r: Uint8Array
+  s: Uint8Array
+  chainId?: bigint
+}
+
+interface SignatureResult {
+  publicKey: Uint8Array
+}
+
+function processSignature(task: SignatureTask): SignatureResult {
+  const publicKey = ecrecover(task.msgHash, task.v, task.r, task.s, task.chainId)
+  return { publicKey }
+}
+
+// Listen for messages from the main thread
+parentPort?.on('message', (tasks: SignatureTask[]) => {
+  const results = tasks.map(processSignature)
+  parentPort?.postMessage(results)
+})

packages/vm/src/worker/signatureWorkerPool.ts

@@ -0,0 +1,69 @@
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+import { Worker } from 'worker_threads'
+
+interface SignatureTask {
+  msgHash: Uint8Array
+  v: bigint
+  r: Uint8Array
+  s: Uint8Array
+  chainId?: bigint
+}
+
+interface SignatureResult {
+  publicKey: Uint8Array
+}
+
+export class SignatureWorkerPool {
+  private workers: Worker[] = []
+  private taskQueue: SignatureTask[] = []
+  private results: Map<number, SignatureResult> = new Map()
+  private nextTaskId = 0
+
+  constructor(numWorkers: number = 4) {
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = dirname(__filename)
+    const workerPath = join(__dirname, 'signatureWorker.ts')
+
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new Worker(workerPath, {
+        // Use tsx to run TypeScript files
+        execArgv: ['-r', 'tsx/register'],
+      })
+
+      worker.on('message', (results: SignatureResult[]) => {
+        results.forEach((result, index) => {
+          this.results.set(this.nextTaskId - results.length + index, result)
+        })
+      })
+      this.workers.push(worker)
+    }
+  }
+
+  async processBatch(tasks: SignatureTask[]): Promise<Map<number, SignatureResult>> {
+    const batchSize = Math.ceil(tasks.length / this.workers.length)
+    const promises: Promise<void>[] = []
+
+    for (let i = 0; i < this.workers.length; i++) {
+      const start = i * batchSize
+      const end = Math.min(start + batchSize, tasks.length)
+      const batch = tasks.slice(start, end)
+
+      if (batch.length > 0) {
+        promises.push(
+          new Promise((resolve) => {
+            this.workers[i].postMessage(batch)
+            resolve()
+          }),
+        )
+      }
+    }
+
+    await Promise.all(promises)
+    return this.results
+  }
+
+  terminate() {
+    this.workers.forEach((worker) => worker.terminate())
+  }
+}

packages/vm/test/benchmark/signatureVerification.ts

@@ -0,0 +1,83 @@
+import { LegacyTx } from '@ethereumjs/tx'
+import { bigIntToUnpaddedBytes, ecrecover, equalsBytes, randomBytes } from '@ethereumjs/util'
+import { SignatureWorkerPool } from '../../src/worker/signatureWorkerPool.ts'
+
+async function runBenchmark() {
+  // Create 10 test transactions
+  const transactions = Array.from({ length: 1000 }, (_, i) => {
+    return new LegacyTx({
+      nonce: i,
+      gasPrice: 1000000000n,
+      gasLimit: 21000n,
+      to: '0x0000000000000000000000000000000000000000',
+      value: 1000000000000000000n,
+      data: '0x',
+    })
+  })
+
+  // Sign all transactions
+  const signedTxs = transactions.map((tx) => tx.sign(randomBytes(32)))
+
+  // Precompute all hashes and signature values
+  const msgHashes = signedTxs.map((tx) => tx.getMessageToVerifySignature())
+  const vs = signedTxs.map((tx) => tx.v!)
+  const rs = signedTxs.map((tx) => bigIntToUnpaddedBytes(tx.r!))
+  const ss = signedTxs.map((tx) => bigIntToUnpaddedBytes(tx.s!))
+  const chainIds = signedTxs.map((tx) => tx.common.chainId())
+
+  console.log('Running benchmark...\n')
+
+  // Sequential verification
+  console.log('Sequential verification:')
+  const startSeq = performance.now()
+
+  // Store sequential results
+  const sequentialResults = new Map()
+  for (let i = 0; i < signedTxs.length; i++) {
+    const publicKey = ecrecover(msgHashes[i], vs[i], rs[i], ss[i], 1n)
+    sequentialResults.set(i, publicKey)
+  }
+
+  const endSeq = performance.now()
+  console.log(`Time taken: ${endSeq - startSeq}ms\n`)
+
+  // Parallel verification using worker pool
+  console.log('Parallel verification using worker pool:')
+  const startPar = performance.now()
+
+  const signatureTasks = msgHashes.map((msgHash, i) => {
+    return {
+      msgHash,
+      v: vs[i],
+      r: rs[i],
+      s: ss[i],
+      chainId: chainIds[i],
+    }
+  })
+
+  const workerPool = new SignatureWorkerPool(4) // Use 4 workers
+  const parallelResults = await workerPool.processBatch(signatureTasks)
+  await workerPool.terminate()
+
+  const endPar = performance.now()
+  console.log(`Time taken: ${endPar - startPar}ms\n`)
+
+  // Print speedup
+  const speedup = (endSeq - startSeq) / (endPar - startPar)
+  console.log(`Speedup: ${speedup.toFixed(2)}x`)
+
+  // Verify results match by comparing the stored sequential results with parallel results
+  console.log('\nVerifying results...')
+  let allMatch = true
+  for (let i = 0; i < signedTxs.length; i++) {
+    const parallelResult = parallelResults.get(i)
+    const sequentialResult = sequentialResults.get(i)
+    if (parallelResult && !equalsBytes(parallelResult.publicKey, sequentialResult)) {
+      console.log(`Mismatch at index ${i}`)
+      allMatch = false
+    }
+  }
+  console.log(`All results match: ${allMatch}`)
+}
+
+runBenchmark().catch(console.error)