X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=benchmarks%2Finternal%2Fbench.js;h=4663d9c42bf2f27f38b78cb417acbe96bf6f2e86;hb=f167044fd69fd0028160f3a92ad435c37be7de7b;hp=f3a1eb4fda07db3328704cf300f2afb1707a91f4;hpb=2f8c5b5c1182f698efe07d327359bef934af3a29;p=poolifier.git

diff --git a/benchmarks/internal/bench.js b/benchmarks/internal/bench.js
index f3a1eb4f..4663d9c4 100644
--- a/benchmarks/internal/bench.js
+++ b/benchmarks/internal/bench.js
@@ -1,99 +1,387 @@
-const Benchmark = require('benchmark')
+const Benchmark = require('benny')
+const { WorkerChoiceStrategies } = require('../../lib')
 const {
-  dynamicClusterTest,
-  dynamicClusterTestFairShare,
-  dynamicClusterTestLessRecentlyUsed,
-  dynamicClusterTestWeightedRoundRobin
-} = require('./cluster/dynamic')
-const {
-  fixedClusterTest,
-  fixedClusterTestFairShare,
-  fixedClusterTestLessRecentlyUsed,
-  fixedClusterTestWeightedRoundRobin
-} = require('./cluster/fixed')
-const {
-  dynamicThreadTest,
-  dynamicThreadTestFairShare,
-  dynamicThreadTestLessRecentlyUsed,
-  dynamicThreadTestWeightedRoundRobin
-} = require('./thread/dynamic')
-const {
-  fixedThreadTest,
-  fixedThreadTestFairShare,
-  fixedThreadTestLessRecentlyUsed,
-  fixedThreadTestWeightedRoundRobin
-} = require('./thread/fixed')
-const { LIST_FORMATTER } = require('../benchmarks-utils')
+  PoolTypes,
+  WorkerFunctions,
+  WorkerTypes
+} = require('../benchmarks-types')
+const { buildPool, runTest } = require('../benchmarks-utils')
+
+const poolSize = 30
+const taskExecutions = 1
+const workerData = {
+  function: WorkerFunctions.jsonIntegerSerialization,
+  taskSize: 1000
+}
+const tasksQueuePoolOption = { enableTasksQueue: true }
+const workerChoiceStrategyRoundRobinPoolOption = {
+  workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN
+}
+const workerChoiceStrategyLessUsedPoolOption = {
+  workerChoiceStrategy: WorkerChoiceStrategies.LESS_USED
+}
+const workerChoiceStrategyLessBusyPoolOption = {
+  workerChoiceStrategy: WorkerChoiceStrategies.LESS_BUSY
+}
+const workerChoiceStrategyWeightedRoundRobinPoolOption = {
+  workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
+}
+const workerChoiceStrategyFairSharePoolOption = {
+  workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE
+}
+
+const fixedThreadPoolRoundRobin = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyRoundRobinPoolOption
+)
+
+const fixedThreadPoolRoundRobinTasksQueue = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  { ...workerChoiceStrategyRoundRobinPoolOption, ...tasksQueuePoolOption }
+)
+
+const fixedThreadPoolLessUsed = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyLessUsedPoolOption
+)
+
+const fixedThreadPoolLessBusy = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyLessBusyPoolOption
+)
+
+const fixedThreadPoolWeightedRoundRobin = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyWeightedRoundRobinPoolOption
+)
+
+const fixedThreadPoolFairShare = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyFairSharePoolOption
+)
+
+const fixedThreadPoolFairShareTasksQueue = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.FIXED,
+  poolSize,
+  { ...workerChoiceStrategyFairSharePoolOption, ...tasksQueuePoolOption }
+)
+
+const dynamicThreadPoolRoundRobin = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyRoundRobinPoolOption
+)
 
-const suite = new Benchmark.Suite('poolifier')
+const dynamicThreadPoolLessUsed = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyLessUsedPoolOption
+)
 
-// Wait some seconds before start, pools need to load threads !!!
-setTimeout(async () => {
-  test()
-}, 3000)
+const dynamicThreadPoolLessBusy = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyLessBusyPoolOption
+)
 
-async function test () {
-  // Add tests
-  suite
-    .add('Poolifier:Fixed:ThreadPool', async function () {
-      await fixedThreadTest()
+const dynamicThreadPoolWeightedRoundRobin = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyWeightedRoundRobinPoolOption
+)
+
+const dynamicThreadPoolFairShare = buildPool(
+  WorkerTypes.THREAD,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyFairSharePoolOption
+)
+
+const fixedClusterPoolRoundRobin = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyRoundRobinPoolOption
+)
+
+const fixedClusterPoolRoundRobinTasksQueue = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  { ...workerChoiceStrategyRoundRobinPoolOption, ...tasksQueuePoolOption }
+)
+
+const fixedClusterPoolLessUsed = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyLessUsedPoolOption
+)
+
+const fixedClusterPoolLessBusy = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyLessBusyPoolOption
+)
+
+const fixedClusterPoolWeightedRoundRobin = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyWeightedRoundRobinPoolOption
+)
+
+const fixedClusterPoolFairShare = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  workerChoiceStrategyFairSharePoolOption
+)
+
+const fixedClusterPoolFairShareTaskQueue = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.FIXED,
+  poolSize,
+  { ...workerChoiceStrategyFairSharePoolOption, ...tasksQueuePoolOption }
+)
+
+const dynamicClusterPoolRoundRobin = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyRoundRobinPoolOption
+)
+
+const dynamicClusterPoolLessUsed = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyLessUsedPoolOption
+)
+
+const dynamicClusterPoolLessBusy = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyLessBusyPoolOption
+)
+
+const dynamicClusterPoolWeightedRoundRobin = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyWeightedRoundRobinPoolOption
+)
+
+const dynamicClusterPoolFairShare = buildPool(
+  WorkerTypes.CLUSTER,
+  PoolTypes.DYNAMIC,
+  poolSize,
+  workerChoiceStrategyFairSharePoolOption
+)
+
+const resultsFile = 'poolifier'
+const resultsFolder = 'benchmarks/internal/results'
+
+Benchmark.suite(
+  'Poolifier',
+  Benchmark.add('Fixed:ThreadPool:RoundRobin', async () => {
+    await runTest(fixedThreadPoolRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ThreadPool:LessRecentlyUsed', async function () {
-      await fixedThreadTestLessRecentlyUsed()
+  }),
+  Benchmark.add(
+    'Fixed:ThreadPool:RoundRobin:{ enableTasksQueue: true }',
+    async () => {
+      await runTest(fixedThreadPoolRoundRobinTasksQueue, {
+        taskExecutions,
+        workerData
+      })
+    }
+  ),
+  Benchmark.add('Fixed:ThreadPool:LessUsed', async () => {
+    await runTest(fixedThreadPoolLessUsed, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ThreadPool:WeightedRoundRobin', async function () {
-      await fixedThreadTestWeightedRoundRobin()
+  }),
+  Benchmark.add('Fixed:ThreadPool:LessBusy', async () => {
+    await runTest(fixedThreadPoolLessBusy, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ThreadPool:FairShare', async function () {
-      await fixedThreadTestFairShare()
+  }),
+  Benchmark.add('Fixed:ThreadPool:WeightedRoundRobin', async () => {
+    await runTest(fixedThreadPoolWeightedRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ThreadPool', async function () {
-      await dynamicThreadTest()
+  }),
+  Benchmark.add('Fixed:ThreadPool:FairShare', async () => {
+    await runTest(fixedThreadPoolFairShare, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ThreadPool:LessRecentlyUsed', async function () {
-      await dynamicThreadTestLessRecentlyUsed()
+  }),
+  Benchmark.add(
+    'Fixed:ThreadPool:FairShare:{ enableTasksQueue: true }',
+    async () => {
+      await runTest(fixedThreadPoolFairShareTasksQueue, {
+        taskExecutions,
+        workerData
+      })
+    }
+  ),
+  Benchmark.add('Dynamic:ThreadPool:RoundRobin', async () => {
+    await runTest(dynamicThreadPoolRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ThreadPool:WeightedRoundRobin', async function () {
-      await dynamicThreadTestWeightedRoundRobin()
+  }),
+  Benchmark.add('Dynamic:ThreadPool:LessUsed', async () => {
+    await runTest(dynamicThreadPoolLessUsed, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ThreadPool:FairShare', async function () {
-      await dynamicThreadTestFairShare()
+  }),
+  Benchmark.add('Dynamic:ThreadPool:LessBusy', async () => {
+    await runTest(dynamicThreadPoolLessBusy, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ClusterPool', async function () {
-      await fixedClusterTest()
+  }),
+  Benchmark.add('Dynamic:ThreadPool:WeightedRoundRobin', async () => {
+    await runTest(dynamicThreadPoolWeightedRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ClusterPool:LessRecentlyUsed', async function () {
-      await fixedClusterTestLessRecentlyUsed()
+  }),
+  Benchmark.add('Dynamic:ThreadPool:FairShare', async () => {
+    await runTest(dynamicThreadPoolFairShare, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ClusterPool:WeightedRoundRobin', async function () {
-      await fixedClusterTestWeightedRoundRobin
+  }),
+  Benchmark.add('Fixed:ClusterPool:RoundRobin', async () => {
+    await runTest(fixedClusterPoolRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Fixed:ClusterPool:FairShare', async function () {
-      await fixedClusterTestFairShare()
+  }),
+  Benchmark.add(
+    'Fixed:ClusterPool:RoundRobin:{ enableTasksQueue: true }',
+    async () => {
+      await runTest(fixedClusterPoolRoundRobinTasksQueue, {
+        taskExecutions,
+        workerData
+      })
+    }
+  ),
+  Benchmark.add('Fixed:ClusterPool:LessUsed', async () => {
+    await runTest(fixedClusterPoolLessUsed, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ClusterPool', async function () {
-      await dynamicClusterTest()
+  }),
+  Benchmark.add('Fixed:ClusterPool:LessBusy', async () => {
+    await runTest(fixedClusterPoolLessBusy, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ClusterPool:LessRecentlyUsed', async function () {
-      await dynamicClusterTestLessRecentlyUsed()
+  }),
+  Benchmark.add('Fixed:ClusterPool:WeightedRoundRobin', async () => {
+    await runTest(fixedClusterPoolWeightedRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ClusterPool:WeightedRoundRobin', async function () {
-      await dynamicClusterTestWeightedRoundRobin
+  }),
+  Benchmark.add('Fixed:ClusterPool:FairShare', async () => {
+    await runTest(fixedClusterPoolFairShare, {
+      taskExecutions,
+      workerData
     })
-    .add('Poolifier:Dynamic:ClusterPool:FairShare', async function () {
-      await dynamicClusterTestFairShare()
+  }),
+  Benchmark.add(
+    'Fixed:ClusterPool:FairShare:{ enableTasksQueue: true }',
+    async () => {
+      await runTest(fixedClusterPoolFairShareTaskQueue, {
+        taskExecutions,
+        workerData
+      })
+    }
+  ),
+  Benchmark.add('Dynamic:ClusterPool:RoundRobin', async () => {
+    await runTest(dynamicClusterPoolRoundRobin, {
+      taskExecutions,
+      workerData
     })
-    // Add listeners
-    .on('cycle', function (event) {
-      console.log(event.target.toString())
+  }),
+  Benchmark.add('Dynamic:ClusterPool:LessUsed', async () => {
+    await runTest(dynamicClusterPoolLessUsed, {
+      taskExecutions,
+      workerData
     })
-    .on('complete', function () {
-      console.log(
-        'Fastest is ' +
-          LIST_FORMATTER.format(this.filter('fastest').map('name'))
-      )
-      // eslint-disable-next-line n/no-process-exit
-      process.exit()
+  }),
+  Benchmark.add('Dynamic:ClusterPool:LessBusy', async () => {
+    await runTest(dynamicClusterPoolLessBusy, {
+      taskExecutions,
+      workerData
     })
-    .run({ async: true })
-}
+  }),
+  Benchmark.add('Dynamic:ClusterPool:WeightedRoundRobin', async () => {
+    await runTest(dynamicClusterPoolWeightedRoundRobin, {
+      taskExecutions,
+      workerData
+    })
+  }),
+  Benchmark.add('Dynamic:ClusterPool:FairShare', async () => {
+    await runTest(dynamicClusterPoolFairShare, {
+      taskExecutions,
+      workerData
+    })
+  }),
+  Benchmark.cycle(),
+  Benchmark.complete(),
+  Benchmark.save({
+    file: resultsFile,
+    folder: resultsFolder,
+    format: 'json',
+    details: true
+  }),
+  Benchmark.save({
+    file: resultsFile,
+    folder: resultsFolder,
+    format: 'chart.html',
+    details: true
+  }),
+  Benchmark.save({
+    file: resultsFile,
+    folder: resultsFolder,
+    format: 'table.html',
+    details: true
+  })
+)
+  .then(() => {
+    // eslint-disable-next-line n/no-process-exit
+    return process.exit()
+  })
+  .catch(err => console.error(err))