How do you scale WebSockets to 1M connections with Redis Pub/Sub?

// 1M WebSocket connections behind 25 gateway nodes, with Redis Pub/Sub simulated in-process.
// Counts what Redis must send to gateways under two subscription designs, computes the
// Redis Cluster hash slot of channel names, and replays a slow-subscriber buffer limit.
let seed = 42;
const rand = (n) => { seed = (seed * 48271) % 2147483647; return seed % n; }; // MINSTD, fixed seed

const CONNS = 1000000, NODES = 25, MESSAGES = 5000;
console.log("Part 1: capacity (assumptions: 30 KB per connection, 25% headroom)");
const perNode = CONNS / NODES;
console.log("  " + NODES + " nodes x " + perNode + " connections = " + CONNS + "; at 80% fill each node can take " + (perNode / 0.8));
console.log("  memory per node: " + perNode + " x 30 KB = " + (perNode * 30 / 1000000).toFixed(1) + " GB");

function scenario(name, rooms) {
  const roomOf = new Int32Array(CONNS);
  const size = new Int32Array(rooms);
  const nodesMask = new Int32Array(rooms); // bit i set = node i has a member of this room
  for (let c = 0; c < CONNS; c++) {
    const node = rand(NODES), room = rand(rooms);
    roomOf[c] = room; size[room]++; nodesMask[room] |= 1 << node;
  }
  let globalSends = 0, perRoomSends = 0, sockets = 0, wasted = 0;
  for (let m = 0; m < MESSAGES; m++) {
    const room = rand(rooms);
    let nodes = 0;
    for (let i = 0; i < NODES; i++) if (nodesMask[room] & (1 << i)) nodes++;
    globalSends += NODES;          // every gateway subscribes to one channel "all"
    perRoomSends += nodes;         // gateways subscribe to "room:<id>" only while they hold a member
    wasted += NODES - nodes;
    sockets += size[room];
  }
  console.log("  " + name + ": " + rooms + " rooms, avg " + CONNS / rooms + " members");
  console.log("    one global channel: " + globalSends + " Redis->gateway sends, " + wasted + " of them to gateways with nobody to tell");
  console.log("    channel per room:   " + perRoomSends + " Redis->gateway sends (" + Math.round(100 * perRoomSends / globalSends) + "% of global)");
  console.log("    socket writes by gateways: " + sockets);
}
console.log("\nPart 2: " + MESSAGES + " messages to random rooms");
scenario("small rooms", 250000);
scenario("big rooms", 1000);

function crc16(s) { // CRC16-XMODEM, the function Redis Cluster uses for key slots
  let crc = 0;
  for (let i = 0; i < s.length; i++) {
    crc ^= s.charCodeAt(i) << 8;
    for (let b = 0; b < 8; b++) crc = crc & 0x8000 ? ((crc << 1) ^ 0x1021) & 0xffff : (crc << 1) & 0xffff;
  }
  return crc;
}
function slot(key) { // only the part inside the first {...} is hashed, if it is non-empty
  const open = key.indexOf("{");
  if (open >= 0) { const close = key.indexOf("}", open + 1); if (close > open + 1) key = key.slice(open + 1, close); }
  return crc16(key) % 16384;
}
console.log("\nPart 3: sharded Pub/Sub routes a channel by hash slot (3 shards, even split)");
console.log("  crc16(\"123456789\") = 0x" + crc16("123456789").toString(16).toUpperCase());
const shardOf = (s) => (s < 5461 ? "shard-1" : s < 10923 ? "shard-2" : "shard-3");
for (const ch of ["room:41", "room:42", "room:43", "{room:42}:typing", "{room:42}:presence"]) {
  const s = slot(ch);
  console.log("  " + ch.padEnd(20) + " slot " + String(s).padStart(5) + " -> " + shardOf(s));
}

console.log("\nPart 4: a gateway reads 800 msg/s while 1000 msg/s of 1 KB arrive");
const SOFT = 8 * 1024 * 1024, HARD = 32 * 1024 * 1024, SOFT_SECONDS = 60;
let buf = 0, overSince = -1;
for (let t = 1; t <= 300; t++) {
  buf += (1000 - 800) * 1024;
  if (buf > SOFT && overSince < 0) { overSince = t; console.log("  t=" + t + "s buffer " + (buf / 1048576).toFixed(2) + " MB passes the 8 MB soft limit"); }
  if (buf > HARD || (overSince >= 0 && t - overSince >= SOFT_SECONDS)) {
    console.log("  t=" + t + "s buffer " + (buf / 1048576).toFixed(2) + " MB: Redis closes the subscriber; " + (t * 1000 - t * 800) + " messages were still unread");
    break;
  }
}