}
if (
workerChoiceStrategyOptions.choiceRetries != null &&
- workerChoiceStrategyOptions.choiceRetries <= 0
+ workerChoiceStrategyOptions.choiceRetries < 0
) {
throw new RangeError(
- `Invalid worker choice strategy options: choice retries '${workerChoiceStrategyOptions.choiceRetries}' must be greater than zero`
+ `Invalid worker choice strategy options: choice retries '${workerChoiceStrategyOptions.choiceRetries}' must be greater or equal than zero`
)
}
if (
`Invalid worker node tasks concurrency: ${tasksQueueOptions.concurrency} is a negative integer or zero`
)
}
- if (
- tasksQueueOptions?.queueMaxSize != null &&
- tasksQueueOptions?.size != null
- ) {
+ if (tasksQueueOptions?.queueMaxSize != null) {
throw new Error(
- 'Invalid tasks queue options: cannot specify both queueMaxSize and size'
+ 'Invalid tasks queue options: queueMaxSize is deprecated, please use size instead'
)
}
- if (tasksQueueOptions?.queueMaxSize != null) {
- tasksQueueOptions.size = tasksQueueOptions.queueMaxSize
- }
if (
tasksQueueOptions?.size != null &&
!Number.isSafeInteger(tasksQueueOptions.size)
) {
throw new TypeError(
- 'Invalid worker node tasks queue max size: must be an integer'
+ 'Invalid worker node tasks queue size: must be an integer'
)
}
if (tasksQueueOptions?.size != null && tasksQueueOptions.size <= 0) {
throw new RangeError(
- `Invalid worker node tasks queue max size: ${tasksQueueOptions.size} is a negative integer or zero`
+ `Invalid worker node tasks queue size: ${tasksQueueOptions.size} is a negative integer or zero`
)
}
}
...(this.opts.enableTasksQueue === true && {
backPressure: this.hasBackPressure()
}),
+ ...(this.opts.enableTasksQueue === true && {
+ stolenTasks: this.workerNodes.reduce(
+ (accumulator, workerNode) =>
+ accumulator + workerNode.usage.tasks.stolen,
+ 0
+ )
+ }),
failedTasks: this.workerNodes.reduce(
(accumulator, workerNode) =>
accumulator + workerNode.usage.tasks.failed,
)
)
),
- average: round(
- average(
- this.workerNodes.reduce<number[]>(
- (accumulator, workerNode) =>
- accumulator.concat(workerNode.usage.runTime.history),
- []
+ ...(this.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+ .runTime.average && {
+ average: round(
+ average(
+ this.workerNodes.reduce<number[]>(
+ (accumulator, workerNode) =>
+ accumulator.concat(workerNode.usage.runTime.history),
+ []
+ )
)
)
- ),
+ }),
...(this.workerChoiceStrategyContext.getTaskStatisticsRequirements()
.runTime.median && {
median: round(
median(
- this.workerNodes.map(
- (workerNode) => workerNode.usage.runTime?.median ?? 0
+ this.workerNodes.reduce<number[]>(
+ (accumulator, workerNode) =>
+ accumulator.concat(workerNode.usage.runTime.history),
+ []
)
)
)
)
)
),
- average: round(
- average(
- this.workerNodes.reduce<number[]>(
- (accumulator, workerNode) =>
- accumulator.concat(workerNode.usage.waitTime.history),
- []
+ ...(this.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+ .waitTime.average && {
+ average: round(
+ average(
+ this.workerNodes.reduce<number[]>(
+ (accumulator, workerNode) =>
+ accumulator.concat(workerNode.usage.waitTime.history),
+ []
+ )
)
)
- ),
+ }),
...(this.workerChoiceStrategyContext.getTaskStatisticsRequirements()
.waitTime.median && {
median: round(
median(
- this.workerNodes.map(
- (workerNode) => workerNode.usage.waitTime?.median ?? 0
+ this.workerNodes.reduce<number[]>(
+ (accumulator, workerNode) =>
+ accumulator.concat(workerNode.usage.waitTime.history),
+ []
)
)
)
return await new Promise<Response>((resolve, reject) => {
if (!this.started) {
reject(new Error('Cannot execute a task on destroyed pool'))
+ return
}
if (name != null && typeof name !== 'string') {
reject(new TypeError('name argument must be a string'))
+ return
}
if (
name != null &&
name.trim().length === 0
) {
reject(new TypeError('name argument must not be an empty string'))
+ return
}
if (transferList != null && !Array.isArray(transferList)) {
reject(new TypeError('transferList argument must be an array'))
+ return
}
const timestamp = performance.now()
const workerNodeKey = this.chooseWorkerNode()
const workerInfo = this.getWorkerInfo(workerNodeKey) as WorkerInfo
- if (
- name != null &&
- Array.isArray(workerInfo.taskFunctions) &&
- !workerInfo.taskFunctions.includes(name)
- ) {
- reject(
- new Error(`Task function '${name}' is not registered in the pool`)
- )
- }
const task: Task<Data> = {
name: name ?? DEFAULT_TASK_NAME,
// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
if (
this.opts.enableTasksQueue === false ||
(this.opts.enableTasksQueue === true &&
+ this.tasksQueueSize(workerNodeKey) === 0 &&
this.workerNodes[workerNodeKey].usage.tasks.executing <
(this.opts.tasksQueueOptions?.concurrency as number))
) {
* @virtual
*/
protected setupHook (): void {
- // Intentionally empty
+ /** Intentionally empty */
}
/**
while (this.tasksQueueSize(workerNodeKey) > 0) {
let destinationWorkerNodeKey!: number
let minQueuedTasks = Infinity
- let executeTask = false
for (const [workerNodeId, workerNode] of this.workerNodes.entries()) {
if (workerNode.info.ready && workerNodeId !== workerNodeKey) {
- if (
- workerNode.usage.tasks.executing <
- (this.opts.tasksQueueOptions?.concurrency as number)
- ) {
- executeTask = true
- }
if (workerNode.usage.tasks.queued === 0) {
destinationWorkerNodeKey = workerNodeId
break
}
}
if (destinationWorkerNodeKey != null) {
+ const destinationWorkerNode = this.workerNodes[destinationWorkerNodeKey]
const task = {
...(this.dequeueTask(workerNodeKey) as Task<Data>),
- workerId: (this.getWorkerInfo(destinationWorkerNodeKey) as WorkerInfo)
- .id as number
+ workerId: destinationWorkerNode.info.id as number
}
- if (executeTask) {
+ if (
+ this.tasksQueueSize(destinationWorkerNodeKey) === 0 &&
+ destinationWorkerNode.usage.tasks.executing <
+ (this.opts.tasksQueueOptions?.concurrency as number)
+ ) {
this.executeTask(destinationWorkerNodeKey, task)
} else {
this.enqueueTask(destinationWorkerNodeKey, task)
workerId: destinationWorkerNode.info.id as number
}
if (
+ this.tasksQueueSize(destinationWorkerNodeKey) === 0 &&
destinationWorkerNode.usage.tasks.executing <
- (this.opts.tasksQueueOptions?.concurrency as number)
+ (this.opts.tasksQueueOptions?.concurrency as number)
) {
this.executeTask(destinationWorkerNodeKey, task)
} else {
this.enqueueTask(destinationWorkerNodeKey, task)
}
+ if (destinationWorkerNode?.usage != null) {
+ ++destinationWorkerNode.usage.tasks.stolen
+ }
+ if (
+ this.shallUpdateTaskFunctionWorkerUsage(destinationWorkerNodeKey) &&
+ destinationWorkerNode.getTaskFunctionWorkerUsage(
+ task.name as string
+ ) != null
+ ) {
+ const taskFunctionWorkerUsage =
+ destinationWorkerNode.getTaskFunctionWorkerUsage(
+ task.name as string
+ ) as WorkerUsage
+ ++taskFunctionWorkerUsage.tasks.stolen
+ }
break
}
}
}
private tasksStealingOnBackPressure (workerId: number): void {
+ if ((this.opts.tasksQueueOptions?.size as number) <= 1) {
+ return
+ }
const sourceWorkerNode =
this.workerNodes[this.getWorkerNodeKeyByWorkerId(workerId)]
const workerNodes = this.workerNodes
...(sourceWorkerNode.popTask() as Task<Data>),
workerId: workerNode.info.id as number
}
- if (
- workerNode.usage.tasks.executing <
- (this.opts.tasksQueueOptions?.concurrency as number)
- ) {
+ if (this.tasksQueueSize(workerNodeKey) === 0) {
this.executeTask(workerNodeKey, task)
} else {
this.enqueueTask(workerNodeKey, task)
}
+ if (workerNode?.usage != null) {
+ ++workerNode.usage.tasks.stolen
+ }
+ if (
+ this.shallUpdateTaskFunctionWorkerUsage(workerNodeKey) &&
+ workerNode.getTaskFunctionWorkerUsage(task.name as string) != null
+ ) {
+ const taskFunctionWorkerUsage = workerNode.getTaskFunctionWorkerUsage(
+ task.name as string
+ ) as WorkerUsage
+ ++taskFunctionWorkerUsage.tasks.stolen
+ }
}
}
}
repositories / poolifier.git / blobdiff