Merge branch 'master' into waittime

diff --git a/.eslintrc.js b/.eslintrc.js
index d7004cc55ff8460161f54f766086dd78d7612eb8..0b465dadff597167df9220f9715c1f8724b010c3 100644 (file)
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -38,6 +38,10 @@ module.exports = defineConfig({
       {
         skipWords: [
           'Benoit',
+          'Uint8',
+          'Uint16',
+          'Uint32',
+          'Uint64',
           'benny',
           'browserslist',
           'builtins',

diff --git a/src/pools/abstract-pool.ts b/src/pools/abstract-pool.ts
index 4c82ef08a8cdad70602ebf20a64235b1cb3833f0..2e769fc9c2660305bbbb84ab370468e7d4326da0 100644 (file)
--- a/src/pools/abstract-pool.ts
+++ b/src/pools/abstract-pool.ts
@@ -263,6 +263,10 @@ export abstract class AbstractPool<
         runTimeHistory: new CircularArray(),
         avgRunTime: 0,
         medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: new CircularArray(),
+        avgWaitTime: 0,
+        medWaitTime: 0,
         error: 0
       })
     }
@@ -340,11 +344,13 @@ export abstract class AbstractPool<
 
   /** @inheritDoc */
   public async execute (data?: Data, name?: string): Promise<Response> {
+    const submissionTimestamp = performance.now()
     const workerNodeKey = this.chooseWorkerNode()
     const submittedTask: Task<Data> = {
       name,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       data: data ?? ({} as Data),
+      submissionTimestamp,
       id: crypto.randomUUID()
     }
     const res = new Promise<Response>((resolve, reject) => {
@@ -448,6 +454,23 @@ export abstract class AbstractPool<
         workerTasksUsage.medRunTime = median(workerTasksUsage.runTimeHistory)
       }
     }
+    if (this.workerChoiceStrategyContext.getRequiredStatistics().waitTime) {
+      workerTasksUsage.waitTime += message.waitTime ?? 0
+      if (
+        this.workerChoiceStrategyContext.getRequiredStatistics().avgWaitTime &&
+        workerTasksUsage.run !== 0
+      ) {
+        workerTasksUsage.avgWaitTime =
+          workerTasksUsage.waitTime / workerTasksUsage.run
+      }
+      if (
+        this.workerChoiceStrategyContext.getRequiredStatistics().medWaitTime &&
+        message.waitTime != null
+      ) {
+        workerTasksUsage.waitTimeHistory.push(message.waitTime)
+        workerTasksUsage.medWaitTime = median(workerTasksUsage.waitTimeHistory)
+      }
+    }
   }
 
   /**
@@ -611,6 +634,10 @@ export abstract class AbstractPool<
         runTimeHistory: new CircularArray(),
         avgRunTime: 0,
         medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: new CircularArray(),
+        avgWaitTime: 0,
+        medWaitTime: 0,
         error: 0
       },
       tasksQueue: new Queue<Task<Data>>()

diff --git a/src/pools/selection-strategies/abstract-worker-choice-strategy.ts b/src/pools/selection-strategies/abstract-worker-choice-strategy.ts
index d969f0c0ad5ca224de0d30356d517821b1e76c3c..efa9578d8b2f889630aadec6da595ded93cd087f 100644 (file)
--- a/src/pools/selection-strategies/abstract-worker-choice-strategy.ts
+++ b/src/pools/selection-strategies/abstract-worker-choice-strategy.ts
@@ -27,7 +27,10 @@ export abstract class AbstractWorkerChoiceStrategy<
   public readonly requiredStatistics: RequiredStatistics = {
     runTime: false,
     avgRunTime: false,
-    medRunTime: false
+    medRunTime: false,
+    waitTime: false,
+    avgWaitTime: false,
+    medWaitTime: false
   }
 
   /**
@@ -52,6 +55,14 @@ export abstract class AbstractWorkerChoiceStrategy<
       this.requiredStatistics.avgRunTime = true
       this.requiredStatistics.medRunTime = opts.medRunTime as boolean
     }
+    if (this.requiredStatistics.avgWaitTime && opts.medWaitTime === true) {
+      this.requiredStatistics.avgWaitTime = false
+      this.requiredStatistics.medWaitTime = opts.medWaitTime as boolean
+    }
+    if (this.requiredStatistics.medWaitTime && opts.medWaitTime === false) {
+      this.requiredStatistics.avgWaitTime = true
+      this.requiredStatistics.medWaitTime = opts.medWaitTime as boolean
+    }
   }
 
   /** @inheritDoc */

diff --git a/src/pools/selection-strategies/fair-share-worker-choice-strategy.ts b/src/pools/selection-strategies/fair-share-worker-choice-strategy.ts
index e26f6b8f5953dff0b3d6dc1d59469977ab264494..56d9dc361fe6e70255877ec6c1e6be6f33b70a70 100644 (file)
--- a/src/pools/selection-strategies/fair-share-worker-choice-strategy.ts
+++ b/src/pools/selection-strategies/fair-share-worker-choice-strategy.ts
@@ -27,7 +27,10 @@ export class FairShareWorkerChoiceStrategy<
   public readonly requiredStatistics: RequiredStatistics = {
     runTime: true,
     avgRunTime: true,
-    medRunTime: false
+    medRunTime: false,
+    waitTime: false,
+    avgWaitTime: false,
+    medWaitTime: false
   }
 
   /**

diff --git a/src/pools/selection-strategies/least-busy-worker-choice-strategy.ts b/src/pools/selection-strategies/least-busy-worker-choice-strategy.ts
index 05caa42a0149ebc7dc29ef76edc3a025e8b24c2c..6e413825d666025022acf6018dfe47c77e8345fe 100644 (file)
--- a/src/pools/selection-strategies/least-busy-worker-choice-strategy.ts
+++ b/src/pools/selection-strategies/least-busy-worker-choice-strategy.ts
@@ -26,7 +26,10 @@ export class LeastBusyWorkerChoiceStrategy<
   public readonly requiredStatistics: RequiredStatistics = {
     runTime: true,
     avgRunTime: false,
-    medRunTime: false
+    medRunTime: false,
+    waitTime: false,
+    avgWaitTime: false,
+    medWaitTime: false
   }
 
   /** @inheritDoc */

diff --git a/src/pools/selection-strategies/selection-strategies-types.ts b/src/pools/selection-strategies/selection-strategies-types.ts
index 282e306db18a4c55bb1016e078ce8456ff64d843..c90036fe6f269dd7757482064a3fdba0b7a97e97 100644 (file)
--- a/src/pools/selection-strategies/selection-strategies-types.ts
+++ b/src/pools/selection-strategies/selection-strategies-types.ts
@@ -39,6 +39,12 @@ export interface WorkerChoiceStrategyOptions {
    * @defaultValue false
    */
   medRunTime?: boolean
+  /**
+   * Use tasks median wait time instead of average runtime.
+   *
+   * @defaultValue false
+   */
+  medWaitTime?: boolean
   /**
    * Worker weights to use for weighted round robin worker selection strategy.
    * Weight is the tasks maximum average or median runtime in milliseconds.
@@ -66,6 +72,18 @@ export interface RequiredStatistics {
    * Require tasks median runtime.
    */
   medRunTime: boolean
+  /**
+   * Require tasks wait time.
+   */
+  waitTime: boolean
+  /**
+   * Require tasks average wait time.
+   */
+  avgWaitTime: boolean
+  /**
+   * Require tasks median wait time.
+   */
+  medWaitTime: boolean
 }
 
 /**

diff --git a/src/pools/selection-strategies/weighted-round-robin-worker-choice-strategy.ts b/src/pools/selection-strategies/weighted-round-robin-worker-choice-strategy.ts
index a0553fcb81ace9c910b1ecd755b9c123b640f362..df45feb3829a4972962d1f51aeeb1e7bcfbc1d7d 100644 (file)
--- a/src/pools/selection-strategies/weighted-round-robin-worker-choice-strategy.ts
+++ b/src/pools/selection-strategies/weighted-round-robin-worker-choice-strategy.ts
@@ -28,7 +28,10 @@ export class WeightedRoundRobinWorkerChoiceStrategy<
   public readonly requiredStatistics: RequiredStatistics = {
     runTime: true,
     avgRunTime: true,
-    medRunTime: false
+    medRunTime: false,
+    waitTime: false,
+    avgWaitTime: false,
+    medWaitTime: false
   }
 
   /**

diff --git a/src/pools/worker.ts b/src/pools/worker.ts
index 2db5f630fefa5a1e81161ca75362e7c73fc450a1..35d2c0abaa331ecad6e9a0404deaa90c00ef7d4c 100644 (file)
--- a/src/pools/worker.ts
+++ b/src/pools/worker.ts
@@ -45,6 +45,10 @@ export interface Task<Data = unknown> {
    * Task input data that will be passed to the worker.
    */
   readonly data?: Data
+  /**
+   * Submission timestamp.
+   */
+  readonly submissionTimestamp?: number
   /**
    * Message UUID.
    */
@@ -81,6 +85,22 @@ export interface TasksUsage {
    * Median tasks runtime.
    */
   medRunTime: number
+  /**
+   * Tasks wait time.
+   */
+  waitTime: number
+  /**
+   * Tasks wait time history.
+   */
+  waitTimeHistory: CircularArray<number>
+  /**
+   * Average tasks wait time.
+   */
+  avgWaitTime: number
+  /**
+   * Median tasks wait time.
+   */
+  medWaitTime: number
   /**
    * Number of tasks errored.
    */

diff --git a/src/utility-types.ts b/src/utility-types.ts
index 08861ebd30045ae430de21eae055f9634a007341..cc04f2cb99113b9cb66305c102ae5c8fe88563ad 100644 (file)
--- a/src/utility-types.ts
+++ b/src/utility-types.ts
@@ -33,6 +33,10 @@ export interface MessageValue<
    * Runtime.
    */
   readonly runTime?: number
+  /**
+   * Wait time.
+   */
+  readonly waitTime?: number
   /**
    * Reference to main worker.
    */

diff --git a/src/utils.ts b/src/utils.ts
index 164a2aca5eeeec3ae86b9bfcdeeb72d872c32cb7..baaf1c1ca62499106a4ce0ea41148204dda75d2b 100644 (file)
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -12,7 +12,8 @@ export const EMPTY_FUNCTION: () => void = Object.freeze(() => {
  */
 export const DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS: WorkerChoiceStrategyOptions =
   {
-    medRunTime: false
+    medRunTime: false,
+    medWaitTime: false
   }
 
 /**

diff --git a/src/worker/abstract-worker.ts b/src/worker/abstract-worker.ts
index 5d0c9492204e0361b8007ef4dccfb3c0154bebca..176a5893caeeec7cb9d82095840b97498b3822b0 100644 (file)
--- a/src/worker/abstract-worker.ts
+++ b/src/worker/abstract-worker.ts
@@ -207,12 +207,14 @@ export abstract class AbstractWorker<
   ): void {
     try {
       const startTimestamp = performance.now()
+      const waitTime = startTimestamp - (message.submissionTimestamp ?? 0)
       const res = fn(message.data)
       const runTime = performance.now() - startTimestamp
       this.sendToMainWorker({
         data: res,
         id: message.id,
-        runTime
+        runTime,
+        waitTime
       })
     } catch (e) {
       const err = this.handleError(e as Error)
@@ -233,13 +235,15 @@ export abstract class AbstractWorker<
     message: MessageValue<Data>
   ): void {
     const startTimestamp = performance.now()
+    const waitTime = startTimestamp - (message.submissionTimestamp ?? 0)
     fn(message.data)
       .then(res => {
         const runTime = performance.now() - startTimestamp
         this.sendToMainWorker({
           data: res,
           id: message.id,
-          runTime
+          runTime,
+          waitTime
         })
         return null
       })

diff --git a/tests/pools/abstract/abstract-pool.test.js b/tests/pools/abstract/abstract-pool.test.js
index 02baefaf93b5639867d8bb6e852dce39c25dfa57..db45fa077620d225d4a8367ebd3d37c9d7cc9da7 100644 (file)
--- a/tests/pools/abstract/abstract-pool.test.js
+++ b/tests/pools/abstract/abstract-pool.test.js
@@ -90,7 +90,8 @@ describe('Abstract pool test suite', () => {
       WorkerChoiceStrategies.ROUND_ROBIN
     )
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      medRunTime: false
+      medRunTime: false,
+      medWaitTime: false
     })
     expect(pool.opts.messageHandler).toBeUndefined()
     expect(pool.opts.errorHandler).toBeUndefined()
@@ -177,18 +178,26 @@ describe('Abstract pool test suite', () => {
       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
     )
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-      medRunTime: false
+      medRunTime: false,
+      medWaitTime: false
     })
     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
       .workerChoiceStrategies) {
-      expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: false })
+      expect(workerChoiceStrategy.opts).toStrictEqual({
+        medRunTime: false,
+        medWaitTime: false
+      })
     }
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     pool.setWorkerChoiceStrategyOptions({ medRunTime: true })
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
       medRunTime: true
@@ -198,11 +207,15 @@ describe('Abstract pool test suite', () => {
       expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: true })
     }
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(true)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: false,
+      medRunTime: true,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     pool.setWorkerChoiceStrategyOptions({ medRunTime: false })
     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
       medRunTime: false
@@ -212,11 +225,15 @@ describe('Abstract pool test suite', () => {
       expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: false })
     }
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
   })
 
@@ -275,15 +292,19 @@ describe('Abstract pool test suite', () => {
       './tests/worker-files/cluster/testWorker.js'
     )
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage).toBeDefined()
-      expect(workerNode.tasksUsage.run).toBe(0)
-      expect(workerNode.tasksUsage.running).toBe(0)
-      expect(workerNode.tasksUsage.runTime).toBe(0)
-      expect(workerNode.tasksUsage.runTimeHistory).toBeInstanceOf(CircularArray)
-      expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
-      expect(workerNode.tasksUsage.avgRunTime).toBe(0)
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
-      expect(workerNode.tasksUsage.error).toBe(0)
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: 0,
+        running: 0,
+        runTime: 0,
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
     }
     await pool.destroy()
   })
@@ -311,27 +332,35 @@ describe('Abstract pool test suite', () => {
       promises.push(pool.execute())
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage).toBeDefined()
-      expect(workerNode.tasksUsage.run).toBe(0)
-      expect(workerNode.tasksUsage.running).toBe(numberOfWorkers * 2)
-      expect(workerNode.tasksUsage.runTime).toBe(0)
-      expect(workerNode.tasksUsage.runTimeHistory).toBeInstanceOf(CircularArray)
-      expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
-      expect(workerNode.tasksUsage.avgRunTime).toBe(0)
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
-      expect(workerNode.tasksUsage.error).toBe(0)
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: 0,
+        running: numberOfWorkers * 2,
+        runTime: 0,
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
     }
     await Promise.all(promises)
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage).toBeDefined()
-      expect(workerNode.tasksUsage.run).toBe(numberOfWorkers * 2)
-      expect(workerNode.tasksUsage.running).toBe(0)
-      expect(workerNode.tasksUsage.runTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.runTimeHistory).toBeInstanceOf(CircularArray)
-      expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
-      expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
-      expect(workerNode.tasksUsage.error).toBe(0)
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: numberOfWorkers * 2,
+        running: 0,
+        runTime: 0,
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
     }
     await pool.destroy()
   })
@@ -348,27 +377,39 @@ describe('Abstract pool test suite', () => {
     }
     await Promise.all(promises)
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage).toBeDefined()
-      expect(workerNode.tasksUsage.run).toBe(numberOfWorkers * 2)
-      expect(workerNode.tasksUsage.running).toBe(0)
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: numberOfWorkers * 2,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.runTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.runTimeHistory).toBeInstanceOf(CircularArray)
-      expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
-      expect(workerNode.tasksUsage.error).toBe(0)
     }
     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
     for (const workerNode of pool.workerNodes) {
       expect(workerNode.tasksUsage).toBeDefined()
-      expect(workerNode.tasksUsage.run).toBe(0)
-      expect(workerNode.tasksUsage.running).toBe(0)
-      expect(workerNode.tasksUsage.runTime).toBe(0)
-      expect(workerNode.tasksUsage.runTimeHistory).toBeInstanceOf(CircularArray)
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: 0,
+        running: 0,
+        runTime: 0,
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
-      expect(workerNode.tasksUsage.avgRunTime).toBe(0)
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
-      expect(workerNode.tasksUsage.error).toBe(0)
     }
     await pool.destroy()
   })

diff --git a/tests/pools/selection-strategies/selection-strategies.test.js b/tests/pools/selection-strategies/selection-strategies.test.js
index 9e3e99e3ba3f1291ea4ebe1893588c084ed064f7..8ab971589a7f6af2d34c45e3d1aabf9d84361a42 100644 (file)
--- a/tests/pools/selection-strategies/selection-strategies.test.js
+++ b/tests/pools/selection-strategies/selection-strategies.test.js
@@ -5,6 +5,7 @@ const {
   FixedThreadPool,
   FixedClusterPool
 } = require('../../../lib')
+const { CircularArray } = require('../../../lib/circular-array')
 
 describe('Selection strategies test suite', () => {
   const min = 0
@@ -118,14 +119,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: false,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
@@ -134,14 +136,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: false,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -251,14 +254,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: false,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
@@ -267,14 +271,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: false,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -318,14 +323,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
@@ -334,14 +340,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(false)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: false,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -385,14 +392,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
@@ -401,14 +409,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -425,10 +434,20 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: expect.any(Number),
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
     }
     expect(
       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
@@ -452,10 +471,20 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: max * maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: expect.any(Number),
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
     }
     expect(
       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
@@ -484,9 +513,19 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.avgRunTime).toBe(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: max * maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: expect.any(Number),
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.medRunTime).toBeGreaterThanOrEqual(0)
     }
     expect(
@@ -580,14 +619,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
@@ -596,14 +636,15 @@ describe('Selection strategies test suite', () => {
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().runTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime
-    ).toBe(true)
-    expect(
-      pool.workerChoiceStrategyContext.getRequiredStatistics().medRunTime
-    ).toBe(false)
+      pool.workerChoiceStrategyContext.getRequiredStatistics()
+    ).toStrictEqual({
+      runTime: true,
+      avgRunTime: true,
+      medRunTime: false,
+      waitTime: false,
+      avgWaitTime: false,
+      medWaitTime: false
+    })
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -620,10 +661,20 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: max * maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: expect.any(Number),
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
     }
     expect(
       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
@@ -652,10 +703,20 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: max * maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: expect.any(Number),
+        medRunTime: 0,
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.medRunTime).toBe(0)
     }
     expect(
       pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
@@ -689,9 +750,19 @@ describe('Selection strategies test suite', () => {
       await pool.execute()
     }
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.tasksUsage.avgRunTime).toBeDefined()
-      expect(workerNode.tasksUsage.avgRunTime).toBe(0)
-      expect(workerNode.tasksUsage.medRunTime).toBeDefined()
+      expect(workerNode.tasksUsage).toStrictEqual({
+        run: max * maxMultiplier,
+        running: 0,
+        runTime: expect.any(Number),
+        runTimeHistory: expect.any(CircularArray),
+        avgRunTime: 0,
+        medRunTime: expect.any(Number),
+        waitTime: 0,
+        waitTimeHistory: expect.any(CircularArray),
+        avgWaitTime: 0,
+        medWaitTime: 0,
+        error: 0
+      })
       expect(workerNode.tasksUsage.medRunTime).toBeGreaterThanOrEqual(0)
     }
     expect(