benchmarks/benchmarks-utils.mjs

   1 import crypto from 'node:crypto'
   2 import fs from 'node:fs'
   3 import {
   4   DynamicClusterPool,
   5   DynamicThreadPool,
   6   FixedClusterPool,
   7   FixedThreadPool,
   8   PoolTypes,
   9   WorkerTypes
  10 } from '../lib/index.mjs'
  11 import { TaskFunctions } from './benchmarks-types.mjs'
  12
  13 export const buildPoolifierPool = (
  14   workerType,
  15   poolType,
  16   poolSize,
  17   poolOptions
  18 ) => {
  19   switch (poolType) {
  20     case PoolTypes.fixed:
  21       switch (workerType) {
  22         case WorkerTypes.thread:
  23           return new FixedThreadPool(
  24             poolSize,
  25             './benchmarks/internal/thread-worker.mjs',
  26             poolOptions
  27           )
  28         case WorkerTypes.cluster:
  29           return new FixedClusterPool(
  30             poolSize,
  31             './benchmarks/internal/cluster-worker.mjs',
  32             poolOptions
  33           )
  34       }
  35       break
  36     case PoolTypes.dynamic:
  37       switch (workerType) {
  38         case WorkerTypes.thread:
  39           return new DynamicThreadPool(
  40             Math.floor(poolSize / 2),
  41             poolSize,
  42             './benchmarks/internal/thread-worker.mjs',
  43             poolOptions
  44           )
  45         case WorkerTypes.cluster:
  46           return new DynamicClusterPool(
  47             Math.floor(poolSize / 2),
  48             poolSize,
  49             './benchmarks/internal/cluster-worker.mjs',
  50             poolOptions
  51           )
  52       }
  53       break
  54   }
  55 }
  56
  57 export const runPoolifierTest = async (
  58   pool,
  59   { taskExecutions, workerData }
  60 ) => {
  61   return new Promise((resolve, reject) => {
  62     let executions = 0
  63     for (let i = 1; i <= taskExecutions; i++) {
  64       pool
  65         .execute(workerData)
  66         .then(() => {
  67           ++executions
  68           if (executions === taskExecutions) {
  69             return resolve({ ok: 1 })
  70           }
  71           return null
  72         })
  73         .catch(err => {
  74           console.error(err)
  75           return reject(err)
  76         })
  77     }
  78   })
  79 }
  80
  81 export const executeAsyncFn = async fn => {
  82   try {
  83     await fn()
  84   } catch (e) {
  85     console.error(e)
  86     // eslint-disable-next-line n/no-process-exit
  87     process.exit(1)
  88   }
  89 }
  90
  91 export const generateRandomInteger = (
  92   max = Number.MAX_SAFE_INTEGER,
  93   min = 0
  94 ) => {
  95   if (max < min || max < 0 || min < 0) {
  96     throw new RangeError('Invalid interval')
  97   }
  98   max = Math.floor(max)
  99   if (min != null && min !== 0) {
 100     min = Math.ceil(min)
 101     return Math.floor(Math.random() * (max - min + 1)) + min
 102   }
 103   return Math.floor(Math.random() * (max + 1))
 104 }
 105
 106 const jsonIntegerSerialization = n => {
 107   for (let i = 0; i < n; i++) {
 108     const o = {
 109       a: i
 110     }
 111     JSON.stringify(o)
 112   }
 113   return { ok: 1 }
 114 }
 115
 116 /**
 117  * Intentionally inefficient implementation.
 118  * @param {number} n - The number of fibonacci numbers to generate.
 119  * @returns {number} - The nth fibonacci number.
 120  */
 121 const fibonacci = n => {
 122   if (n <= 1) return n
 123   return fibonacci(n - 1) + fibonacci(n - 2)
 124 }
 125
 126 /**
 127  * Intentionally inefficient implementation.
 128  * @param {number} n - The number to calculate the factorial of.
 129  * @returns {number} - The factorial of n.
 130  */
 131 const factorial = n => {
 132   if (n === 0) {
 133     return 1
 134   }
 135   return factorial(n - 1) * n
 136 }
 137
 138 const readWriteFiles = (
 139   n,
 140   baseDirectory = `/tmp/poolifier-benchmarks/${crypto.randomInt(
 141     281474976710655
 142   )}`
 143 ) => {
 144   if (fs.existsSync(baseDirectory) === true) {
 145     fs.rmSync(baseDirectory, { recursive: true })
 146   }
 147   fs.mkdirSync(baseDirectory, { recursive: true })
 148   for (let i = 0; i < n; i++) {
 149     const filePath = `${baseDirectory}/${i}`
 150     fs.writeFileSync(filePath, i.toString(), {
 151       encoding: 'utf8',
 152       flag: 'a'
 153     })
 154     fs.readFileSync(filePath, 'utf8')
 155   }
 156   fs.rmSync(baseDirectory, { recursive: true })
 157   return { ok: 1 }
 158 }
 159
 160 export const executeTaskFunction = data => {
 161   switch (data.function) {
 162     case TaskFunctions.jsonIntegerSerialization:
 163       return jsonIntegerSerialization(data.taskSize || 1000)
 164     case TaskFunctions.fibonacci:
 165       return fibonacci(data.taskSize || 1000)
 166     case TaskFunctions.factorial:
 167       return factorial(data.taskSize || 1000)
 168     case TaskFunctions.readWriteFiles:
 169       return readWriteFiles(data.taskSize || 1000)
 170     default:
 171       throw new Error('Unknown task function')
 172   }
 173 }