refactor(benchmark): finish migration to tatami-ng

[poolifier.git] / benchmarks / benchmarks-utils.mjs

diff --git a/benchmarks/benchmarks-utils.mjs b/benchmarks/benchmarks-utils.mjs
index a74a36ee6dbb05ad645aea2f468c2b61835efdfb..35c335c45877748ec332e45cd10fda5e5d4b69df 100644 (file)
--- a/benchmarks/benchmarks-utils.mjs
+++ b/benchmarks/benchmarks-utils.mjs
@@ -1,7 +1,7 @@
 import { strictEqual } from 'node:assert'
 
 import Benchmark from 'benchmark'
-import { bench, group } from 'mitata'
+import { bench, clear, group, run } from 'tatami-ng'
 
 import {
   DynamicClusterPool,
@@ -76,6 +76,77 @@ const runPoolifierPool = async (pool, { taskExecutions, workerData }) => {
 }
 
 export const runPoolifierBenchmarkBenchmarkJs = async (
+  name,
+  workerType,
+  poolType,
+  poolSize,
+  poolOptions,
+  { taskExecutions, workerData }
+) => {
+  return await new Promise((resolve, reject) => {
+    const pool = buildPoolifierPool(workerType, poolType, poolSize, poolOptions)
+    let workerChoiceStrategy
+    let enableTasksQueue
+    let workerChoiceStrategyOptions
+    if (poolOptions != null) {
+      ({
+        workerChoiceStrategy,
+        enableTasksQueue,
+        workerChoiceStrategyOptions
+      } = poolOptions)
+    }
+    const measurement = workerChoiceStrategyOptions?.measurement
+    new Benchmark(
+      `${name} with ${workerChoiceStrategy ?? pool.opts.workerChoiceStrategy}${
+        measurement != null ? `, with ${measurement}` : ''
+      } and ${enableTasksQueue ? 'with' : 'without'} tasks queue`,
+      async () => {
+        await runPoolifierPool(pool, {
+          taskExecutions,
+          workerData
+        })
+      },
+      {
+        onStart: () => {
+          if (workerChoiceStrategy != null) {
+            strictEqual(pool.opts.workerChoiceStrategy, workerChoiceStrategy)
+          }
+          if (enableTasksQueue != null) {
+            strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
+          }
+          if (measurement != null) {
+            strictEqual(
+              pool.opts.workerChoiceStrategyOptions.measurement,
+              measurement
+            )
+          }
+        },
+        onComplete: event => {
+          console.info(event.target.toString())
+          if (pool.started && !pool.destroying) {
+            pool.destroy().then(resolve).catch(reject)
+          } else {
+            resolve()
+          }
+        },
+        onError: event => {
+          if (pool.started && !pool.destroying) {
+            pool
+              .destroy()
+              .then(() => {
+                return reject(event.target.error)
+              })
+              .catch(() => {})
+          } else {
+            reject(event.target.error)
+          }
+        }
+      }
+    ).run({ async: true })
+  })
+}
+
+export const runPoolifierBenchmarkBenchmarkJsSuite = async (
   name,
   workerType,
   poolType,
@@ -113,7 +184,7 @@ export const runPoolifierBenchmarkBenchmarkJs = async (
         if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
           for (const measurement of [Measurements.runTime, Measurements.elu]) {
             suite.add(
-              `${name} with ${workerChoiceStrategy}, with measurement ${measurement} and ${
+              `${name} with ${workerChoiceStrategy}, with ${measurement} and ${
                 enableTasksQueue ? 'with' : 'without'
               } tasks queue`,
               async () => {
@@ -178,7 +249,7 @@ export const runPoolifierBenchmarkBenchmarkJs = async (
   })
 }
 
-export const buildPoolifierBenchmarkMitata = (
+export const runPoolifierBenchmarkTatamiNg = async (
   name,
   workerType,
   poolType,
@@ -197,23 +268,27 @@ export const buildPoolifierBenchmarkMitata = (
                   enableTasksQueue ? 'with' : 'without'
                 } tasks queue`,
                 async () => {
-                  pool.setWorkerChoiceStrategy(workerChoiceStrategy, {
-                    measurement
-                  })
-                  pool.enableTasksQueue(enableTasksQueue)
-                  strictEqual(
-                    pool.opts.workerChoiceStrategy,
-                    workerChoiceStrategy
-                  )
-                  strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
-                  strictEqual(
-                    pool.opts.workerChoiceStrategyOptions.measurement,
-                    measurement
-                  )
                   await runPoolifierPool(pool, {
                     taskExecutions,
                     workerData
                   })
+                },
+                {
+                  before: () => {
+                    pool.setWorkerChoiceStrategy(workerChoiceStrategy, {
+                      measurement
+                    })
+                    pool.enableTasksQueue(enableTasksQueue)
+                    strictEqual(
+                      pool.opts.workerChoiceStrategy,
+                      workerChoiceStrategy
+                    )
+                    strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
+                    strictEqual(
+                      pool.opts.workerChoiceStrategyOptions.measurement,
+                      measurement
+                    )
+                  }
                 }
               )
             })
@@ -225,24 +300,30 @@ export const buildPoolifierBenchmarkMitata = (
                 enableTasksQueue ? 'with' : 'without'
               } tasks queue`,
               async () => {
-                pool.setWorkerChoiceStrategy(workerChoiceStrategy)
-                pool.enableTasksQueue(enableTasksQueue)
-                strictEqual(
-                  pool.opts.workerChoiceStrategy,
-                  workerChoiceStrategy
-                )
-                strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
                 await runPoolifierPool(pool, {
                   taskExecutions,
                   workerData
                 })
+              },
+              {
+                before: () => {
+                  pool.setWorkerChoiceStrategy(workerChoiceStrategy)
+                  pool.enableTasksQueue(enableTasksQueue)
+                  strictEqual(
+                    pool.opts.workerChoiceStrategy,
+                    workerChoiceStrategy
+                  )
+                  strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
+                }
               }
             )
           })
         }
       }
     }
-    return pool
+    await run()
+    clear()
+    await pool.destroy()
   } catch (error) {
     console.error(error)
   }