child_process ipc & shared memory experiment

master.js

const { fork } = require('child_process');
const cache = require('node-shared-cache');
let childCache = new cache.Cache('children', 524288);

let child;
function startWorker(ready) {
    child = fork(require.resolve('./worker'), {
        cwd: process.cwd(),
        silent: true
    });
    child.send('init');
    child.once('message', (data) => {
        ready();
    });
    child.stdout.pipe(process.stdout);
    child.stderr.pipe(process.stderr);
}

function pingWorker(data, callback) {
    childCache.request = data;
    child.send(1);
    child.once('message', (data) => {
        callback(childCache.response);
    });
}

function sendMessage(data, callback) {
    child.send(data);
    child.once('message', (data) => {
        callback(data);
    });
}

function kill() {
    if (child) {
        cache.release('children');
        child.kill('SIGTERM');
    }
    child = null;
}

exports.startWorker = startWorker;
exports.pingWorker = pingWorker;
exports.sendMessage = sendMessage;
exports.kill = kill;

worker.js

const testdata = require('../testdata.json');
const cache = require('node-shared-cache');
let processCache = new cache.Cache('children', 524288);

function initWorker() {
    process.send('ready');
}

function processMessage(type, data) {
    switch (type) {
        case 'ping':
            data = processCache.request;
            processCache.response = testdata;
            process.send(1);
            break;
        case 'ipc':
            process.send(testdata);
            break;
    }
}

process.on('message', (message) => {
    if (message === 'init') {
        initWorker();
    } else {
        if (typeof message === 'number') {
            processMessage('ping', message);
        } else {
            processMessage('ipc', message);
        }
    }
});

workers.test.js

const assert = require('assert');
const testdata = require('../testdata.json');
const master = require('../lib/master');

function startWorker() {
    return new Promise((resolve, reject) => {
        master.startWorker(() => {
            resolve(master);
        });
    });
}

function sendMessage(data) {
    return new Promise((resolve, reject) => {
        master.sendMessage(data, (response) => {
            resolve(response);
        });
    });
}

function pingWorker(data) {
    return new Promise((resolve, reject) => {
        master.pingWorker(data, (response) => {
            resolve(response);
        });
    });
}

describe('Workers', () => {
    it('Startup time', async () => {
        await startWorker();
        await master.kill();
    });

    it('Message time', async () => {
        await startWorker();
        for (let i = 0; i < 1000; i++) {
            await sendMessage(testdata);
        }
        await master.kill();
    });

    it('Ping worker + shared memory time', async () => {
        await startWorker();
        for (let i = 0; i < 1000; i++) {
            await pingWorker(testdata);
        }
        await master.kill();
    });
});