X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fpools%2Fabstract-pool.ts;h=62def61e6dd28a1f042280f3a1a676bd07f226a2;hb=2740a743fcbf64e0ee674530e3cbcf6df710c1ef;hp=363db0e3f9b64ff650a0c351de05135c8de1de96;hpb=fc3e65861bc1939ae047ee1e8e91a1ce577035f4;p=poolifier.git diff --git a/src/pools/abstract-pool.ts b/src/pools/abstract-pool.ts index 363db0e3..62def61e 100644 --- a/src/pools/abstract-pool.ts +++ b/src/pools/abstract-pool.ts @@ -1,8 +1,5 @@ import crypto from 'node:crypto' -import type { - MessageValue, - PromiseWorkerResponseWrapper -} from '../utility-types' +import type { MessageValue, PromiseResponseWrapper } from '../utility-types' import { EMPTY_FUNCTION } from '../utils' import { KillBehaviors, isKillBehavior } from '../worker/worker-options' import type { PoolOptions } from './pool' @@ -29,31 +26,21 @@ export abstract class AbstractPool< Response = unknown > implements IPoolInternal { /** {@inheritDoc} */ - public readonly workers: Map> = new Map< - number, - WorkerType - >() + public readonly workers: Array> = [] /** {@inheritDoc} */ public readonly emitter?: PoolEmitter /** - * Id of the next worker. - */ - protected nextWorkerId: number = 0 - - /** - * The promise map. + * The promise response map. * - * - `key`: This is the message id of each submitted task. - * - `value`: An object that contains the worker, the resolve function and the reject function. + * - `key`: The message id of each submitted task. + * - `value`: An object that contains the worker key, the promise resolve and reject callbacks. * - * When we receive a message from the worker we get a map entry and resolve/reject the promise based on the message. + * When we receive a message from the worker we get a map entry with the promise resolve/reject bound to the message. */ - protected promiseMap: Map< - string, - PromiseWorkerResponseWrapper - > = new Map>() + protected promiseResponseMap: Map> = + new Map>() /** * Worker choice strategy instance implementing the worker choice algorithm. @@ -100,7 +87,7 @@ export abstract class AbstractPool< this.registerWorkerMessageListener(workerCreated, message => { if ( isKillBehavior(KillBehaviors.HARD, message.kill) || - this.getWorkerRunningTasks(workerCreated) === 0 + this.getWorkerTasksUsage(workerCreated)?.running === 0 ) { // Kill received from the worker, means that no new tasks are submitted to that worker for a while ( > maxInactiveTime) void this.destroyWorker(workerCreated) @@ -150,7 +137,7 @@ export abstract class AbstractPool< /** {@inheritDoc} */ public get numberOfRunningTasks (): number { - return this.promiseMap.size + return this.promiseResponseMap.size } /** @@ -159,20 +146,8 @@ export abstract class AbstractPool< * @param worker - The worker. * @returns The worker key. */ - private getWorkerKey (worker: Worker): number | undefined { - return [...this.workers].find(([, value]) => value.worker === worker)?.[0] - } - - /** {@inheritDoc} */ - public getWorkerRunningTasks (worker: Worker): number | undefined { - return this.workers.get(this.getWorkerKey(worker) as number)?.tasksUsage - ?.running - } - - /** {@inheritDoc} */ - public getWorkerAverageTasksRunTime (worker: Worker): number | undefined { - return this.workers.get(this.getWorkerKey(worker) as number)?.tasksUsage - ?.avgRunTime + private getWorkerKey (worker: Worker): number { + return this.workers.findIndex(workerItem => workerItem.worker === worker) } /** {@inheritDoc} */ @@ -180,12 +155,13 @@ export abstract class AbstractPool< workerChoiceStrategy: WorkerChoiceStrategy ): void { this.opts.workerChoiceStrategy = workerChoiceStrategy - for (const [key, value] of this.workers) { - this.setWorker(key, value.worker, { + for (const workerItem of this.workers) { + this.setWorker(workerItem.worker, { run: 0, running: 0, runTime: 0, - avgRunTime: 0 + avgRunTime: 0, + error: 0 }) } this.workerChoiceStrategyContext.setWorkerChoiceStrategy( @@ -205,10 +181,10 @@ export abstract class AbstractPool< /** {@inheritDoc} */ public findFreeWorker (): Worker | false { - for (const value of this.workers.values()) { - if (value.tasksUsage.running === 0) { + for (const workerItem of this.workers) { + if (workerItem.tasksUsage.running === 0) { // A worker is free, return the matching worker - return value.worker + return workerItem.worker } } return false @@ -218,7 +194,7 @@ export abstract class AbstractPool< public async execute (data: Data): Promise { const worker = this.chooseWorker() const messageId = crypto.randomUUID() - const res = this.internalExecute(worker, messageId) + const res = this.internalExecute(this.getWorkerKey(worker), messageId) this.checkAndEmitBusy() this.sendToWorker(worker, { // eslint-disable-next-line @typescript-eslint/consistent-type-assertions @@ -232,8 +208,8 @@ export abstract class AbstractPool< /** {@inheritDoc} */ public async destroy (): Promise { await Promise.all( - [...this.workers].map(async ([, value]) => { - await this.destroyWorker(value.worker) + this.workers.map(async workerItem => { + await this.destroyWorker(workerItem.worker) }) ) } @@ -262,26 +238,39 @@ export abstract class AbstractPool< * Hook executed before the worker task promise resolution. * Can be overridden. * - * @param worker - The worker. + * @param workerKey - The worker key. */ - protected beforePromiseWorkerResponseHook (worker: Worker): void { - this.increaseWorkerRunningTasks(worker) + protected beforePromiseResponseHook (workerKey: number): void { + ++this.workers[workerKey].tasksUsage.running } /** * Hook executed after the worker task promise resolution. * Can be overridden. * + * @param workerKey - The worker key. * @param message - The received message. - * @param promise - The Promise response. */ - protected afterPromiseWorkerResponseHook ( - message: MessageValue, - promise: PromiseWorkerResponseWrapper + protected afterPromiseResponseHook ( + workerKey: number, + message: MessageValue ): void { - this.decreaseWorkerRunningTasks(promise.worker) - this.stepWorkerRunTasks(promise.worker, 1) - this.updateWorkerTasksRunTime(promise.worker, message.taskRunTime) + const workerTasksUsage = this.workers[workerKey].tasksUsage + --workerTasksUsage.running + ++workerTasksUsage.run + if (message.error != null) { + ++workerTasksUsage.error + } + if ( + this.workerChoiceStrategyContext.getWorkerChoiceStrategy() + .requiredStatistics.runTime + ) { + workerTasksUsage.runTime += message.taskRunTime ?? 0 + if (workerTasksUsage.run !== 0) { + workerTasksUsage.avgRunTime = + workerTasksUsage.runTime / workerTasksUsage.run + } + } } /** @@ -290,8 +279,7 @@ export abstract class AbstractPool< * @param worker - The worker that will be removed. */ protected removeWorker (worker: Worker): void { - this.workers.delete(this.getWorkerKey(worker) as number) - --this.nextWorkerId + this.workers.splice(this.getWorkerKey(worker), 1) } /** @@ -356,13 +344,13 @@ export abstract class AbstractPool< this.removeWorker(worker) }) - this.setWorker(this.nextWorkerId, worker, { + this.setWorker(worker, { run: 0, running: 0, runTime: 0, - avgRunTime: 0 + avgRunTime: 0, + error: 0 }) - ++this.nextWorkerId this.afterWorkerSetup(worker) @@ -377,27 +365,27 @@ export abstract class AbstractPool< protected workerListener (): (message: MessageValue) => void { return message => { if (message.id !== undefined) { - const promise = this.promiseMap.get(message.id) - if (promise !== undefined) { + const promiseResponse = this.promiseResponseMap.get(message.id) + if (promiseResponse !== undefined) { if (message.error != null) { - promise.reject(message.error) + promiseResponse.reject(message.error) } else { - promise.resolve(message.data as Response) + promiseResponse.resolve(message.data as Response) } - this.afterPromiseWorkerResponseHook(message, promise) - this.promiseMap.delete(message.id) + this.afterPromiseResponseHook(promiseResponse.workerKey, message) + this.promiseResponseMap.delete(message.id) } } } } private async internalExecute ( - worker: Worker, + workerKey: number, messageId: string ): Promise { - this.beforePromiseWorkerResponseHook(worker) + this.beforePromiseResponseHook(workerKey) return await new Promise((resolve, reject) => { - this.promiseMap.set(messageId, { resolve, reject, worker }) + this.promiseResponseMap.set(messageId, { resolve, reject, workerKey }) }) } @@ -407,110 +395,25 @@ export abstract class AbstractPool< } } - /** - * Increases the number of tasks that the given worker has applied. - * - * @param worker - Worker which running tasks is increased. - */ - private increaseWorkerRunningTasks (worker: Worker): void { - this.stepWorkerRunningTasks(worker, 1) - } - - /** - * Decreases the number of tasks that the given worker has applied. - * - * @param worker - Worker which running tasks is decreased. - */ - private decreaseWorkerRunningTasks (worker: Worker): void { - this.stepWorkerRunningTasks(worker, -1) - } - - /** - * Gets tasks usage of the given worker. - * - * @param worker - Worker which tasks usage is returned. - */ - private getWorkerTasksUsage (worker: Worker): TasksUsage | undefined { - if (this.checkWorker(worker)) { - const workerKey = this.getWorkerKey(worker) as number - const workerEntry = this.workers.get(workerKey) as WorkerType - return workerEntry.tasksUsage - } - } - - /** - * Steps the number of tasks that the given worker has applied. - * - * @param worker - Worker which running tasks are stepped. - * @param step - Number of running tasks step. - */ - private stepWorkerRunningTasks (worker: Worker, step: number): void { - // prettier-ignore - (this.getWorkerTasksUsage(worker) as TasksUsage).running += step - } - - /** - * Steps the number of tasks that the given worker has run. - * - * @param worker - Worker which has run tasks. - * @param step - Number of run tasks step. - */ - private stepWorkerRunTasks (worker: Worker, step: number): void { - // prettier-ignore - (this.getWorkerTasksUsage(worker) as TasksUsage).run += step - } - - /** - * Updates tasks runtime for the given worker. - * - * @param worker - Worker which run the task. - * @param taskRunTime - Worker task runtime. - */ - private updateWorkerTasksRunTime ( - worker: Worker, - taskRunTime: number | undefined - ): void { - if ( - this.workerChoiceStrategyContext.getWorkerChoiceStrategy() - .requiredStatistics.runTime - ) { - const workerTasksUsage = this.getWorkerTasksUsage(worker) as TasksUsage - workerTasksUsage.runTime += taskRunTime ?? 0 - if (workerTasksUsage.run !== 0) { - workerTasksUsage.avgRunTime = - workerTasksUsage.runTime / workerTasksUsage.run - } + /** {@inheritDoc} */ + public getWorkerTasksUsage (worker: Worker): TasksUsage | undefined { + const workerKey = this.getWorkerKey(worker) + if (workerKey !== -1) { + return this.workers[workerKey].tasksUsage } + throw new Error('Worker could not be found in the pool') } /** * Sets the given worker. * - * @param workerKey - The worker key. * @param worker - The worker. * @param tasksUsage - The worker tasks usage. */ - private setWorker ( - workerKey: number, - worker: Worker, - tasksUsage: TasksUsage - ): void { - this.workers.set(workerKey, { + private setWorker (worker: Worker, tasksUsage: TasksUsage): void { + this.workers.push({ worker, tasksUsage }) } - - /** - * Checks if the given worker is registered in the pool. - * - * @param worker - Worker to check. - * @returns `true` if the worker is registered in the pool. - */ - private checkWorker (worker: Worker): boolean { - if (this.getWorkerKey(worker) == null) { - throw new Error('Worker could not be found in the pool') - } - return true - } }