public readonly emitter?: PoolEmitter
/**
- * The promise response map.
+ * The execution response promise map.
*
* - `key`: The message id of each submitted task.
- * - `value`: An object that contains the worker, the promise resolve and reject callbacks.
+ * - `value`: An object that contains the worker, the execution response promise resolve and reject callbacks.
*
- * When we receive a message from the worker we get a map entry with the promise resolve/reject bound to the message.
+ * When we receive a message from the worker, we get a map entry with the promise resolve/reject bound to the message id.
*/
protected promiseResponseMap: Map<
string,
this.chooseWorkerNode.bind(this)
this.internalExecute.bind(this)
- this.checkAndEmitFull.bind(this)
- this.checkAndEmitBusy.bind(this)
+ this.checkAndEmitEvents.bind(this)
this.sendToWorker.bind(this)
this.setupHook()
Worker,
Data,
Response
- >(this, this.opts.workerChoiceStrategy)
+ >(
+ this,
+ this.opts.workerChoiceStrategy,
+ this.opts.workerChoiceStrategyOptions
+ )
}
private checkFilePath (filePath: string): void {
this.opts.workerChoiceStrategy =
opts.workerChoiceStrategy ?? WorkerChoiceStrategies.ROUND_ROBIN
this.checkValidWorkerChoiceStrategy(this.opts.workerChoiceStrategy)
+ this.opts.workerChoiceStrategyOptions =
+ opts.workerChoiceStrategyOptions ?? { medRunTime: false }
this.opts.enableEvents = opts.enableEvents ?? true
+ this.opts.enableTasksQueue = opts.enableTasksQueue ?? false
}
private checkValidWorkerChoiceStrategy (
public abstract get type (): PoolType
/**
- * Number of tasks concurrently running in the pool.
+ * Number of tasks running in the pool.
*/
private get numberOfRunningTasks (): number {
- return this.promiseResponseMap.size
+ return this.workerNodes.reduce(
+ (accumulator, workerNode) => accumulator + workerNode.tasksUsage.running,
+ 0
+ )
+ }
+
+ /**
+ * Number of tasks queued in the pool.
+ */
+ private get numberOfQueuedTasks (): number {
+ if (this.opts.enableTasksQueue === false) {
+ return 0
+ }
+ return this.workerNodes.reduce(
+ (accumulator, workerNode) => accumulator + workerNode.tasksQueue.length,
+ 0
+ )
}
/**
): void {
this.checkValidWorkerChoiceStrategy(workerChoiceStrategy)
this.opts.workerChoiceStrategy = workerChoiceStrategy
- for (const [index, workerNode] of this.workerNodes.entries()) {
- this.setWorkerNode(
- index,
- workerNode.worker,
- {
- run: 0,
- running: 0,
- runTime: 0,
- runTimeHistory: new CircularArray(),
- avgRunTime: 0,
- medRunTime: 0,
- error: 0
- },
- workerNode.tasksQueue
- )
+ for (const workerNode of this.workerNodes) {
+ this.setWorkerNodeTasksUsage(workerNode, {
+ run: 0,
+ running: 0,
+ runTime: 0,
+ runTimeHistory: new CircularArray(),
+ avgRunTime: 0,
+ medRunTime: 0,
+ error: 0
+ })
}
this.workerChoiceStrategyContext.setWorkerChoiceStrategy(
workerChoiceStrategy
id: crypto.randomUUID()
}
const res = this.internalExecute(workerNodeKey, workerNode, submittedTask)
- let currentTask: Task<Data>
- // FIXME: Add sensible conditions to start tasks queuing on the worker node
- if (this.tasksQueueLength(workerNodeKey) > 0) {
- currentTask = this.dequeueTask(workerNodeKey) as Task<Data>
+ if (
+ this.opts.enableTasksQueue === true &&
+ (this.busy || this.workerNodes[workerNodeKey].tasksUsage.running > 0)
+ ) {
this.enqueueTask(workerNodeKey, submittedTask)
} else {
- currentTask = submittedTask
+ this.sendToWorker(workerNode.worker, submittedTask)
}
- this.sendToWorker(workerNode.worker, currentTask)
- this.checkAndEmitFull()
- this.checkAndEmitBusy()
+ this.checkAndEmitEvents()
// eslint-disable-next-line @typescript-eslint/return-await
return res
}
public async destroy (): Promise<void> {
await Promise.all(
this.workerNodes.map(async workerNode => {
+ this.flushTasksQueueByWorker(workerNode.worker)
await this.destroyWorker(workerNode.worker)
})
)
(message.kill != null &&
this.getWorkerTasksUsage(workerCreated)?.running === 0)
) {
- // Kill message received from the worker, means that no new tasks are submitted to that worker for a while ( > maxInactiveTime)
+ // Kill message received from the worker: no new tasks are submitted to that worker for a while ( > maxInactiveTime)
+ this.flushTasksQueueByWorker(workerCreated)
void this.destroyWorker(workerCreated)
}
})
}
/**
- * This function is the listener registered for each worker.
+ * This function is the listener registered for each worker message.
*
* @returns The listener function to execute when a message is received from a worker.
*/
protected workerListener (): (message: MessageValue<Response>) => void {
return message => {
if (message.id != null) {
- // Task response received
+ // Task execution response received
const promiseResponse = this.promiseResponseMap.get(message.id)
if (promiseResponse != null) {
if (message.error != null) {
}
this.afterPromiseResponseHook(promiseResponse.worker, message)
this.promiseResponseMap.delete(message.id)
+ const workerNodeKey = this.getWorkerNodeKey(promiseResponse.worker)
+ if (
+ this.opts.enableTasksQueue === true &&
+ this.tasksQueueSize(workerNodeKey) > 0
+ ) {
+ this.sendToWorker(
+ promiseResponse.worker,
+ this.dequeueTask(workerNodeKey) as Task<Data>
+ )
+ }
}
}
}
})
}
- private checkAndEmitBusy (): void {
- if (this.opts.enableEvents === true && this.busy) {
- this.emitter?.emit(PoolEvents.busy)
+ private checkAndEmitEvents (): void {
+ if (this.opts.enableEvents === true) {
+ if (this.busy) {
+ this.emitter?.emit(PoolEvents.busy)
+ }
+ if (this.type === PoolType.DYNAMIC && this.full) {
+ this.emitter?.emit(PoolEvents.full)
+ }
}
}
- private checkAndEmitFull (): void {
- if (
- this.type === PoolType.DYNAMIC &&
- this.opts.enableEvents === true &&
- this.full
- ) {
- this.emitter?.emit(PoolEvents.full)
- }
+ /**
+ * Sets the given worker node its tasks usage in the pool.
+ *
+ * @param workerNode - The worker node.
+ * @param tasksUsage - The worker node tasks usage.
+ */
+ private setWorkerNodeTasksUsage (
+ workerNode: WorkerNode<Worker, Data>,
+ tasksUsage: TasksUsage
+ ): void {
+ workerNode.tasksUsage = tasksUsage
}
/**
*
* @param worker - The worker.
*/
- protected removeWorkerNode (worker: Worker): void {
+ private removeWorkerNode (worker: Worker): void {
const workerNodeKey = this.getWorkerNodeKey(worker)
this.workerNodes.splice(workerNodeKey, 1)
this.workerChoiceStrategyContext.remove(workerNodeKey)
}
- protected enqueueTask (workerNodeKey: number, task: Task<Data>): void {
+ private enqueueTask (workerNodeKey: number, task: Task<Data>): void {
this.workerNodes[workerNodeKey].tasksQueue.push(task)
}
- protected dequeueTask (workerNodeKey: number): Task<Data> | undefined {
+ private dequeueTask (workerNodeKey: number): Task<Data> | undefined {
return this.workerNodes[workerNodeKey].tasksQueue.shift()
}
- protected tasksQueueLength (workerNodeKey: number): number {
+ private tasksQueueSize (workerNodeKey: number): number {
return this.workerNodes[workerNodeKey].tasksQueue.length
}
+
+ private flushTasksQueue (workerNodeKey: number): void {
+ if (this.tasksQueueSize(workerNodeKey) > 0) {
+ for (const task of this.workerNodes[workerNodeKey].tasksQueue) {
+ this.sendToWorker(this.workerNodes[workerNodeKey].worker, task)
+ }
+ this.workerNodes[workerNodeKey].tasksQueue = []
+ }
+ }
+
+ private flushTasksQueueByWorker (worker: Worker): void {
+ const workerNodeKey = this.getWorkerNodeKey(worker)
+ this.flushTasksQueue(workerNodeKey)
+ }
}
repositories / poolifier.git / blobdiff