import { strictEqual } from 'node:assert'
import Benchmark from 'benchmark'
-import { bench, group } from 'mitata'
+import { bench, clear, group, run } from 'tatami-ng'
import {
DynamicClusterPool,
}
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,
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 () => {
})
}
-export const buildPoolifierBenchmarkMitata = (
+export const runPoolifierBenchmarkTatamiNg = async (
name,
workerType,
poolType,
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
+ )
+ }
}
)
})
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)
}