X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=benchmarks%2Fbenchmarks-utils.cjs;h=c3b470f7a152724e6729b1dc29ccb1bb58fa3761;hb=5b95eb9bcafda56ce57003da834cf4e153bb0509;hp=4dd1227b00b2362b393b47113e70a154aad6fe87;hpb=c7ed5d3b88f8f2c75675d953a4e9df87a3d9a54c;p=poolifier.git

diff --git a/benchmarks/benchmarks-utils.cjs b/benchmarks/benchmarks-utils.cjs
index 4dd1227b..c3b470f7 100644
--- a/benchmarks/benchmarks-utils.cjs
+++ b/benchmarks/benchmarks-utils.cjs
@@ -1,5 +1,4 @@
 const { randomInt } = require('node:crypto')
-const { strictEqual } = require('node:assert')
 const {
   existsSync,
   mkdirSync,
@@ -7,185 +6,8 @@ const {
   rmSync,
   writeFileSync
 } = require('node:fs')
-const Benchmark = require('benchmark')
-const {
-  DynamicClusterPool,
-  DynamicThreadPool,
-  FixedClusterPool,
-  FixedThreadPool,
-  Measurements,
-  PoolTypes,
-  WorkerChoiceStrategies,
-  WorkerTypes
-} = require('../lib/index.cjs')
 const { TaskFunctions } = require('./benchmarks-types.cjs')
 
-const buildPoolifierPool = (workerType, poolType, poolSize, poolOptions) => {
-  switch (poolType) {
-    case PoolTypes.fixed:
-      switch (workerType) {
-        case WorkerTypes.thread:
-          return new FixedThreadPool(
-            poolSize,
-            './benchmarks/internal/thread-worker.mjs',
-            poolOptions
-          )
-        case WorkerTypes.cluster:
-          return new FixedClusterPool(
-            poolSize,
-            './benchmarks/internal/cluster-worker.cjs',
-            poolOptions
-          )
-      }
-      break
-    case PoolTypes.dynamic:
-      switch (workerType) {
-        case WorkerTypes.thread:
-          return new DynamicThreadPool(
-            Math.floor(poolSize / 2),
-            poolSize,
-            './benchmarks/internal/thread-worker.mjs',
-            poolOptions
-          )
-        case WorkerTypes.cluster:
-          return new DynamicClusterPool(
-            Math.floor(poolSize / 2),
-            poolSize,
-            './benchmarks/internal/cluster-worker.cjs',
-            poolOptions
-          )
-      }
-      break
-  }
-}
-
-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)
-        })
-    }
-  })
-}
-
-const runPoolifierPoolBenchmark = 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)
-    try {
-      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 () => {
-                  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
-                  })
-                }
-              )
-            }
-          } else {
-            suite.add(
-              `${name} with ${workerChoiceStrategy} and ${
-                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
-                })
-              }
-            )
-          }
-        }
-      }
-      suite
-        .on('cycle', event => {
-          console.info(event.target.toString())
-        })
-        .on('complete', function () {
-          console.info(
-            'Fastest is ' +
-              LIST_FORMATTER.format(this.filter('fastest').map('name'))
-          )
-          const destroyTimeout = setTimeout(() => {
-            console.error('Pool destroy timeout reached (30s)')
-            resolve()
-          }, 30000)
-          pool
-            .destroy()
-            .then(resolve)
-            .catch(reject)
-            .finally(() => {
-              clearTimeout(destroyTimeout)
-            })
-            .catch(() => {})
-        })
-        .run({ async: true })
-    } catch (error) {
-      pool
-        .destroy()
-        .then(() => {
-          return reject(error)
-        })
-        .catch(() => {})
-    }
-  })
-}
-
-const LIST_FORMATTER = new Intl.ListFormat('en-US', {
-  style: 'long',
-  type: 'conjunction'
-})
-
 const jsonIntegerSerialization = n => {
   for (let i = 0; i < n; i++) {
     const o = {
@@ -197,25 +19,38 @@ const jsonIntegerSerialization = n => {
 }
 
 /**
- * Intentionally inefficient implementation.
  * @param {number} n - The number of fibonacci numbers to generate.
  * @returns {number} - The nth fibonacci number.
  */
 const fibonacci = n => {
-  if (n <= 1) return n
-  return fibonacci(n - 1) + fibonacci(n - 2)
+  n = BigInt(n)
+  let current = 1n
+  let previous = 0n
+  while (--n) {
+    const tmp = current
+    current += previous
+    previous = tmp
+  }
+  // cluster worker do not support BigInt
+  return current.toString()
 }
 
 /**
- * Intentionally inefficient implementation.
  * @param {number} n - The number to calculate the factorial of.
  * @returns {number} - The factorial of n.
  */
 const factorial = n => {
-  if (n === 0) {
-    return 1
+  if (n === 0 || n === 1) {
+    return 1n
+  } else {
+    n = BigInt(n)
+    let factorial = 1n
+    for (let i = 1n; i <= n; i++) {
+      factorial *= i
+    }
+    // cluster worker do not support BigInt
+    return factorial.toString()
   }
-  return factorial(n - 1) * n
 }
 
 const readWriteFiles = (
@@ -254,7 +89,5 @@ const executeTaskFunction = data => {
 }
 
 module.exports = {
-  LIST_FORMATTER,
-  executeTaskFunction,
-  runPoolifierPoolBenchmark
+  executeTaskFunction
 }