medWaitTime: false
})
}
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
pool.setWorkerChoiceStrategyOptions({ medRunTime: true })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: true })
}
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: false,
medRunTime: true,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
pool.setWorkerChoiceStrategyOptions({ medRunTime: false })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
.workerChoiceStrategies) {
expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: false })
}
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
})
)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
waitTimeHistory: expect.any(CircularArray),
avgWaitTime: 0,
medWaitTime: 0,
- error: 0
+ error: 0,
+ elu: undefined
})
}
await pool.destroy()
}
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: maxMultiplier,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
waitTimeHistory: expect.any(CircularArray),
avgWaitTime: 0,
medWaitTime: 0,
- error: 0
+ error: 0,
+ elu: undefined
})
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
+ ran: maxMultiplier,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
waitTimeHistory: expect.any(CircularArray),
avgWaitTime: 0,
medWaitTime: 0,
- error: 0
+ error: 0,
+ elu: undefined
})
}
await pool.destroy()
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
+ ran: expect.any(Number),
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
waitTimeHistory: expect.any(CircularArray),
avgWaitTime: 0,
medWaitTime: 0,
- error: 0
+ error: 0,
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(maxMultiplier)
+ expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(maxMultiplier)
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
waitTimeHistory: expect.any(CircularArray),
avgWaitTime: 0,
medWaitTime: 0,
- error: 0
+ error: 0,
+ elu: undefined
})
expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
expect(workerNode.tasksUsage.waitTimeHistory.length).toBe(0)
)
const promises = new Set()
let poolFull = 0
- pool.emitter.on(PoolEvents.full, () => ++poolFull)
+ let poolInfo
+ pool.emitter.on(PoolEvents.full, info => {
+ ++poolFull
+ poolInfo = info
+ })
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
// The `full` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
// So in total numberOfWorkers * 2 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool with min = max = numberOfWorkers.
expect(poolFull).toBe(numberOfWorkers * 2)
+ expect(poolInfo).toStrictEqual({
+ type: PoolTypes.dynamic,
+ worker: WorkerTypes.thread,
+ minSize: expect.any(Number),
+ maxSize: expect.any(Number),
+ workerNodes: expect.any(Number),
+ idleWorkerNodes: expect.any(Number),
+ busyWorkerNodes: expect.any(Number),
+ runningTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ maxQueuedTasks: expect.any(Number)
+ })
await pool.destroy()
})
)
const promises = new Set()
let poolBusy = 0
- pool.emitter.on(PoolEvents.busy, () => ++poolBusy)
+ let poolInfo
+ pool.emitter.on(PoolEvents.busy, info => {
+ ++poolBusy
+ poolInfo = info
+ })
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
// The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
// So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
expect(poolBusy).toBe(numberOfWorkers + 1)
+ expect(poolInfo).toStrictEqual({
+ type: PoolTypes.fixed,
+ worker: WorkerTypes.thread,
+ minSize: expect.any(Number),
+ maxSize: expect.any(Number),
+ workerNodes: expect.any(Number),
+ idleWorkerNodes: expect.any(Number),
+ busyWorkerNodes: expect.any(Number),
+ runningTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ maxQueuedTasks: expect.any(Number)
+ })
await pool.destroy()
})