perf(benchmark): port to homemade mitata fork

[poolifier.git] / benchmarks / internal / bench.mjs

diff --git a/benchmarks/internal/bench.mjs b/benchmarks/internal/bench.mjs
index 23ab0625807e349b89f6fabd55be766e45f9fff5..480998b72c935900681627839091162befbd6a23 100644 (file)
--- a/benchmarks/internal/bench.mjs
+++ b/benchmarks/internal/bench.mjs
@@ -1,79 +1,122 @@
-import Benchmark from 'benchmark'
+import { exit } from 'node:process'
+import { parseArgs } from 'node:util'
+
 import {
-  Measurements,
+  availableParallelism,
   PoolTypes,
-  WorkerChoiceStrategies,
-  WorkerTypes,
-  availableParallelism
+  WorkerTypes
 } from '../../lib/index.mjs'
-import { TaskFunctions } from '../benchmarks-types.mjs'
+import { TaskFunctions } from '../benchmarks-types.cjs'
 import {
-  LIST_FORMATTER,
-  buildPoolifierPool,
-  runPoolifierTest
+  runPoolifierBenchmarkBenchmarkJsSuite,
+  runPoolifierBenchmarkMitata
 } from '../benchmarks-utils.mjs'
 
 const poolSize = availableParallelism()
-const pools = []
-for (const poolType of Object.values(PoolTypes)) {
-  for (const workerType of Object.values(WorkerTypes)) {
-    if (workerType === WorkerTypes.cluster) {
-      continue
-    }
-    for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
-      for (const enableTasksQueue of [false]) {
-        if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
-          for (const measurement of [Measurements.runTime, Measurements.elu]) {
-            pools.push([
-              `${poolType}|${workerType}|${workerChoiceStrategy}|tasks queue:${enableTasksQueue}|measurement:${measurement}`,
-              buildPoolifierPool(workerType, poolType, poolSize, {
-                workerChoiceStrategy,
-                workerChoiceStrategyOptions: {
-                  measurement
-                },
-                enableTasksQueue
-              })
-            ])
-          }
-        } else {
-          pools.push([
-            `${poolType}|${workerType}|${workerChoiceStrategy}|tasks queue:${enableTasksQueue}`,
-            buildPoolifierPool(workerType, poolType, poolSize, {
-              workerChoiceStrategy,
-              enableTasksQueue
-            })
-          ])
-        }
-      }
-    }
-  }
-}
-
 const taskExecutions = 1
 const workerData = {
-  function: TaskFunctions.jsonIntegerSerialization,
-  taskSize: 100
+  function: TaskFunctions.factorial,
+  taskSize: 50000
 }
 
-const suite = new Benchmark.Suite('Poolifier')
-for (const [name, pool] of pools) {
-  suite.add(name, async () => {
-    await runPoolifierTest(pool, {
-      taskExecutions,
-      workerData
-    })
-  })
+switch (
+  parseArgs({
+    args: process.argv,
+    options: {
+      type: {
+        type: 'string',
+        short: 't'
+      }
+    },
+    strict: true,
+    allowPositionals: true
+  }).values.type
+) {
+  case 'mitata':
+    await runPoolifierBenchmarkMitata(
+      'FixedThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkMitata(
+      'DynamicThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkMitata(
+      'FixedClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkMitata(
+      'DynamicClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    break
+  case 'benchmark.js':
+  default:
+    await runPoolifierBenchmarkBenchmarkJsSuite(
+      'FixedThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJsSuite(
+      'DynamicThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJsSuite(
+      'FixedClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJsSuite(
+      'DynamicClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    break
 }
 
-suite
-  .on('cycle', event => {
-    console.info(event.target.toString())
-  })
-  .on('complete', function () {
-    console.info(
-      'Fastest is ' + LIST_FORMATTER.format(this.filter('fastest').map('name'))
-    )
-    // eslint-disable-next-line n/no-process-exit
-    process.exit()
-  })
-  .run({ async: true, maxTime: 120 })
+exit()