X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fpools%2Fselection-strategies%2Fabstract-worker-choice-strategy.ts;h=f244374291da55b9173129b6384b00f49d952e65;hb=0e8587d2e6bc29e14158c01948c625df9b11d381;hp=41573ab43dcafe60560b25924fbf1adb94901970;hpb=8d1e1b3b417d37460c091ec8db3ac862201a244e;p=poolifier.git diff --git a/src/pools/selection-strategies/abstract-worker-choice-strategy.ts b/src/pools/selection-strategies/abstract-worker-choice-strategy.ts index 41573ab4..f2443742 100644 --- a/src/pools/selection-strategies/abstract-worker-choice-strategy.ts +++ b/src/pools/selection-strategies/abstract-worker-choice-strategy.ts @@ -1,19 +1,23 @@ -import { cpus } from 'node:os' -import { DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS } from '../../utils' -import type { IPool } from '../pool' -import type { IWorker } from '../worker' +import { + DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS, + buildWorkerChoiceStrategyOptions +} from '../../utils.js' +import type { IPool } from '../pool.js' +import type { IWorker } from '../worker.js' import type { IWorkerChoiceStrategy, + MeasurementStatisticsRequirements, + StrategyPolicy, TaskStatisticsRequirements, WorkerChoiceStrategyOptions -} from './selection-strategies-types' +} from './selection-strategies-types.js' /** * Worker choice strategy abstract base class. * * @typeParam Worker - Type of worker which manages the strategy. - * @typeParam Data - Type of data sent to the worker. This can only be serializable data. - * @typeParam Response - Type of execution response. This can only be serializable data. + * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data. + * @typeParam Response - Type of execution response. This can only be structured-cloneable data. */ export abstract class AbstractWorkerChoiceStrategy< Worker extends IWorker, @@ -21,18 +25,26 @@ export abstract class AbstractWorkerChoiceStrategy< Response = unknown > implements IWorkerChoiceStrategy { /** - * Toggles finding the last free worker node key. + * The next worker node key. */ - private toggleFindLastFreeWorkerNodeKey: boolean = false + protected nextWorkerNodeKey: number | undefined = 0 + + /** + * The previous worker node key. + */ + protected previousWorkerNodeKey = 0 + + /** @inheritDoc */ + public readonly strategyPolicy: StrategyPolicy = { + dynamicWorkerUsage: false, + dynamicWorkerReady: true + } + /** @inheritDoc */ public readonly taskStatisticsRequirements: TaskStatisticsRequirements = { - runTime: false, - avgRunTime: false, - medRunTime: false, - waitTime: false, - avgWaitTime: false, - medWaitTime: false, - elu: false + runTime: DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS, + waitTime: DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS, + elu: DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS } /** @@ -43,42 +55,51 @@ export abstract class AbstractWorkerChoiceStrategy< */ public constructor ( protected readonly pool: IPool, - protected opts: WorkerChoiceStrategyOptions = DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS + protected opts?: WorkerChoiceStrategyOptions ) { this.choose = this.choose.bind(this) + this.setOptions(this.opts) } - protected setTaskStatistics (opts: WorkerChoiceStrategyOptions): void { - if ( - this.taskStatisticsRequirements.avgRunTime && - opts.medRunTime === true - ) { - this.taskStatisticsRequirements.avgRunTime = false - this.taskStatisticsRequirements.medRunTime = opts.medRunTime as boolean - } - if ( - this.taskStatisticsRequirements.medRunTime && - opts.medRunTime === false - ) { - this.taskStatisticsRequirements.avgRunTime = true - this.taskStatisticsRequirements.medRunTime = opts.medRunTime as boolean - } - if ( - this.taskStatisticsRequirements.avgWaitTime && - opts.medWaitTime === true - ) { - this.taskStatisticsRequirements.avgWaitTime = false - this.taskStatisticsRequirements.medWaitTime = opts.medWaitTime as boolean + protected setTaskStatisticsRequirements ( + opts: WorkerChoiceStrategyOptions | undefined + ): void { + this.toggleMedianMeasurementStatisticsRequirements( + this.taskStatisticsRequirements.runTime, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + opts!.runTime!.median + ) + this.toggleMedianMeasurementStatisticsRequirements( + this.taskStatisticsRequirements.waitTime, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + opts!.waitTime!.median + ) + this.toggleMedianMeasurementStatisticsRequirements( + this.taskStatisticsRequirements.elu, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + opts!.elu!.median + ) + } + + private toggleMedianMeasurementStatisticsRequirements ( + measurementStatisticsRequirements: MeasurementStatisticsRequirements, + toggleMedian: boolean + ): void { + if (measurementStatisticsRequirements.average && toggleMedian) { + measurementStatisticsRequirements.average = false + measurementStatisticsRequirements.median = toggleMedian } - if ( - this.taskStatisticsRequirements.medWaitTime && - opts.medWaitTime === false - ) { - this.taskStatisticsRequirements.avgWaitTime = true - this.taskStatisticsRequirements.medWaitTime = opts.medWaitTime as boolean + if (measurementStatisticsRequirements.median && !toggleMedian) { + measurementStatisticsRequirements.average = true + measurementStatisticsRequirements.median = toggleMedian } } + protected resetWorkerNodeKeyProperties (): void { + this.nextWorkerNodeKey = 0 + this.previousWorkerNodeKey = 0 + } + /** @inheritDoc */ public abstract reset (): boolean @@ -86,111 +107,94 @@ export abstract class AbstractWorkerChoiceStrategy< public abstract update (workerNodeKey: number): boolean /** @inheritDoc */ - public abstract choose (): number + public abstract choose (): number | undefined /** @inheritDoc */ public abstract remove (workerNodeKey: number): boolean /** @inheritDoc */ - public setOptions (opts: WorkerChoiceStrategyOptions): void { - opts = opts ?? DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS - this.setTaskStatistics(opts) - this.opts = opts + public setOptions (opts: WorkerChoiceStrategyOptions | undefined): void { + this.opts = buildWorkerChoiceStrategyOptions( + this.pool, + opts + ) + this.setTaskStatisticsRequirements(this.opts) } /** - * Finds a free worker node key. + * Whether the worker node is ready or not. * - * @returns The free worker node key or `-1` if there is no free worker node. + * @param workerNodeKey - The worker node key. + * @returns Whether the worker node is ready or not. + */ + protected isWorkerNodeReady (workerNodeKey: number): boolean { + return this.pool.workerNodes[workerNodeKey]?.info?.ready ?? false + } + + /** + * Check the next worker node key. */ - protected findFreeWorkerNodeKey (): number { - if (this.toggleFindLastFreeWorkerNodeKey) { - this.toggleFindLastFreeWorkerNodeKey = false - return this.findLastFreeWorkerNodeKey() + protected checkNextWorkerNodeKey (): void { + if ( + this.nextWorkerNodeKey != null && + (this.nextWorkerNodeKey < 0 || + !this.isWorkerNodeReady(this.nextWorkerNodeKey)) + ) { + delete this.nextWorkerNodeKey } - this.toggleFindLastFreeWorkerNodeKey = true - return this.findFirstFreeWorkerNodeKey() } /** - * Gets the worker task runtime. - * If the task statistics require `avgRunTime`, the average runtime is returned. - * If the task statistics require `medRunTime`, the median runtime is returned. + * Gets the worker node task runtime. + * If the task statistics require the average runtime, the average runtime is returned. + * If the task statistics require the median runtime , the median runtime is returned. * * @param workerNodeKey - The worker node key. - * @returns The worker task runtime. + * @returns The worker node task runtime. */ - protected getWorkerTaskRunTime (workerNodeKey: number): number { - return this.taskStatisticsRequirements.medRunTime - ? this.pool.workerNodes[workerNodeKey].workerUsage.runTime.median - : this.pool.workerNodes[workerNodeKey].workerUsage.runTime.average + protected getWorkerNodeTaskRunTime (workerNodeKey: number): number { + return this.taskStatisticsRequirements.runTime.median + ? this.pool.workerNodes[workerNodeKey].usage.runTime.median ?? 0 + : this.pool.workerNodes[workerNodeKey].usage.runTime.average ?? 0 } /** - * Gets the worker task wait time. - * If the task statistics require `avgWaitTime`, the average wait time is returned. - * If the task statistics require `medWaitTime`, the median wait time is returned. + * Gets the worker node task wait time. + * If the task statistics require the average wait time, the average wait time is returned. + * If the task statistics require the median wait time, the median wait time is returned. * * @param workerNodeKey - The worker node key. - * @returns The worker task wait time. + * @returns The worker node task wait time. */ - protected getWorkerWaitTime (workerNodeKey: number): number { - return this.taskStatisticsRequirements.medWaitTime - ? this.pool.workerNodes[workerNodeKey].workerUsage.runTime.median - : this.pool.workerNodes[workerNodeKey].workerUsage.runTime.average - } - - protected computeDefaultWorkerWeight (): number { - let cpusCycleTimeWeight = 0 - for (const cpu of cpus()) { - // CPU estimated cycle time - const numberOfDigits = cpu.speed.toString().length - 1 - const cpuCycleTime = 1 / (cpu.speed / Math.pow(10, numberOfDigits)) - cpusCycleTimeWeight += cpuCycleTime * Math.pow(10, numberOfDigits) - } - return Math.round(cpusCycleTimeWeight / cpus().length) + protected getWorkerNodeTaskWaitTime (workerNodeKey: number): number { + return this.taskStatisticsRequirements.waitTime.median + ? this.pool.workerNodes[workerNodeKey].usage.waitTime.median ?? 0 + : this.pool.workerNodes[workerNodeKey].usage.waitTime.average ?? 0 } /** - * Finds the first free worker node key based on the number of tasks the worker has applied. - * - * If a worker is found with `0` executing tasks, it is detected as free and its worker node key is returned. - * - * If no free worker is found, `-1` is returned. + * Gets the worker node task ELU. + * If the task statistics require the average ELU, the average ELU is returned. + * If the task statistics require the median ELU, the median ELU is returned. * - * @returns A worker node key if there is one, `-1` otherwise. + * @param workerNodeKey - The worker node key. + * @returns The worker node task ELU. */ - private findFirstFreeWorkerNodeKey (): number { - return this.pool.workerNodes.findIndex(workerNode => { - return workerNode.workerUsage.tasks.executing === 0 - }) + protected getWorkerNodeTaskElu (workerNodeKey: number): number { + return this.taskStatisticsRequirements.elu.median + ? this.pool.workerNodes[workerNodeKey].usage.elu.active.median ?? 0 + : this.pool.workerNodes[workerNodeKey].usage.elu.active.average ?? 0 } /** - * Finds the last free worker node key based on the number of tasks the worker has applied. - * - * If a worker is found with `0` executing tasks, it is detected as free and its worker node key is returned. + * Sets safely the previous worker node key. * - * If no free worker is found, `-1` is returned. - * - * @returns A worker node key if there is one, `-1` otherwise. + * @param workerNodeKey - The worker node key. */ - private findLastFreeWorkerNodeKey (): number { - // It requires node >= 18.0.0: - // return this.workerNodes.findLastIndex(workerNode => { - // return workerNode.workerUsage.tasks.executing === 0 - // }) - for ( - let workerNodeKey = this.pool.workerNodes.length - 1; - workerNodeKey >= 0; - workerNodeKey-- - ) { - if ( - this.pool.workerNodes[workerNodeKey].workerUsage.tasks.executing === 0 - ) { - return workerNodeKey - } - } - return -1 + protected setPreviousWorkerNodeKey (workerNodeKey: number | undefined): void { + this.previousWorkerNodeKey = + workerNodeKey != null && workerNodeKey >= 0 + ? workerNodeKey + : this.previousWorkerNodeKey } }