vodorod/parcer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: lint

Browse Source
This commit is contained in:
karishmas6
2024-06-12 20:09:31 +05:30
parent 779c1f66cc
commit 88620344f7
1 changed files with 77 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
mx-interpreter/utils/concurrency.ts
View File

@@ -2,84 +2,84 @@
* Concurrency class for running concurrent tasks while managing a limited amount of resources. * Concurrency class for running concurrent tasks while managing a limited amount of resources.
*/ */
export default class Concurrency { export default class Concurrency {
/** /**
* Maximum number of workers running in parallel. If set to `null`, there is no limit. * Maximum number of workers running in parallel. If set to `null`, there is no limit.
*/ */
maxConcurrency : number = 1; maxConcurrency: number = 1;
/** /**
* Number of currently active workers. * Number of currently active workers.
*/ */
activeWorkers : number = 0; activeWorkers: number = 0;
/** /**
* Queue of jobs waiting to be completed. * Queue of jobs waiting to be completed.
*/ */
private jobQueue : Function[] = []; private jobQueue: Function[] = [];
/** /**
* "Resolve" callbacks of the waitForCompletion() promises. * "Resolve" callbacks of the waitForCompletion() promises.
*/ */
private waiting : Function[] = []; private waiting: Function[] = [];
/** /**
* Constructs a new instance of concurrency manager. * Constructs a new instance of concurrency manager.
* @param {number} maxConcurrency Maximum number of workers running in parallel. * @param {number} maxConcurrency Maximum number of workers running in parallel.
*/ */
constructor(maxConcurrency: number) { constructor(maxConcurrency: number) {
this.maxConcurrency = maxConcurrency; this.maxConcurrency = maxConcurrency;
} }
/** /**
* Takes a waiting job out of the queue and runs it. * Takes a waiting job out of the queue and runs it.
*/ */
private runNextJob() : void { private runNextJob(): void {
const job = this.jobQueue.pop(); const job = this.jobQueue.pop();
if (job) { if (job) {
// console.debug("Running a job..."); // console.debug("Running a job...");
job().then(() => { job().then(() => {
// console.debug("Job finished, running the next waiting job..."); // console.debug("Job finished, running the next waiting job...");
this.runNextJob();
});
} else {
// console.debug("No waiting job found!");
this.activeWorkers -= 1;
if (this.activeWorkers === 0) {
// console.debug("This concurrency manager is idle!");
this.waiting.forEach((x) => x());
}
}
}
/**
* Pass a job (a time-demanding async function) to the concurrency manager. \
* The time of the job's execution depends on the concurrency manager itself
* (given a generous enough `maxConcurrency` value, it might be immediate,
* but this is not guaranteed).
* @param worker Async function to be executed (job to be processed).
*/
addJob(job: () => Promise<any>) : void {
// console.debug("Adding a worker!");
this.jobQueue.push(job);
if (!this.maxConcurrency || this.activeWorkers < this.maxConcurrency) {
this.runNextJob(); this.runNextJob();
this.activeWorkers += 1; });
} else { } else {
// console.debug("No capacity to run a worker now, waiting!"); // console.debug("No waiting job found!");
this.activeWorkers -= 1;
if (this.activeWorkers === 0) {
// console.debug("This concurrency manager is idle!");
this.waiting.forEach((x) => x());
} }
} }
}
/**
* Waits until there is no running nor waiting job. \ /**
* If the concurrency manager is idle at the time of calling this function, * Pass a job (a time-demanding async function) to the concurrency manager. \
* it waits until at least one job is compeleted (can be "presubscribed"). * The time of the job's execution depends on the concurrency manager itself
* @returns Promise, resolved after there is no running/waiting worker. * (given a generous enough `maxConcurrency` value, it might be immediate,
*/ * but this is not guaranteed).
waitForCompletion() : Promise<void> { * @param worker Async function to be executed (job to be processed).
return new Promise((res) => { */
this.waiting.push(res); addJob(job: () => Promise<any>): void {
}); // console.debug("Adding a worker!");
this.jobQueue.push(job);
if (!this.maxConcurrency || this.activeWorkers < this.maxConcurrency) {
this.runNextJob();
this.activeWorkers += 1;
} else {
// console.debug("No capacity to run a worker now, waiting!");
} }
} }
/**
* Waits until there is no running nor waiting job. \
* If the concurrency manager is idle at the time of calling this function,
* it waits until at least one job is compeleted (can be "presubscribed").
* @returns Promise, resolved after there is no running/waiting worker.
*/
waitForCompletion(): Promise<void> {
return new Promise((res) => {
this.waiting.push(res);
});
}
}