X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;ds=sidebyside;f=benchmarks%2Finternal%2Fbench.mjs;h=aa98be858bb66f6f819f4c52c190cab45c48d6fc;hb=47ab5d238b0f0bcc72b99959108ca53a9935dd22;hp=258854f864702ecf92816e151b33d14f38c96840;hpb=4735284627d276d3532cb3bd4b6d7fe392bb6b8b;p=poolifier.git

diff --git a/benchmarks/internal/bench.mjs b/benchmarks/internal/bench.mjs
index 258854f8..aa98be85 100644
--- a/benchmarks/internal/bench.mjs
+++ b/benchmarks/internal/bench.mjs
@@ -1,92 +1,133 @@
-import Benchmark from 'benchmark'
+import { exit } from 'node:process'
+import { parseArgs } from 'node:util'
+
+import { run } from 'mitata'
+
 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
+  buildPoolifierBenchmarkMitata,
+  runPoolifierBenchmarkBenchmarkJs
 } from '../benchmarks-utils.mjs'
 
-const poolifierSuite = new Benchmark.Suite('Poolifier', {
-  onCycle: event => {
-    console.info(event.target.toString())
-  },
-  onComplete: function () {
-    console.info(
-      'Fastest is ' + LIST_FORMATTER.format(this.filter('fastest').map('name'))
-    )
-  }
-})
-
 const poolSize = availableParallelism()
-const benchmarkSettings = []
-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, true]) {
-        if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
-          for (const measurement of [Measurements.runTime, Measurements.elu]) {
-            benchmarkSettings.push([
-              `${poolType}|${workerType}|${workerChoiceStrategy}|tasks queue:${enableTasksQueue}|measurement:${measurement}`,
-              workerType,
-              poolType,
-              poolSize,
-              {
-                workerChoiceStrategy,
-                workerChoiceStrategyOptions: {
-                  measurement
-                },
-                enableTasksQueue
-              }
-            ])
-          }
-        } else {
-          benchmarkSettings.push([
-            `${poolType}|${workerType}|${workerChoiceStrategy}|tasks queue:${enableTasksQueue}`,
-            workerType,
-            poolType,
-            poolSize,
-            {
-              workerChoiceStrategy,
-              enableTasksQueue
-            }
-          ])
-        }
-      }
-    }
-  }
-}
-
 const taskExecutions = 1
 const workerData = {
-  function: TaskFunctions.jsonIntegerSerialization,
-  taskSize: 100
+  function: TaskFunctions.factorial,
+  taskSize: 50000
 }
 
-for (const [
-  name,
-  workerType,
-  poolType,
-  poolSize,
-  poolOptions
-] of benchmarkSettings) {
-  poolifierSuite.add(name, async () => {
-    const pool = buildPoolifierPool(workerType, poolType, poolSize, poolOptions)
-    await runPoolifierTest(pool, {
-      taskExecutions,
-      workerData
-    })
-    await pool.destroy()
-  })
+let fixedThreadPool
+let dynamicThreadPool
+let fixedClusterPool
+let dynamicClusterPool
+switch (
+  parseArgs({
+    args: process.argv,
+    options: {
+      type: {
+        type: 'string',
+        short: 't'
+      }
+    },
+    strict: true,
+    allowPositionals: true
+  }).values.type
+) {
+  case 'mitata':
+    fixedThreadPool = buildPoolifierBenchmarkMitata(
+      'FixedThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    dynamicThreadPool = buildPoolifierBenchmarkMitata(
+      'DynamicThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    fixedClusterPool = buildPoolifierBenchmarkMitata(
+      'FixedClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    dynamicClusterPool = buildPoolifierBenchmarkMitata(
+      'DynamicClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await run()
+    await fixedThreadPool.destroy()
+    await dynamicThreadPool.destroy()
+    await fixedClusterPool.destroy()
+    await dynamicClusterPool.destroy()
+    break
+  case 'benchmark.js':
+  default:
+    await runPoolifierBenchmarkBenchmarkJs(
+      'FixedThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJs(
+      'DynamicThreadPool',
+      WorkerTypes.thread,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJs(
+      'FixedClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.fixed,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    await runPoolifierBenchmarkBenchmarkJs(
+      'DynamicClusterPool',
+      WorkerTypes.cluster,
+      PoolTypes.dynamic,
+      poolSize,
+      {
+        taskExecutions,
+        workerData
+      }
+    )
+    break
 }
 
-poolifierSuite.run({ async: true })
+exit()