X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=benchmarks%2Fbenchmarks-utils.mjs;h=16a656107fc6f00973fe7bdc6541a6bab2794a2b;hb=4b72aab982db24a30656e0b82a9866ca3a0f7480;hp=5db55b3b11c9b8c956e46397674e71a34471d241;hpb=cc8689daa9ac0859d46afed4a36a9ec2b6c84327;p=poolifier.git

diff --git a/benchmarks/benchmarks-utils.mjs b/benchmarks/benchmarks-utils.mjs
index 5db55b3b..16a65610 100644
--- a/benchmarks/benchmarks-utils.mjs
+++ b/benchmarks/benchmarks-utils.mjs
@@ -1,7 +1,6 @@
 import { strictEqual } from 'node:assert'
 
-import Benchmark from 'benchmark'
-import { bench, group } from 'mitata'
+import { bench, clear, group, run } from 'tatami-ng'
 
 import {
   DynamicClusterPool,
@@ -55,201 +54,12 @@ const buildPoolifierPool = (workerType, poolType, poolSize, poolOptions) => {
 }
 
 const runPoolifierPool = async (pool, { taskExecutions, workerData }) => {
-  return await new Promise((resolve, reject) => {
-    let executions = 0
-    for (let i = 1; i <= taskExecutions; i++) {
-      pool
-        .execute(workerData)
-        .then(() => {
-          ++executions
-          if (executions === taskExecutions) {
-            resolve({ ok: 1 })
-          }
-          return undefined
-        })
-        .catch(err => {
-          console.error(err)
-          reject(err)
-        })
-    }
-  })
-}
-
-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,
-  poolSize,
-  { taskExecutions, workerData }
-) => {
-  return await new Promise((resolve, reject) => {
-    const pool = buildPoolifierPool(workerType, poolType, poolSize)
-    const suite = new Benchmark.Suite(name, {
-      onComplete: () => {
-        if (pool.started && !pool.destroying) {
-          pool.destroy().then(resolve).catch(reject)
-        } else {
-          resolve()
-        }
-      },
-      onCycle: event => {
-        console.info(event.target.toString())
-      },
-      onError: event => {
-        if (pool.started && !pool.destroying) {
-          pool
-            .destroy()
-            .then(() => {
-              return reject(event.target.error)
-            })
-            .catch(() => {})
-        } else {
-          reject(event.target.error)
-        }
-      }
-    })
-    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]) {
-            suite.add(
-              `${name} with ${workerChoiceStrategy}, with ${measurement} and ${
-                enableTasksQueue ? 'with' : 'without'
-              } tasks queue`,
-              async () => {
-                await runPoolifierPool(pool, {
-                  taskExecutions,
-                  workerData
-                })
-              },
-              {
-                onStart: () => {
-                  pool.setWorkerChoiceStrategy(workerChoiceStrategy, {
-                    measurement
-                  })
-                  pool.enableTasksQueue(enableTasksQueue)
-                  strictEqual(
-                    pool.opts.workerChoiceStrategy,
-                    workerChoiceStrategy
-                  )
-                  strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
-                  strictEqual(
-                    pool.opts.workerChoiceStrategyOptions.measurement,
-                    measurement
-                  )
-                }
-              }
-            )
-          }
-        } else {
-          suite.add(
-            `${name} with ${workerChoiceStrategy} and ${
-              enableTasksQueue ? 'with' : 'without'
-            } tasks queue`,
-            async () => {
-              await runPoolifierPool(pool, {
-                taskExecutions,
-                workerData
-              })
-            },
-            {
-              onStart: () => {
-                pool.setWorkerChoiceStrategy(workerChoiceStrategy)
-                pool.enableTasksQueue(enableTasksQueue)
-                strictEqual(
-                  pool.opts.workerChoiceStrategy,
-                  workerChoiceStrategy
-                )
-                strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
-              }
-            }
-          )
-        }
-      }
-    }
-    suite
-      .on('complete', function () {
-        console.info(
-          'Fastest is ' +
-            LIST_FORMATTER.format(this.filter('fastest').map('name'))
-        )
-      })
-      .run({ async: true })
-  })
+  for (let i = 1; i <= taskExecutions; i++) {
+    await pool.execute(workerData)
+  }
 }
 
-export const buildPoolifierBenchmarkMitata = (
+export const runPoolifierBenchmarkTatamiNg = async (
   name,
   workerType,
   poolType,
@@ -268,23 +78,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
+                    )
+                  }
                 }
               )
             })
@@ -296,32 +110,53 @@ 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
+    const report = await run()
+    clear()
+    await pool.destroy()
+    return report
   } catch (error) {
     console.error(error)
   }
 }
 
-const LIST_FORMATTER = new Intl.ListFormat('en-US', {
-  style: 'long',
-  type: 'conjunction'
-})
+export const convertTatamiNgToBmf = report => {
+  return report.benchmarks
+    .map(({ name, stats }) => {
+      return {
+        [name]: {
+          latency: {
+            value: stats?.avg,
+            lower_value: stats?.min,
+            upper_value: stats?.max
+          },
+          throughput: {
+            value: stats?.iter
+          }
+        }
+      }
+    })
+    .reduce((obj, item) => Object.assign(obj, item), {})
+}
 
 export { executeTaskFunction }