-const crypto = require('node:crypto')
-const assert = require('node:assert')
-const fs = require('node:fs')
+const { randomInt } = require('node:crypto')
+const { strictEqual } = require('node:assert')
+const {
+ existsSync,
+ mkdirSync,
+ readFileSync,
+ rmSync,
+ writeFileSync
+} = require('node:fs')
const Benchmark = require('benchmark')
const {
DynamicClusterPool,
if (executions === taskExecutions) {
resolve({ ok: 1 })
}
- return null
+ return undefined
})
.catch(err => {
console.error(err)
const runPoolifierPoolBenchmark = async (
name,
- pool,
+ workerType,
+ poolType,
+ poolSize,
{ taskExecutions, workerData }
) => {
return await new Promise((resolve, reject) => {
+ const pool = buildPoolifierPool(workerType, poolType, poolSize)
+ const suite = new Benchmark.Suite(name)
try {
- const suite = new Benchmark.Suite(name)
for (const workerChoiceStrategy of Object.values(
WorkerChoiceStrategies
)) {
measurement
})
pool.enableTasksQueue(enableTasksQueue)
- assert.strictEqual(
+ strictEqual(
pool.opts.workerChoiceStrategy,
workerChoiceStrategy
)
- assert.strictEqual(
- pool.opts.enableTasksQueue,
- enableTasksQueue
- )
- assert.strictEqual(
+ strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
+ strictEqual(
pool.opts.workerChoiceStrategyOptions.measurement,
measurement
)
async () => {
pool.setWorkerChoiceStrategy(workerChoiceStrategy)
pool.enableTasksQueue(enableTasksQueue)
- assert.strictEqual(
+ strictEqual(
pool.opts.workerChoiceStrategy,
workerChoiceStrategy
)
- assert.strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
+ strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
await runPoolifierPool(pool, {
taskExecutions,
workerData
.on('cycle', event => {
console.info(event.target.toString())
})
- .on('complete', async function () {
+ .on('complete', function () {
console.info(
'Fastest is ' +
LIST_FORMATTER.format(this.filter('fastest').map('name'))
)
- await pool.destroy()
- resolve()
+ 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) {
- reject(error)
+ pool
+ .destroy()
+ .then(() => {
+ return reject(error)
+ })
+ .catch(() => {})
}
})
}
const readWriteFiles = (
n,
- baseDirectory = `/tmp/poolifier-benchmarks/${crypto.randomInt(
- 281474976710655
- )}`
+ baseDirectory = `/tmp/poolifier-benchmarks/${randomInt(281474976710655)}`
) => {
- if (fs.existsSync(baseDirectory) === true) {
- fs.rmSync(baseDirectory, { recursive: true })
+ if (existsSync(baseDirectory) === true) {
+ rmSync(baseDirectory, { recursive: true })
}
- fs.mkdirSync(baseDirectory, { recursive: true })
+ mkdirSync(baseDirectory, { recursive: true })
for (let i = 0; i < n; i++) {
const filePath = `${baseDirectory}/${i}`
- fs.writeFileSync(filePath, i.toString(), {
+ writeFileSync(filePath, i.toString(), {
encoding: 'utf8',
flag: 'a'
})
- fs.readFileSync(filePath, 'utf8')
+ readFileSync(filePath, 'utf8')
}
- fs.rmSync(baseDirectory, { recursive: true })
+ rmSync(baseDirectory, { recursive: true })
return { ok: 1 }
}
module.exports = {
LIST_FORMATTER,
- buildPoolifierPool,
executeTaskFunction,
generateRandomInteger,
runPoolifierPoolBenchmark