multiple threads vs fork process in NodeJS

[NeoyeElf]

• Node.js Version: v10.15.3
• OS: MacOS(2.2 GHz Intel Core i7, 16 GB 1600 MHz DDR3)

I have some questions about the "multiple threads vs fork process in NodeJS".
The full question is at the stackoverflow as well as the code

can anyone give me some ideas? Thks

[ORESoftware]

Just use:

const cp = require('child_process');
const k = cp.spawn('bash');
k.stdin.end(` your command here `);
k.stdout.pipe(process.stdout);
k.stderr.pipe(process.stderr);

[NeoyeElf]

@ORESoftware thks, but you didn't answer the questions in the stackoverflow

[gireeshpunathil]

@NeoyeElf - is this still outstanding?

[NeoyeElf]

@gireeshpunathil yes

[gireeshpunathil]

1. Why is the fork process method faster?
2. Are the worker threads useless? Or what are the worker threads advantages, consumes less cpu/memory?

Here is my take on this:

there is no single formulae that computes which method will be faster. It depends on a number of parameters:

• the running time of the job itself
• the interaction of the job with the spawning code
• the machine characteristics, specifically cpu, memory and scheduling

the fork uses native fork and exec, that is heavy-weight than thread creation.
fork creates a new node instance with new v8, isolate, libuv etc. worker does not create new node instance.
forked process uses IPC channel to talk to the forking process, if needed. workers use in-memory buffers.

So:

• if the execution time of the microjob is too small compared to the process creation, worker method will be faster.
• if the job communicates with the driver, the frequency of communication and the cost of communication will decide the winner
• if the job runs as long independent piece of code with no interaction, fork method will eventually prove faster (I think that is happening here)

cc @addaleax to get more expert opinion.

[NeoyeElf]

@gireeshpunathil learned a lot from your comment, Thks.

[NeoyeElf]

if the execution time of the microjob is too small compared to the process creation, worker method will be faster.

@gireeshpunathil would you mind give some example code? I have reduce the job time in my code like
let res = 0 for (i = 0; i < 100; i++) { res += 1 }
but still the "fork process" won.

[gireeshpunathil]

here it is:

#cat 1920w.js

const { Worker } = require('worker_threads');
const start = process.hrtime()
const worker = new Worker( 'let res = 0; for (i = 0; i < 100; i++) { res += 1 }', { eval: true });
worker.on('exit', () => {
  const diff = process.hrtime(start)
  console.log(diff[0] * 1e9 + diff[1])
})

#cat 1920f.js

if (process.argv[2] === 'child') {
  let res = 0; for (i = 0; i < 100; i++) { res += 1 };
  process.exit();
} else {
  const child_process = require('child_process')
  const start = process.hrtime()
  const cp  = child_process.spawn(process.execPath, [__filename, 'child'])
  cp.on('exit', () => {
    const diff = process.hrtime(start)
    console.log(diff[0] * 1e9 + diff[1])
})
}

#node 1920w
35503006
#node 1920f
67765890

[NeoyeElf]

I see. below is my code:

workform.js

const workerFarm = require('worker-farm');
const workers = workerFarm(
  {
    maxConcurrentWorkers: 1,
    maxConcurrentCallsPerWorker: 1,
  },
  require.resolve('./workers.js'),
  [
    'heavyJob',
  ]
);

async function main() {
  return new Promise((resolve, reject) => {
    workers.heavyJob(0, (err, out) => {
      if (err) {
        return reject(err);
      }

      resolve(out);
    });
  });
}

module.exports = main

workers.js

exports.heavyJob = wrap(function() {
  let res = 0
  for (i = 0; i < 100; i++) {
    res += 1
  }

  return res
})

function wrap (fn) {
  return function (arg, callback) {
    try {
      const ret = fn(arg)
      callback(null, ret)
    } catch (e) {
      callback(e)
    }
  }
}

worker-threads.js

const { Worker } = require('worker_threads')

function main() {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker-code.js', { workerData: null });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0)
        reject(new Error(`Worker stopped with exit code ${code}`));
    })
  })
}

module.exports = main

worker-code.js

const { parentPort } = require('worker_threads');

let res = 0
for (i = 0; i < 100; i++) {
  res += 1
}

parentPort.postMessage({ res });

test.js

const doProcessJob = require('./workform')
const workerThreads = require('./worker-threads')

async function main() {
  let start = Date.now()
  const times = 100
  
  for (let index = 0; index < times; index++) {
    await doProcessJob()
  }
  console.log('fork process cost time:', Date.now() - start)
  
  start = Date.now()
  for (let index = 0; index < times; index++) {
    await workerThreads()
  }
  console.log('worker threads cost time:', Date.now() - start)
}

main().catch(console.error)

output:

fork process cost time: 111
worker threads cost time: 5891

why my output shows "fork process" is faster? @gireeshpunathil Can you give me some ideas? Thanks a lot！

[addaleax]

@NeoyeElf The worker-farm module maintains a pool of child processes for the jobs, while your worker code creates a new Worker instance for each job – that’s two very different things (and the reason why the Worker documentation recommends using a worker pool for these things). You could try using e.g. https://www.npmjs.com/package/microjob, or another package which supports Worker pooling.

[NeoyeElf]

After I used microjob, the output is as expected (using the above test.js instead of benchmark.js), the "worker threads" won, nearly 2 times faster than "fork process".

but the output for the benchmark.js is

worker threads x 394 ops/sec ±176.63% (32 runs sampled)
fork process x 427 ops/sec ±132.45% (78 runs sampled)
Fastest is fork process

maybe the lib "benchmark" did some trick?

any way, @gireeshpunathil @addaleax Thks again !