multiprocessor
Version:
Multiprocessing pool implementation for NodeJS and TypeScript
513 lines • 24.9 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __asyncValues = (this && this.__asyncValues) || function (o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
};
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Pool = void 0;
var path = __importStar(require("path"));
var events_1 = require("events");
var child_process_1 = require("child_process");
/**
* A class representing a pool of workers for executing tasks concurrently using child processes.
* Extends EventEmitter to allow task result events to be emitted.
*/
var Pool = /** @class */ (function (_super) {
__extends(Pool, _super);
/**
* Create a new pool with the specified number of workers.
*
* @param poolSize The number of workers to create in the pool.
*/
function Pool(poolSize) {
var _this = _super.call(this) || this;
/**
* Array of child processes representing the workers in the pool.
*/
_this.workers = [];
/**
* Array of child processes representing the available workers in the pool.
*/
_this.availableWorkers = [];
/**
* Array of tasks to be processed in the pool.
*/
_this.taskQueue = [];
/**
* Map of tasks currently being processed by workers, keyed by worker.
*/
_this.tasksInProcess = new Map();
/**
* Current task index, incremented for each task processed.
*/
_this.currentTaskIndex = 0;
_this.initWorkers(poolSize);
_this.taskHandlers = {
onTaskSuccess: _this.createEmptyHandler(),
onTaskError: _this.createEmptyHandler(),
};
return _this;
}
/**
* Asynchronously processes tasks from the provided inputs in an ordered manner.
* Tasks are executed concurrently using a pool of workers.
*
* @template TInput The type of the input elements.
* @template TResult The type of the result elements.
*
* @param inputs An iterable or async iterable of input elements.
* @param task The task to execute for each input element.
* @param taskHandlers Optional handlers for task events (onTaskSuccess, onTaskError).
*
* @returns A promise that resolves to an array of task results in the order of the input elements.
*/
Pool.prototype.map = function (inputs, task, taskHandlers) {
return __awaiter(this, void 0, void 0, function () {
var result, _a, _b, _c, item, e_1_1;
var _d, e_1, _e, _f;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
result = [];
_g.label = 1;
case 1:
_g.trys.push([1, 6, 7, 12]);
_a = true, _b = __asyncValues(this.imapUnorderedExtended(inputs, task, taskHandlers));
_g.label = 2;
case 2: return [4 /*yield*/, _b.next()];
case 3:
if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 5];
_f = _c.value;
_a = false;
item = _f;
result.push(item);
_g.label = 4;
case 4:
_a = true;
return [3 /*break*/, 2];
case 5: return [3 /*break*/, 12];
case 6:
e_1_1 = _g.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 12];
case 7:
_g.trys.push([7, , 10, 11]);
if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 9];
return [4 /*yield*/, _e.call(_b)];
case 8:
_g.sent();
_g.label = 9;
case 9: return [3 /*break*/, 11];
case 10:
if (e_1) throw e_1.error;
return [7 /*endfinally*/];
case 11: return [7 /*endfinally*/];
case 12:
result.sort(function (lhs, rhs) { return lhs[0] - rhs[0]; });
return [2 /*return*/, result.map(function (item) { return item[1]; })];
}
});
});
};
/**
* Asynchronously processes tasks from the provided inputs in a lazy ordered manner.
* Tasks are executed concurrently using a pool of workers.
*
* @template TInput The type of the input elements.
* @template TResult The type of the result elements.
*
* @param inputs An iterable or async iterable of input elements.
* @param task The task to execute for each input element.
* @param taskHandlers Optional handlers for task events (onTaskSuccess, onTaskError).
*
* @returns An async generator yielding results of the tasks in the order of the input elements.
*/
Pool.prototype.imap = function (inputs, task, taskHandlers) {
return __asyncGenerator(this, arguments, function imap_1() {
var lastYieldedIndex, bufferedResults, _a, _b, _c, _d, taskIndex, result, e_2_1;
var _e, e_2, _f, _g;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
lastYieldedIndex = -1;
bufferedResults = new Map();
_h.label = 1;
case 1:
_h.trys.push([1, 11, 12, 17]);
_a = true, _b = __asyncValues(this.imapUnorderedExtended(inputs, task, taskHandlers));
_h.label = 2;
case 2: return [4 /*yield*/, __await(_b.next())];
case 3:
if (!(_c = _h.sent(), _e = _c.done, !_e)) return [3 /*break*/, 10];
_g = _c.value;
_a = false;
_d = __read(_g, 2), taskIndex = _d[0], result = _d[1];
if (taskIndex !== lastYieldedIndex + 1) {
bufferedResults.set(taskIndex, result);
return [3 /*break*/, 9];
}
++lastYieldedIndex;
return [4 /*yield*/, __await(result)];
case 4: return [4 /*yield*/, _h.sent()];
case 5:
_h.sent();
_h.label = 6;
case 6:
if (!bufferedResults.has(lastYieldedIndex + 1)) return [3 /*break*/, 9];
return [4 /*yield*/, __await(bufferedResults.get(lastYieldedIndex + 1))];
case 7: return [4 /*yield*/, _h.sent()];
case 8:
_h.sent();
bufferedResults.delete(lastYieldedIndex + 1);
++lastYieldedIndex;
return [3 /*break*/, 6];
case 9:
_a = true;
return [3 /*break*/, 2];
case 10: return [3 /*break*/, 17];
case 11:
e_2_1 = _h.sent();
e_2 = { error: e_2_1 };
return [3 /*break*/, 17];
case 12:
_h.trys.push([12, , 15, 16]);
if (!(!_a && !_e && (_f = _b.return))) return [3 /*break*/, 14];
return [4 /*yield*/, __await(_f.call(_b))];
case 13:
_h.sent();
_h.label = 14;
case 14: return [3 /*break*/, 16];
case 15:
if (e_2) throw e_2.error;
return [7 /*endfinally*/];
case 16: return [7 /*endfinally*/];
case 17: return [2 /*return*/];
}
});
});
};
/**
* Asynchronously processes tasks from the provided inputs in a lazy unordered manner.
* Tasks are executed concurrently using a pool of workers.
*
* @template TInput The type of the input elements.
* @template TResult The type of the result elements.
*
* @param inputs An iterable or async iterable of input elements.
* @param task The task to execute for each input element.
* @param taskHandlers Optional handlers for task events (onTaskSuccess, onTaskError).
*
* @returns An async generator yielding results of the tasks in completion order.
*/
Pool.prototype.imapUnordered = function (inputs, task, taskHandlers) {
return __asyncGenerator(this, arguments, function imapUnordered_1() {
var _a, _b, _c, _d, _, result, e_3_1;
var _e, e_3, _f, _g;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
_h.trys.push([0, 7, 8, 13]);
_a = true, _b = __asyncValues(this.imapUnorderedExtended(inputs, task, taskHandlers));
_h.label = 1;
case 1: return [4 /*yield*/, __await(_b.next())];
case 2:
if (!(_c = _h.sent(), _e = _c.done, !_e)) return [3 /*break*/, 6];
_g = _c.value;
_a = false;
_d = __read(_g, 2), _ = _d[0], result = _d[1];
return [4 /*yield*/, __await(result)];
case 3: return [4 /*yield*/, _h.sent()];
case 4:
_h.sent();
_h.label = 5;
case 5:
_a = true;
return [3 /*break*/, 1];
case 6: return [3 /*break*/, 13];
case 7:
e_3_1 = _h.sent();
e_3 = { error: e_3_1 };
return [3 /*break*/, 13];
case 8:
_h.trys.push([8, , 11, 12]);
if (!(!_a && !_e && (_f = _b.return))) return [3 /*break*/, 10];
return [4 /*yield*/, __await(_f.call(_b))];
case 9:
_h.sent();
_h.label = 10;
case 10: return [3 /*break*/, 12];
case 11:
if (e_3) throw e_3.error;
return [7 /*endfinally*/];
case 12: return [7 /*endfinally*/];
case 13: return [2 /*return*/];
}
});
});
};
/**
* Asynchronously processes tasks from the provided inputs in a lazy unordered manner with extended information.
* Tasks are executed concurrently using a pool of workers.
*
* @template TInput The type of the input elements.
* @template TResult The type of the result elements.
*
* @param inputs An iterable or async iterable of input elements.
* @param task The task to execute for each input element.
* @param taskHandlers Optional handlers for task events (onTaskSuccess, onTaskError).
*
* @returns An async generator yielding task responses containing the index, result or error for each task.
*/
Pool.prototype.imapUnorderedExtended = function (inputs, task, taskHandlers) {
return __asyncGenerator(this, arguments, function imapUnorderedExtended_1() {
var taskFunctionString, totalTasks, _a, inputs_1, inputs_1_1, inputData, e_4_1, received, result;
var _this = this;
var _b, e_4, _c, _d;
var _e, _f;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
this.currentTaskIndex = 0;
this.taskHandlers.onTaskSuccess = (_e = taskHandlers === null || taskHandlers === void 0 ? void 0 : taskHandlers.onTaskSuccess) !== null && _e !== void 0 ? _e : this.createEmptyHandler();
this.taskHandlers.onTaskError = (_f = taskHandlers === null || taskHandlers === void 0 ? void 0 : taskHandlers.onTaskError) !== null && _f !== void 0 ? _f : this.createEmptyHandler();
taskFunctionString = task.toString();
totalTasks = 0;
_g.label = 1;
case 1:
_g.trys.push([1, 6, 7, 12]);
_a = true, inputs_1 = __asyncValues(inputs);
_g.label = 2;
case 2: return [4 /*yield*/, __await(inputs_1.next())];
case 3:
if (!(inputs_1_1 = _g.sent(), _b = inputs_1_1.done, !_b)) return [3 /*break*/, 5];
_d = inputs_1_1.value;
_a = false;
inputData = _d;
this.taskQueue.push({ inputData: inputData, taskFunctionString: taskFunctionString });
++totalTasks;
_g.label = 4;
case 4:
_a = true;
return [3 /*break*/, 2];
case 5: return [3 /*break*/, 12];
case 6:
e_4_1 = _g.sent();
e_4 = { error: e_4_1 };
return [3 /*break*/, 12];
case 7:
_g.trys.push([7, , 10, 11]);
if (!(!_a && !_b && (_c = inputs_1.return))) return [3 /*break*/, 9];
return [4 /*yield*/, __await(_c.call(inputs_1))];
case 8:
_g.sent();
_g.label = 9;
case 9: return [3 /*break*/, 11];
case 10:
if (e_4) throw e_4.error;
return [7 /*endfinally*/];
case 11: return [7 /*endfinally*/];
case 12:
// Start processing
this.processQueue();
received = 0;
_g.label = 13;
case 13:
if (!(received < totalTasks)) return [3 /*break*/, 17];
return [4 /*yield*/, __await(new Promise(function (resolve) {
_this.once('result', resolve);
}))];
case 14:
result = _g.sent();
received++;
return [4 /*yield*/, __await([result.taskIndex, result.result, result.error])];
case 15: return [4 /*yield*/, _g.sent()];
case 16:
_g.sent();
return [3 /*break*/, 13];
case 17: return [2 /*return*/];
}
});
});
};
/**
* Closes the worker pool by terminating all worker processes.
* This method should be called when the pool is no longer needed
* to ensure that all resources are properly released.
*/
Pool.prototype.close = function () {
var e_5, _a;
try {
for (var _b = __values(this.workers), _c = _b.next(); !_c.done; _c = _b.next()) {
var worker = _c.value;
worker.kill();
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_5) throw e_5.error; }
}
};
Pool.prototype.processQueue = function () {
while (this.availableWorkers.length > 0 && this.taskQueue.length > 0) {
var worker = this.availableWorkers.shift();
var task = this.taskQueue.shift();
this.tasksInProcess.set(worker, task.inputData);
worker.send({
taskFunctionString: task.taskFunctionString,
inputData: task.inputData,
taskIndex: this.currentTaskIndex++,
});
}
};
Pool.prototype.initWorkers = function (poolSize) {
var _this = this;
var _loop_1 = function (i) {
var worker = (0, child_process_1.fork)(path.resolve(__dirname, './worker.js'));
worker.on('message', function (message) {
var result = message.result, error = message.error, inputData = message.inputData, taskIndex = message.taskIndex;
if (error) {
_this.taskHandlers.onTaskError(error, inputData, taskIndex);
}
else {
_this.taskHandlers.onTaskSuccess(result, inputData, taskIndex);
}
_this.emit('result', { result: result, taskIndex: taskIndex, error: error });
_this.tasksInProcess.delete(worker);
_this.availableWorkers.push(worker);
_this.processQueue();
});
this_1.workers.push(worker);
this_1.availableWorkers.push(worker);
};
var this_1 = this;
for (var i = 0; i < poolSize; i++) {
_loop_1(i);
}
};
Pool.prototype.createEmptyHandler = function () {
return function () { };
};
return Pool;
}(events_1.EventEmitter));
exports.Pool = Pool;
//# sourceMappingURL=pool.js.map