X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=benchmarks%2Fbenchmarks-utils.mjs;h=1878988f2ab5491c87ec7a73adcc287e590228b4;hb=0804b9b4106132c5487b57be518958c699ce2563;hp=259fca5696b0a32c62c040966196ed78f052d9ca;hpb=fef029a52aacd3063ba882834ce58527600009ca;p=poolifier.git diff --git a/benchmarks/benchmarks-utils.mjs b/benchmarks/benchmarks-utils.mjs index 259fca56..1878988f 100644 --- a/benchmarks/benchmarks-utils.mjs +++ b/benchmarks/benchmarks-utils.mjs @@ -1,121 +1,20 @@ -import crypto from 'node:crypto' -import fs from 'node:fs' +import { strictEqual } from 'node:assert' + +import Benchmark from 'benchmark' +import { bench, group } from 'mitata' + import { DynamicClusterPool, DynamicThreadPool, FixedClusterPool, FixedThreadPool, + Measurements, PoolTypes, + WorkerChoiceStrategies, WorkerTypes } from '../lib/index.mjs' -import { TaskFunctions } from './benchmarks-types.mjs' - -export const runTest = async (pool, { taskExecutions, workerData }) => { - return new Promise((resolve, reject) => { - let executions = 0 - for (let i = 1; i <= taskExecutions; i++) { - pool - .execute(workerData) - .then(() => { - ++executions - if (executions === taskExecutions) { - return resolve({ ok: 1 }) - } - return null - }) - .catch(err => { - console.error(err) - return reject(err) - }) - } - }) -} -export const generateRandomInteger = ( - max = Number.MAX_SAFE_INTEGER, - min = 0 -) => { - if (max < min || max < 0 || min < 0) { - throw new RangeError('Invalid interval') - } - max = Math.floor(max) - if (min != null && min !== 0) { - min = Math.ceil(min) - return Math.floor(Math.random() * (max - min + 1)) + min - } - return Math.floor(Math.random() * (max + 1)) -} - -const jsonIntegerSerialization = n => { - for (let i = 0; i < n; i++) { - const o = { - a: i - } - JSON.stringify(o) - } - return { ok: 1 } -} - -/** - * 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) -} - -/** - * 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 - } - return factorial(n - 1) * n -} - -const readWriteFiles = ( - n, - baseDirectory = `/tmp/poolifier-benchmarks/${crypto.randomInt( - 281474976710655 - )}` -) => { - if (fs.existsSync(baseDirectory) === true) { - fs.rmSync(baseDirectory, { recursive: true }) - } - fs.mkdirSync(baseDirectory, { recursive: true }) - for (let i = 0; i < n; i++) { - const filePath = `${baseDirectory}/${i}` - fs.writeFileSync(filePath, i.toString(), { - encoding: 'utf8', - flag: 'a' - }) - fs.readFileSync(filePath, 'utf8') - } - fs.rmSync(baseDirectory, { recursive: true }) - return { ok: 1 } -} - -export const executeTaskFunction = data => { - switch (data.function) { - case TaskFunctions.jsonIntegerSerialization: - return jsonIntegerSerialization(data.taskSize || 1000) - case TaskFunctions.fibonacci: - return fibonacci(data.taskSize || 1000) - case TaskFunctions.factorial: - return factorial(data.taskSize || 1000) - case TaskFunctions.readWriteFiles: - return readWriteFiles(data.taskSize || 1000) - default: - throw new Error('Unknown task function') - } -} - -export const buildPool = (workerType, poolType, poolSize, poolOptions) => { +const buildPoolifierPool = (workerType, poolType, poolSize, poolOptions) => { switch (poolType) { case PoolTypes.fixed: switch (workerType) { @@ -128,7 +27,7 @@ export const buildPool = (workerType, poolType, poolSize, poolOptions) => { case WorkerTypes.cluster: return new FixedClusterPool( poolSize, - './benchmarks/internal/cluster-worker.mjs', + './benchmarks/internal/cluster-worker.cjs', poolOptions ) } @@ -146,10 +45,207 @@ export const buildPool = (workerType, poolType, poolSize, poolOptions) => { return new DynamicClusterPool( Math.floor(poolSize / 2), poolSize, - './benchmarks/internal/cluster-worker.mjs', + './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) + }) + } + }) +} + +export const runPoolifierBenchmarkBenchmarkJs = async ( + name, + workerType, + poolType, + poolSize, + { taskExecutions, workerData } +) => { + return await new Promise((resolve, reject) => { + const pool = buildPoolifierPool(workerType, poolType, poolSize) + try { + const suite = new Benchmark.Suite(name) + 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(() => {}) + } + }) +} + +export const buildPoolifierBenchmarkMitata = ( + name, + workerType, + poolType, + poolSize, + { taskExecutions, workerData } +) => { + try { + const pool = buildPoolifierPool(workerType, poolType, poolSize) + 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]) { + group(name, () => { + bench( + `${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 { + group(name, () => { + bench( + `${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 + }) + } + ) + }) + } + } + } + return pool + } catch (error) { + console.error(error) + } +} + +const LIST_FORMATTER = new Intl.ListFormat('en-US', { + style: 'long', + type: 'conjunction' +})