NikolayMakhonin / time-limits / #16

Committed 14 Nov 2023 06:53AM UTC coverage: 80.664% (-1.4%) from 82.045%

Build # #16

Build Type

push

Committed by

Commit Message

v1.0.0

Run Details

218 of 303 branches covered (0.0%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 2 files covered. (100.0%)

9 existing lines in 3 files now uncovered.

487 of 571 relevant lines covered (85.29%)

107854.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.62

/src/pool/Pool.ts

import {IAbortSignalFast} from '@flemist/abort-controller-fast'
import {CustomPromise, promiseToAbortable} from '@flemist/async-utils'
import {
  Priority,
  IPriorityQueue,
  PriorityQueue,
  AwaitPriority,
  awaitPriorityDefault,
} from '@flemist/priority-queue'

export interface IPool {
  readonly size: number
  readonly maxSize: number

  holdAvailable: number

  hold(count: number): boolean

  /** it returns false if the obj cannot be pushed into the object pool (if size >= maxSize) */
  releaseAvailable: number

  release(count: number, dontThrow?: boolean): Promise<number> | number

  /** it will resolve when size > 0 */
  tick(abortSignal?: IAbortSignalFast): Promise<void> | void

  /** wait size > 0 and hold, use this for concurrency hold */
  holdWait(
    count: number,
    priority?: Priority,
    abortSignal?: IAbortSignalFast,
    awaitPriority?: AwaitPriority,
  ): Promise<void>
}

// export interface IPoolSync extends IPool {
//   release(count: number): number
// }

export class Pool implements IPool {
  private readonly _priorityQueue: IPriorityQueue
  private readonly _maxSize: number = 0
  private _size: number = 0

  constructor(maxSize: number) {
    if (!maxSize) {
      throw new Error('maxSize should be > 0')
    }
    this._maxSize = maxSize
    this._size = maxSize
    this._priorityQueue = new PriorityQueue()
  }

  get maxSize() {
    return this._maxSize
  }

  get size() {
    return this._size
  }

  get holdAvailable() {
    return this._size
  }

  hold(count: number): boolean {
    const size = this._size
    if (count > size) {
      return false
    }
    this._size = size - count
    return true
  }

  get releaseAvailable() {
    return this.maxSize - this._size
  }

  release(count: number, dontThrow?: boolean): number {
    const size = this._size
    const maxReleaseCount = this.maxSize - size
    if (count > maxReleaseCount) {
      if (dontThrow) {
        count = maxReleaseCount
      }
      else {
        throw new Error(`count (${count} > maxReleaseCount (${maxReleaseCount}))`)
      }
    }
    if (count > 0) {
      this._size = size + count

      if (this._tickPromise) {
        const tickPromise = this._tickPromise
        this._tickPromise = null
        tickPromise.resolve()
      }
    }
    return count
  }

  private _tickPromise: CustomPromise = new CustomPromise()
  tick(abortSignal?: IAbortSignalFast): Promise<void> | void {
    if (this._size >= this._maxSize) {
      return
    }
    if (!this._tickPromise) {
      this._tickPromise = new CustomPromise()
    }
    return promiseToAbortable(abortSignal, this._tickPromise.promise)
  }

  holdWait(
    count: number,
    priority?: Priority,
    abortSignal?: IAbortSignalFast,
    awaitPriority?: AwaitPriority,
  ) {
    if (count > this.maxSize) {
      throw new Error(`holdCount (${count} > maxSize (${this.maxSize}))`)
    }

    if (!awaitPriority) {
      awaitPriority = awaitPriorityDefault
    }

    return this._priorityQueue.run(async (abortSignal) => {
      while (count > this._size) {
        await this.tick(abortSignal)
        await awaitPriority(priority, abortSignal)
      }
      if (!this.hold(count)) {
        throw new Error('Unexpected behavior')
      }
    }, priority, abortSignal)
  }
}


1	import {IAbortSignalFast} from '@flemist/abort-controller-fast'
2	import {CustomPromise, promiseToAbortable} from '@flemist/async-utils'	1✔
3	import {	1✔
4	Priority,
5	IPriorityQueue,
6	PriorityQueue,
7	AwaitPriority,	2✔
8	awaitPriorityDefault,
9	} from '@flemist/priority-queue'	23,240✔
10		23,240✔
11	export interface IPool {	23,240✔
12	readonly size: number	23,240!
13	readonly maxSize: number	×
14
15	holdAvailable: number	23,240✔
16		23,240✔
17	hold(count: number): boolean	23,240✔
18
19	/** it returns false if the obj cannot be pushed into the object pool (if size >= maxSize) */	2✔
20	releaseAvailable: number
21		1,103,636✔
22	release(count: number, dontThrow?: boolean): Promise<number> \| number
23
24	/** it will resolve when size > 0 */
25	tick(abortSignal?: IAbortSignalFast): Promise<void> \| void
26		2✔
27	/** wait size > 0 and hold, use this for concurrency hold */
28	holdWait(	1,322,319✔
29	count: number,
30	priority?: Priority,
31	abortSignal?: IAbortSignalFast,
32	awaitPriority?: AwaitPriority,
33	): Promise<void>	2✔
34	}
35		×
36	// export interface IPoolSync extends IPool {
37	// release(count: number): number
38	// }
39
40	export class Pool implements IPool {	2✔
41	private readonly _priorityQueue: IPriorityQueue	204,600✔
42	private readonly _maxSize: number = 0	204,600!
43	private _size: number = 0	31,032✔
44
45	constructor(maxSize: number) {	204,600✔
46	if (!maxSize) {	204,600!
47	throw new Error('maxSize should be > 0')	×
48	}	2✔
49	this._maxSize = maxSize	31,032✔
50	this._size = maxSize	31,032✔
51	this._priorityQueue = new PriorityQueue()	31,032✔
52	}
53
54	get maxSize() {
55	return this._maxSize	1,336,065✔
56	}	205,714✔
57		205,714✔
58	get size() {	205,714!
59	return this._size	1,638,891!
UNCOV 60	}	×
61
62	get holdAvailable() {
63	return this._size	×
64	}
65
66	hold(count: number): boolean {	205,714!
67	const size = this._size	282,369✔
68	if (count > size) {	282,369!
69	return false	142,988✔
70	}	142,988✔
71	this._size = size - count	282,369✔
72	return true	282,369✔
73	}
74		205,714✔
75	get releaseAvailable() {
76	return this.maxSize - this._size	2✔
77	}	221,782✔
78		33,779✔
79	release(count: number, dontThrow?: boolean): number {
80	const size = this._size	282,295✔
81	const maxReleaseCount = this.maxSize - size	282,295✔
82	if (count > maxReleaseCount) {	282,295!
83	if (dontThrow) {	188,003!
UNCOV 84	count = maxReleaseCount	×
85	}	2✔
86	else {	2,496✔
87	throw new Error(`count (${count} > maxReleaseCount (${maxReleaseCount}))`)	2,496!
88	}	×
89	}
90	if (count > 0) {	282,295!
91	this._size = size + count	282,295✔
92
93	if (this._tickPromise) {	282,295✔
94	const tickPromise = this._tickPromise	198,059✔
95	this._tickPromise = null	198,059✔
96	tickPromise.resolve()	198,059✔
97	}	2,912✔
98	}	416✔
99	return count	282,295✔
100	}	416✔
101		416✔
102	private _tickPromise: CustomPromise = new CustomPromise()	31,032✔
103	tick(abortSignal?: IAbortSignalFast): Promise<void> \| void {	416✔
104	if (this._size >= this._maxSize) {	305,897✔
105	return	45,687✔
106	}	2,496!
107	if (!this._tickPromise) {	260,210✔
108	this._tickPromise = new CustomPromise()	173,551✔
109	}	2,496✔
110	return promiseToAbortable(abortSignal, this._tickPromise.promise)	260,210✔
111	}
112
113	holdWait(
114	count: number,	2✔
115	priority?: Priority,
116	abortSignal?: IAbortSignalFast,
117	awaitPriority?: AwaitPriority,
118	) {
119	if (count > this.maxSize) {	1,248!
120	throw new Error(`holdCount (${count} > maxSize (${this.maxSize}))`)	×
121	}
122
123	if (!awaitPriority) {	1,248✔
124	awaitPriority = awaitPriorityDefault	624✔
125	}
126
127	return this._priorityQueue.run(async (abortSignal) => {	1,248✔
128	while (count > this._size) {	1,248✔
129	await this.tick(abortSignal)	208✔
130	await awaitPriority(priority, abortSignal)	208✔
131	}
132	if (!this.hold(count)) {	1,248!
133	throw new Error('Unexpected behavior')	×
134	}
135	}, priority, abortSignal)
136	}
137	}
138

NikolayMakhonin / time-limits / #16

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous