-const { WorkerFunctions } = require('./benchmarks-types')
+const crypto = require('crypto')
+const fs = require('fs')
+const {
+ DynamicClusterPool,
+ DynamicThreadPool,
+ FixedClusterPool,
+ FixedThreadPool
+} = require('../lib')
+const {
+ PoolTypes,
+ WorkerFunctions,
+ WorkerTypes
+} = require('./benchmarks-types')
-async function runPoolifierTest (pool, { tasks, workerData }) {
+async function runTest (pool, { taskExecutions, workerData }) {
return new Promise((resolve, reject) => {
let executions = 0
- for (let i = 1; i <= tasks; i++) {
+ for (let i = 1; i <= taskExecutions; i++) {
pool
.execute(workerData)
.then(() => {
- executions++
- if (executions === tasks) {
+ ++executions
+ if (executions === taskExecutions) {
return resolve({ ok: 1 })
}
return null
})
}
+function 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))
+}
+
function jsonIntegerSerialization (n) {
for (let i = 0; i < n; i++) {
const o = {
}
}
-function generateRandomInteger (max = Number.MAX_SAFE_INTEGER, min = 0) {
- max = Math.floor(max)
- if (min) {
- min = Math.ceil(min)
- return Math.floor(Math.random() * (max - min + 1)) + min
- }
- return Math.floor(Math.random() * (max + 1))
-}
-
/**
* Intentionally inefficient implementation.
- *
* @param {number} n - The number of fibonacci numbers to generate.
* @returns {number} - The nth fibonacci number.
*/
/**
* Intentionally inefficient implementation.
- *
* @param {number} n - The number to calculate the factorial of.
* @returns {number} - The factorial of n.
*/
function factorial (n) {
if (n === 0) {
return 1
- } else {
- return factorial(n - 1) * n
}
+ return factorial(n - 1) * n
+}
+
+function 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 })
}
function executeWorkerFunction (data) {
return fibonacci(data.taskSize || 1000)
case WorkerFunctions.factorial:
return factorial(data.taskSize || 1000)
+ case WorkerFunctions.readWriteFiles:
+ return readWriteFiles(data.taskSize || 1000)
default:
throw new Error('Unknown worker function')
}
}
+function buildPool (workerType, poolType, poolSize, poolOptions) {
+ switch (poolType) {
+ case PoolTypes.fixed:
+ switch (workerType) {
+ case WorkerTypes.thread:
+ return new FixedThreadPool(
+ poolSize,
+ './benchmarks/internal/thread-worker.js',
+ poolOptions
+ )
+ case WorkerTypes.cluster:
+ return new FixedClusterPool(
+ poolSize,
+ './benchmarks/internal/cluster-worker.js',
+ poolOptions
+ )
+ }
+ break
+ case PoolTypes.dynamic:
+ switch (workerType) {
+ case WorkerTypes.thread:
+ return new DynamicThreadPool(
+ poolSize / 2,
+ poolSize * 3,
+ './benchmarks/internal/thread-worker.js',
+ poolOptions
+ )
+ case WorkerTypes.cluster:
+ return new DynamicClusterPool(
+ poolSize / 2,
+ poolSize * 3,
+ './benchmarks/internal/cluster-worker.js',
+ poolOptions
+ )
+ }
+ break
+ }
+}
+
module.exports = {
WorkerFunctions,
+ buildPool,
executeWorkerFunction,
generateRandomInteger,
- runPoolifierTest
+ readWriteFiles,
+ runTest
}