awv3/src/worker/factory.js

⚡ AWV3 embedded CAD

//import webworker from '../worker/webworker';
//const blob = URL.createObjectURL( new Blob([ '(', webworker.toString(), ')(0)' ], { type: 'application/javascript' } ) );
import v4 from 'uuid-v4';
import Worker from 'worker-loader?inline=true!../worker/webworker';

export default class WorkerHandler {
    constructor() {
        this.id = v4();
        this.worker = new Worker(); //new Worker(blob);
        this.promises = {};
        this.requests = [];

        this.worker.addEventListener(
            'message',
            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
        );
    }

    occupy() {
        let token = {};
        token.promise = new Promise(resolve => token.resolve = resolve);
        this.requests.push(token);
    }

    // Wait until all tasks are completed, then return
    wait() {
        return Promise
            .all(
                Object.keys(this.promises)
                    .map(key => this.promises[key].promise)
                    .concat(this.requests.map(obj => obj.promise))
            )
            .then(() => this);
    }

    // Post message to worker
    post(obj, callback) {
        obj.task = v4();
        let task = { callback: callback };
        this.promises[obj.task] = task;
        task.promise = new Promise(resolve => {
            task.resolve = resolve;
            let transfer = [];
            if (obj.type === 'Binary') {
                transfer.push(obj.data.buffer);
            }
            this.worker.postMessage(obj, transfer);
        });
        return task.promise;
    }

    // This will race for a unused core
    static getFreeCore() {
        for (let core of cores) {
            if (core.requests.length == 0 && Object.keys(core.promises).length == 0) {
                core.occupy();
                return core;
            }
        }

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

    static callWorkers(props) {
        for (let core of cores) {
            core.worker.postMessage(props);
        }
    }
}

// Create a worker for each core
let cores = Array.from(new Array(navigator.hardwareConcurrency || 4), () => new WorkerHandler());