Benchmark

event-emitter.js

const { EventEmitter } = require('events');
const { performance } = require('perf_hooks')

const CHANNELS = [
  'connecting',
  'connected',
  'disconnected',
  'reconnecting',
  'closing',
  'closed',
  'error',
  'trade',
  'ticker',
  'candle',
  'l2update',
  'l2snapshot',
];

class AbstractEmitter extends EventEmitter {
  static relay(source, dest, channels = CHANNELS) {
    for (const channel of channels) {
      source.on(channel, (...args) => dest.emit(channel, ...args));
    }
  }
}

function generateEventEmmiters(hierarchy) {
  let source, first;
  if (hierarchy > 0) {
    ({source, first} = generateEventEmmiters(hierarchy - 1));
  }

  const dst = new (class extends AbstractEmitter {})
  if (source) {
    AbstractEmitter.relay(source, dst);
  }
  return { source: dst, first: first || dst };
}

function measurementStats(arr) {
  const result = arr.reduce((memo, n) => {
    return {
      max: Math.max(memo.max, n),
      min: Math.min(memo.min, n),
      sum: memo.sum + n,
    }
  }, {
    max: -Infinity,
    min: Infinity,
    sum: 0,
  });
  result.avg = result.sum / arr.length;
  delete result.sum;
  return result;
}

function future() {
  let resolve, reject, promise = new Promise((_resolve, _reject) => {
    resolve = _resolve;
    reject = _reject;
  });
  return {
    resolve,
    reject,
    promise,
  };
}


const { source: sourceSingle, first: firstSingle } = generateEventEmmiters(0);
const { source: sourceThree, first: firstThree} = generateEventEmmiters(3);
const { source: sourceFive, first: firstFive }  = generateEventEmmiters(5);

const firstFacade = new AbstractEmitter();

const channels = [
  ['single', sourceSingle, firstSingle],
  ['three', sourceThree, firstThree],
  ['five', sourceFive, firstFive],
];

const ITERATIONS = 1e6;

async function main() {
  for (const [key, src, first] of channels) {
    const iterationTimes = [];
    for (let i = 0; i < ITERATIONS; i++) {
      const f = future();
      const start = performance.now();
      src.once('trade', () => {
        iterationTimes.push(performance.now(start))
        f.resolve();
      });
      src.emit('trade', { ok: true });
      await f.promise;
    }

    const results = measurementStats(iterationTimes);

    console.log(key, results);
  }
}

main();

result.md

Results:

single {
  max: 731.1573449969292,
  min: 44.102203994989395,
  avg: 397.87253509664504
}
three {
  max: 1481.1004790067673,
  min: 761.2753449976444,
  avg: 1133.2061397619066
}
five {
  max: 2163.3564960062504,
  min: 1506.5321449935436,
  avg: 1846.5781688581696
}