refactor(benchmark): improve benchmark.js code
[poolifier.git] / benchmarks / benchmarks-utils.mjs
1 import { strictEqual } from 'node:assert'
2
3 import Benchmark from 'benchmark'
4 import { bench, group } from 'mitata'
5
6 import {
7 DynamicClusterPool,
8 DynamicThreadPool,
9 FixedClusterPool,
10 FixedThreadPool,
11 Measurements,
12 PoolTypes,
13 WorkerChoiceStrategies,
14 WorkerTypes
15 } from '../lib/index.mjs'
16 import { executeTaskFunction } from './benchmarks-utils.cjs'
17
18 const buildPoolifierPool = (workerType, poolType, poolSize, poolOptions) => {
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.cjs',
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.cjs',
50 poolOptions
51 )
52 }
53 break
54 }
55 }
56
57 const runPoolifierPool = async (pool, { taskExecutions, workerData }) => {
58 return await new Promise((resolve, reject) => {
59 let executions = 0
60 for (let i = 1; i <= taskExecutions; i++) {
61 pool
62 .execute(workerData)
63 .then(() => {
64 ++executions
65 if (executions === taskExecutions) {
66 resolve({ ok: 1 })
67 }
68 return undefined
69 })
70 .catch(err => {
71 console.error(err)
72 reject(err)
73 })
74 }
75 })
76 }
77
78 export const runPoolifierBenchmarkBenchmarkJs = async (
79 name,
80 workerType,
81 poolType,
82 poolSize,
83 { taskExecutions, workerData }
84 ) => {
85 return await new Promise((resolve, reject) => {
86 let pool = buildPoolifierPool(workerType, poolType, poolSize)
87 try {
88 const suite = new Benchmark.Suite(name, {
89 onComplete: () => {
90 const destroyTimeout = setTimeout(() => {
91 console.error('Pool destroy timeout reached (30s)')
92 resolve()
93 pool = undefined
94 }, 30000)
95 pool
96 .destroy()
97 .then(resolve)
98 .catch(reject)
99 .finally(() => {
100 clearTimeout(destroyTimeout)
101 })
102 .catch(() => {})
103 },
104 onCycle: event => {
105 console.info(event.target.toString())
106 },
107 onError: event => {
108 pool
109 .destroy()
110 .then(() => {
111 return reject(event.target.error)
112 })
113 .catch(() => {})
114 }
115 })
116 for (const workerChoiceStrategy of Object.values(
117 WorkerChoiceStrategies
118 )) {
119 for (const enableTasksQueue of [false, true]) {
120 if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
121 for (const measurement of [
122 Measurements.runTime,
123 Measurements.elu
124 ]) {
125 suite.add(
126 `${name} with ${workerChoiceStrategy}, with measurement ${measurement} and ${
127 enableTasksQueue ? 'with' : 'without'
128 } tasks queue`,
129 async () => {
130 await runPoolifierPool(pool, {
131 taskExecutions,
132 workerData
133 })
134 },
135 {
136 onStart: () => {
137 pool.setWorkerChoiceStrategy(workerChoiceStrategy, {
138 measurement
139 })
140 pool.enableTasksQueue(enableTasksQueue)
141 strictEqual(
142 pool.opts.workerChoiceStrategy,
143 workerChoiceStrategy
144 )
145 strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
146 strictEqual(
147 pool.opts.workerChoiceStrategyOptions.measurement,
148 measurement
149 )
150 }
151 }
152 )
153 }
154 } else {
155 suite.add(
156 `${name} with ${workerChoiceStrategy} and ${
157 enableTasksQueue ? 'with' : 'without'
158 } tasks queue`,
159 async () => {
160 await runPoolifierPool(pool, {
161 taskExecutions,
162 workerData
163 })
164 },
165 {
166 onStart: () => {
167 pool.setWorkerChoiceStrategy(workerChoiceStrategy)
168 pool.enableTasksQueue(enableTasksQueue)
169 strictEqual(
170 pool.opts.workerChoiceStrategy,
171 workerChoiceStrategy
172 )
173 strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
174 }
175 }
176 )
177 }
178 }
179 }
180 suite
181 .on('complete', function () {
182 console.info(
183 'Fastest is ' +
184 LIST_FORMATTER.format(this.filter('fastest').map('name'))
185 )
186 })
187 .run({ async: true, queued: true })
188 } catch (error) {
189 pool
190 .destroy()
191 .then(() => {
192 return reject(error)
193 })
194 .catch(() => {})
195 }
196 })
197 }
198
199 export const buildPoolifierBenchmarkMitata = (
200 name,
201 workerType,
202 poolType,
203 poolSize,
204 { taskExecutions, workerData }
205 ) => {
206 try {
207 const pool = buildPoolifierPool(workerType, poolType, poolSize)
208 for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
209 for (const enableTasksQueue of [false, true]) {
210 if (workerChoiceStrategy === WorkerChoiceStrategies.FAIR_SHARE) {
211 for (const measurement of [Measurements.runTime, Measurements.elu]) {
212 group(name, () => {
213 bench(
214 `${name} with ${workerChoiceStrategy}, with ${measurement} and ${
215 enableTasksQueue ? 'with' : 'without'
216 } tasks queue`,
217 async () => {
218 pool.setWorkerChoiceStrategy(workerChoiceStrategy, {
219 measurement
220 })
221 pool.enableTasksQueue(enableTasksQueue)
222 strictEqual(
223 pool.opts.workerChoiceStrategy,
224 workerChoiceStrategy
225 )
226 strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
227 strictEqual(
228 pool.opts.workerChoiceStrategyOptions.measurement,
229 measurement
230 )
231 await runPoolifierPool(pool, {
232 taskExecutions,
233 workerData
234 })
235 }
236 )
237 })
238 }
239 } else {
240 group(name, () => {
241 bench(
242 `${name} with ${workerChoiceStrategy} and ${
243 enableTasksQueue ? 'with' : 'without'
244 } tasks queue`,
245 async () => {
246 pool.setWorkerChoiceStrategy(workerChoiceStrategy)
247 pool.enableTasksQueue(enableTasksQueue)
248 strictEqual(
249 pool.opts.workerChoiceStrategy,
250 workerChoiceStrategy
251 )
252 strictEqual(pool.opts.enableTasksQueue, enableTasksQueue)
253 await runPoolifierPool(pool, {
254 taskExecutions,
255 workerData
256 })
257 }
258 )
259 })
260 }
261 }
262 }
263 return pool
264 } catch (error) {
265 console.error(error)
266 }
267 }
268
269 const LIST_FORMATTER = new Intl.ListFormat('en-US', {
270 style: 'long',
271 type: 'conjunction'
272 })
273
274 export { executeTaskFunction }