X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fpools%2Fabstract-pool.ts;h=a7f1579fde52512735224c1f47738f8ab7c211f2;hb=3e406edee2c758263a2e8d8bbbaaeff951a3db7a;hp=88f2c9e9f9ff9318f0777fb0c4e065482b59fc4b;hpb=98e72cda1ce363322fc7ae868b66dec89a1ad74c;p=poolifier.git diff --git a/src/pools/abstract-pool.ts b/src/pools/abstract-pool.ts index 88f2c9e9..a7f1579f 100644 --- a/src/pools/abstract-pool.ts +++ b/src/pools/abstract-pool.ts @@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto' import { performance } from 'node:perf_hooks' import type { MessageValue, PromiseResponseWrapper } from '../utility-types' import { + DEFAULT_TASK_NAME, DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS, EMPTY_FUNCTION, isKillBehavior, @@ -10,8 +11,6 @@ import { round } from '../utils' import { KillBehaviors } from '../worker/worker-options' -import { CircularArray } from '../circular-array' -import { Queue } from '../queue' import { type IPool, PoolEmitter, @@ -20,16 +19,15 @@ import { type PoolOptions, type PoolType, PoolTypes, - type TasksQueueOptions, - type WorkerType, - WorkerTypes + type TasksQueueOptions } from './pool' import type { IWorker, + IWorkerNode, MessageHandler, Task, WorkerInfo, - WorkerNode, + WorkerType, WorkerUsage } from './worker' import { @@ -40,6 +38,7 @@ import { } from './selection-strategies/selection-strategies-types' import { WorkerChoiceStrategyContext } from './selection-strategies/worker-choice-strategy-context' import { version } from './version' +import { WorkerNode } from './worker-node' /** * Base class that implements some shared logic for all poolifier pools. @@ -54,7 +53,7 @@ export abstract class AbstractPool< Response = unknown > implements IPool { /** @inheritDoc */ - public readonly workerNodes: Array> = [] + public readonly workerNodes: Array> = [] /** @inheritDoc */ public readonly emitter?: PoolEmitter @@ -155,7 +154,25 @@ export abstract class AbstractPool< 'Cannot instantiate a pool with a negative number of workers' ) } else if (this.type === PoolTypes.fixed && numberOfWorkers === 0) { - throw new Error('Cannot instantiate a fixed pool with no worker') + throw new RangeError('Cannot instantiate a fixed pool with zero worker') + } + } + + protected checkDynamicPoolSize (min: number, max: number): void { + if (this.type === PoolTypes.dynamic) { + if (min > max) { + throw new RangeError( + 'Cannot instantiate a dynamic pool with a maximum pool size inferior to the minimum pool size' + ) + } else if (min === 0 && max === 0) { + throw new RangeError( + 'Cannot instantiate a dynamic pool with a minimum pool size and a maximum pool size equal to zero' + ) + } else if (min === max) { + throw new RangeError( + 'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead' + ) + } } } @@ -254,6 +271,8 @@ export abstract class AbstractPool< version, type: this.type, worker: this.worker, + ready: this.ready, + strategy: this.opts.workerChoiceStrategy as WorkerChoiceStrategy, minSize: this.minSize, maxSize: this.maxSize, ...(this.workerChoiceStrategyContext.getTaskStatisticsRequirements() @@ -290,7 +309,7 @@ export abstract class AbstractPool< ), maxQueuedTasks: this.workerNodes.reduce( (accumulator, workerNode) => - accumulator + workerNode.usage.tasks.maxQueued, + accumulator + (workerNode.usage.tasks?.maxQueued ?? 0), 0 ), failedTasks: this.workerNodes.reduce( @@ -383,6 +402,21 @@ export abstract class AbstractPool< } } + private get starting (): boolean { + return ( + this.workerNodes.length < this.minSize || + (this.workerNodes.length >= this.minSize && + this.workerNodes.some(workerNode => !workerNode.info.ready)) + ) + } + + private get ready (): boolean { + return ( + this.workerNodes.length >= this.minSize && + this.workerNodes.every(workerNode => workerNode.info.ready) + ) + } + /** * Gets the approximate pool utilization. * @@ -437,6 +471,17 @@ export abstract class AbstractPool< ?.worker } + private checkMessageWorkerId (message: MessageValue): void { + if ( + message.workerId != null && + this.getWorkerById(message.workerId) == null + ) { + throw new Error( + `Worker message received from unknown worker '${message.workerId}'` + ) + } + } + /** * Gets the given worker its worker node key. * @@ -463,10 +508,7 @@ export abstract class AbstractPool< this.setWorkerChoiceStrategyOptions(workerChoiceStrategyOptions) } for (const workerNode of this.workerNodes) { - this.setWorkerNodeTasksUsage( - workerNode, - this.getInitialWorkerUsage(workerNode.worker) - ) + workerNode.resetUsage() this.setWorkerStatistics(workerNode.worker) } } @@ -547,10 +589,11 @@ export abstract class AbstractPool< const timestamp = performance.now() const workerNodeKey = this.chooseWorkerNode() const submittedTask: Task = { - name, + name: name ?? DEFAULT_TASK_NAME, // eslint-disable-next-line @typescript-eslint/consistent-type-assertions data: data ?? ({} as Data), timestamp, + workerId: this.getWorkerInfo(workerNodeKey).id as number, id: randomUUID() } const res = new Promise((resolve, reject) => { @@ -629,6 +672,11 @@ export abstract class AbstractPool< const workerUsage = this.workerNodes[workerNodeKey].usage ++workerUsage.tasks.executing this.updateWaitTimeWorkerUsage(workerUsage, task) + const tasksWorkerUsage = this.workerNodes[ + workerNodeKey + ].getTasksWorkerUsage(task.name as string) as WorkerUsage + ++tasksWorkerUsage.tasks.executing + this.updateWaitTimeWorkerUsage(tasksWorkerUsage, task) } /** @@ -642,10 +690,17 @@ export abstract class AbstractPool< worker: Worker, message: MessageValue ): void { - const workerUsage = this.workerNodes[this.getWorkerNodeKey(worker)].usage + const workerNodeKey = this.getWorkerNodeKey(worker) + const workerUsage = this.workerNodes[workerNodeKey].usage this.updateTaskStatisticsWorkerUsage(workerUsage, message) this.updateRunTimeWorkerUsage(workerUsage, message) this.updateEluWorkerUsage(workerUsage, message) + const tasksWorkerUsage = this.workerNodes[ + workerNodeKey + ].getTasksWorkerUsage(message.name as string) as WorkerUsage + this.updateTaskStatisticsWorkerUsage(tasksWorkerUsage, message) + this.updateRunTimeWorkerUsage(tasksWorkerUsage, message) + this.updateEluWorkerUsage(tasksWorkerUsage, message) } private updateTaskStatisticsWorkerUsage ( @@ -869,6 +924,13 @@ export abstract class AbstractPool< protected afterWorkerSetup (worker: Worker): void { // Listen to worker messages. this.registerWorkerMessageListener(worker, this.workerListener()) + // Send startup message to worker. + this.sendToWorker(worker, { + ready: false, + workerId: this.getWorkerInfo(this.getWorkerNodeKey(worker)).id as number + }) + // Setup worker task statistics computation. + this.setWorkerStatistics(worker) } /** @@ -886,33 +948,9 @@ export abstract class AbstractPool< this.emitter.emit(PoolEvents.error, error) } if (this.opts.enableTasksQueue === true) { - const workerNodeKey = this.getWorkerNodeKey(worker) - while (this.tasksQueueSize(workerNodeKey) > 0) { - let targetWorkerNodeKey: number = workerNodeKey - let minQueuedTasks = Infinity - for (const [workerNodeId, workerNode] of this.workerNodes.entries()) { - if ( - workerNodeId !== workerNodeKey && - workerNode.usage.tasks.queued === 0 - ) { - targetWorkerNodeKey = workerNodeId - break - } - if ( - workerNodeId !== workerNodeKey && - workerNode.usage.tasks.queued < minQueuedTasks - ) { - minQueuedTasks = workerNode.usage.tasks.queued - targetWorkerNodeKey = workerNodeId - } - } - this.enqueueTask( - targetWorkerNodeKey, - this.dequeueTask(workerNodeKey) as Task - ) - } + this.redistributeQueuedTasks(worker) } - if (this.opts.restartWorkerOnError === true) { + if (this.opts.restartWorkerOnError === true && !this.starting) { if (this.getWorkerInfo(this.getWorkerNodeKey(worker)).dynamic) { this.createAndSetupDynamicWorker() } else { @@ -928,13 +966,39 @@ export abstract class AbstractPool< this.pushWorkerNode(worker) - this.setWorkerStatistics(worker) - this.afterWorkerSetup(worker) return worker } + private redistributeQueuedTasks (worker: Worker): void { + const workerNodeKey = this.getWorkerNodeKey(worker) + while (this.tasksQueueSize(workerNodeKey) > 0) { + let targetWorkerNodeKey: number = workerNodeKey + let minQueuedTasks = Infinity + for (const [workerNodeId, workerNode] of this.workerNodes.entries()) { + if ( + workerNodeId !== workerNodeKey && + workerNode.usage.tasks.queued === 0 + ) { + targetWorkerNodeKey = workerNodeId + break + } + if ( + workerNodeId !== workerNodeKey && + workerNode.usage.tasks.queued < minQueuedTasks + ) { + minQueuedTasks = workerNode.usage.tasks.queued + targetWorkerNodeKey = workerNodeId + } + } + this.enqueueTask( + targetWorkerNodeKey, + this.dequeueTask(workerNodeKey) as Task + ) + } + } + /** * Creates a new dynamic worker and sets it up completely in the pool worker nodes. * @@ -942,7 +1006,6 @@ export abstract class AbstractPool< */ protected createAndSetupDynamicWorker (): Worker { const worker = this.createAndSetupWorker() - this.getWorkerInfo(this.getWorkerNodeKey(worker)).dynamic = true this.registerWorkerMessageListener(worker, message => { const workerNodeKey = this.getWorkerNodeKey(worker) if ( @@ -958,6 +1021,12 @@ export abstract class AbstractPool< void (this.destroyWorker(worker) as Promise) } }) + const workerInfo = this.getWorkerInfo(this.getWorkerNodeKey(worker)) + workerInfo.dynamic = true + this.sendToWorker(worker, { + checkAlive: true, + workerId: workerInfo.id as number + }) return worker } @@ -968,9 +1037,10 @@ export abstract class AbstractPool< */ protected workerListener (): (message: MessageValue) => void { return message => { - if (message.workerId != null && message.started != null) { - // Worker started message received - this.handleWorkerStartedMessage(message) + this.checkMessageWorkerId(message) + if (message.ready != null && message.workerId != null) { + // Worker ready message received + this.handleWorkerReadyMessage(message) } else if (message.id != null) { // Task execution response received this.handleTaskExecutionResponse(message) @@ -978,18 +1048,12 @@ export abstract class AbstractPool< } } - private handleWorkerStartedMessage (message: MessageValue): void { - // Worker started message received - const worker = this.getWorkerById(message.workerId as number) - if (worker != null) { - this.workerNodes[this.getWorkerNodeKey(worker)].info.started = - message.started as boolean - } else { - throw new Error( - `Worker started message received from unknown worker '${ - message.workerId as number - }'` - ) + private handleWorkerReadyMessage (message: MessageValue): void { + const worker = this.getWorkerById(message.workerId) + this.getWorkerInfo(this.getWorkerNodeKey(worker as Worker)).ready = + message.ready as boolean + if (this.emitter != null && this.ready) { + this.emitter.emit(PoolEvents.ready, this.info) } } @@ -1031,19 +1095,6 @@ export abstract class AbstractPool< } } - /** - * Sets the given worker node its tasks usage in the pool. - * - * @param workerNode - The worker node. - * @param workerUsage - The worker usage. - */ - private setWorkerNodeTasksUsage ( - workerNode: WorkerNode, - workerUsage: WorkerUsage - ): void { - workerNode.usage = workerUsage - } - /** * Gets the worker information. * @@ -1060,57 +1111,9 @@ export abstract class AbstractPool< * @returns The worker nodes length. */ private pushWorkerNode (worker: Worker): number { - this.workerNodes.push({ - worker, - info: this.getInitialWorkerInfo(worker), - usage: this.getInitialWorkerUsage(), - tasksQueue: new Queue>() - }) - this.setWorkerNodeTasksUsage( - this.workerNodes[this.getWorkerNodeKey(worker)], - this.getInitialWorkerUsage(worker) - ) - return this.workerNodes.length + return this.workerNodes.push(new WorkerNode(worker, this.worker)) } - /** - * Gets the worker id. - * - * @param worker - The worker. - * @returns The worker id. - */ - private getWorkerId (worker: Worker): number | undefined { - if (this.worker === WorkerTypes.thread) { - return worker.threadId - } else if (this.worker === WorkerTypes.cluster) { - return worker.id - } - } - - // /** - // * Sets the given worker in the pool worker nodes. - // * - // * @param workerNodeKey - The worker node key. - // * @param worker - The worker. - // * @param workerInfo - The worker info. - // * @param workerUsage - The worker usage. - // * @param tasksQueue - The worker task queue. - // */ - // private setWorkerNode ( - // workerNodeKey: number, - // worker: Worker, - // workerInfo: WorkerInfo, - // workerUsage: WorkerUsage, - // tasksQueue: Queue> - // ): void { - // this.workerNodes[workerNodeKey] = { - // worker, - // info: workerInfo, - // usage: workerUsage, - // tasksQueue - // } - // } - /** * Removes the given worker from the pool worker nodes. * @@ -1130,19 +1133,15 @@ export abstract class AbstractPool< } private enqueueTask (workerNodeKey: number, task: Task): number { - return this.workerNodes[workerNodeKey].tasksQueue.enqueue(task) + return this.workerNodes[workerNodeKey].enqueueTask(task) } private dequeueTask (workerNodeKey: number): Task | undefined { - return this.workerNodes[workerNodeKey].tasksQueue.dequeue() + return this.workerNodes[workerNodeKey].dequeueTask() } private tasksQueueSize (workerNodeKey: number): number { - return this.workerNodes[workerNodeKey].tasksQueue.size - } - - private tasksMaxQueueSize (workerNodeKey: number): number { - return this.workerNodes[workerNodeKey].tasksQueue.maxSize + return this.workerNodes[workerNodeKey].tasksQueueSize() } private flushTasksQueue (workerNodeKey: number): void { @@ -1152,7 +1151,7 @@ export abstract class AbstractPool< this.dequeueTask(workerNodeKey) as Task ) } - this.workerNodes[workerNodeKey].tasksQueue.clear() + this.workerNodes[workerNodeKey].clearTasksQueue() } private flushTasksQueues (): void { @@ -1169,53 +1168,8 @@ export abstract class AbstractPool< .runTime.aggregate, elu: this.workerChoiceStrategyContext.getTaskStatisticsRequirements() .elu.aggregate - } - }) - } - - private getInitialWorkerUsage (worker?: Worker): WorkerUsage { - const getTasksQueueSize = (worker?: Worker): number => { - if (worker == null) { - return 0 - } - return this.tasksQueueSize(this.getWorkerNodeKey(worker)) - } - const getTasksMaxQueueSize = (worker?: Worker): number => { - if (worker == null) { - return 0 - } - return this.tasksMaxQueueSize(this.getWorkerNodeKey(worker)) - } - return { - tasks: { - executed: 0, - executing: 0, - get queued (): number { - return getTasksQueueSize(worker) - }, - get maxQueued (): number { - return getTasksMaxQueueSize(worker) - }, - failed: 0 - }, - runTime: { - history: new CircularArray() }, - waitTime: { - history: new CircularArray() - }, - elu: { - idle: { - history: new CircularArray() - }, - active: { - history: new CircularArray() - } - } - } - } - - private getInitialWorkerInfo (worker: Worker): WorkerInfo { - return { id: this.getWorkerId(worker), dynamic: false, started: true } + workerId: this.getWorkerInfo(this.getWorkerNodeKey(worker)).id as number + }) } }