awv3/worker/factory.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _from = require('babel-runtime/core-js/array/from');

var _from2 = _interopRequireDefault(_from);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _uuidV = require('uuid-v4');

var _uuidV2 = _interopRequireDefault(_uuidV);

var _webworker = require('worker-loader?inline=true!../worker/webworker');

var _webworker2 = _interopRequireDefault(_webworker);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

//import webworker from '../worker/webworker';
//const blob = URL.createObjectURL( new Blob([ '(', webworker.toString(), ')(0)' ], { type: 'application/javascript' } ) );
var WorkerHandler = function () {
    function WorkerHandler() {
        var _this = this;

        (0, _classCallCheck3.default)(this, WorkerHandler);

        this.id = (0, _uuidV2.default)();
        this.worker = new _webworker2.default(); //new Worker(blob);
        this.promises = {};
        this.requests = [];

        this.worker.addEventListener('message', function (message) {
            switch (message.data.action) {
                case 'Finished':
                    var resolve = _this.promises[message.data.task].resolve;
                    delete _this.promises[message.data.task];
                    resolve(message.data);

                    if (_this.requests.length > 0) _this.requests.pop().resolve();
                    break;

                case 'Result':
                    if (!!_this.promises[message.data.task].callback) {
                        _this.promises[message.data.task].callback(message.data.result);
                    }
                    break;
            }
        }, false);
    }

    (0, _createClass3.default)(WorkerHandler, [{
        key: 'occupy',
        value: function occupy() {
            var token = {};
            token.promise = new _promise2.default(function (resolve) {
                return token.resolve = resolve;
            });
            this.requests.push(token);
        }

        // Wait until all tasks are completed, then return

    }, {
        key: 'wait',
        value: function wait() {
            var _this2 = this;

            return _promise2.default.all((0, _keys2.default)(this.promises).map(function (key) {
                return _this2.promises[key].promise;
            }).concat(this.requests.map(function (obj) {
                return obj.promise;
            }))).then(function () {
                return _this2;
            });
        }

        // Post message to worker

    }, {
        key: 'post',
        value: function post(obj, callback) {
            var _this3 = this;

            obj.task = (0, _uuidV2.default)();
            var task = { callback: callback };
            this.promises[obj.task] = task;
            task.promise = new _promise2.default(function (resolve) {
                task.resolve = resolve;
                var transfer = [];
                if (obj.type === 'Binary') {
                    transfer.push(obj.data.buffer);
                }
                _this3.worker.postMessage(obj, transfer);
            });
            return task.promise;
        }

        // This will race for a unused core

    }], [{
        key: 'getFreeCore',
        value: function getFreeCore() {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {

                for (var _iterator = (0, _getIterator3.default)(cores), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var _core = _step.value;

                    if (_core.requests.length == 0 && (0, _keys2.default)(_core.promises).length == 0) {
                        _core.occupy();
                        return _core;
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            var core = cores[Math.round(Math.random() * (cores.length - 1))];
            core.occupy();
            return core;
        }
    }]);
    return WorkerHandler;
}();

// Create a worker for each core


exports.default = WorkerHandler;
var cores = (0, _from2.default)(new Array(navigator.hardwareConcurrency || 4), function () {
    return new WorkerHandler();
});