Performance all 4 written

server.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import { createServer } from "node:http";

// About half a second of pure computation.
function buildReport() {
  let total = 0;
  for (let i = 0; i < 300_000_000; i++) total += i % 7;
  return total;
}

const server = createServer((req, res) => {
  if (req.url === "/report") return res.end(`report total: ${buildReport()}`);
  res.end("ok");
});

server.listen(0, "127.0.0.1", () => {
  console.log(`http://127.0.0.1:${server.address().port}`);
});

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import { spawn } from "node:child_process";
import { createInterface } from "node:readline";
import { once } from "node:events";
import { setTimeout as sleep } from "node:timers/promises";

// The server runs as its own process, so this one stays free to measure.
const server = spawn(process.execPath, ["server.mjs"], { stdio: ["ignore", "pipe", "inherit"] });
const [base] = await once(createInterface({ input: server.stdout }), "line");

async function timed(path) {
  const started = performance.now();
  await (await fetch(base + path)).text();
  return performance.now() - started;
}

await timed("/health");                               // warm up the connection
const alone = await timed("/health");

const report = timed("/report");                      // start the slow one...
await sleep(50);
const during = await timed("/health");                // ...and ask for health 50 ms in
const reportMs = await report;

console.log(`/health on its own:          ${alone.toFixed(1)} ms`);
console.log(`/report:                     ${reportMs.toFixed(0)} ms`);
console.log(`/health while /report runs:  ${during.toFixed(0)} ms`);
server.kill();

check("health is quick on its own", alone < 50, true);
check("but waited for the report to finish", during > 200, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38import { scrypt, scryptSync } from "node:crypto";
import { promisify } from "node:util";

const scryptAsync = promisify(scrypt);
const cost = { N: 2 ** 15, r: 8, p: 1, maxmem: 64 * 1024 * 1024 };   // about 90 ms per hash

// A ticker standing in for "everything else the server should be doing".
let ticks = 0;
const ticker = setInterval(() => ticks++, 5);

let started = performance.now();
ticks = 0;
for (let i = 0; i < 4; i++) scryptSync(`password ${i}`, "salt", 64, cost);
const syncMs = performance.now() - started;
const syncTicks = ticks;

await new Promise((resolve) => setTimeout(resolve, 20));
started = performance.now();
ticks = 0;
await Promise.all([0, 1, 2, 3].map((i) => scryptAsync(`password ${i}`, "salt", 64, cost)));
const asyncMs = performance.now() - started;
const asyncTicks = ticks;

console.log(`4 × scryptSync: ${syncMs.toFixed(0)} ms, and the ticker ran ${syncTicks} times`);
console.log(`4 × scrypt:     ${asyncMs.toFixed(0)} ms, and the ticker ran ${asyncTicks} times`);

// Eight at once: when does each one finish?
started = performance.now();
const finished = await Promise.all(Array.from({ length: 8 }, (_, i) =>
  scryptAsync(`password ${i}`, "salt", 64, cost).then(() => Math.round(performance.now() - started))));
clearInterval(ticker);
finished.sort((a, b) => a - b);
console.log("8 × scrypt, finish times in ms:", finished.join(", "));

const gaps = finished.slice(1).map((t, i) => t - finished[i]);
check("the sync calls froze everything else", syncTicks, 0);
check("the async ones ran in parallel while the ticker kept going", [asyncMs < syncMs, asyncTicks > 5], [true, true]);
check("eight hashes finished as two groups of four", gaps.indexOf(Math.max(...gaps)), 3);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21// A pattern for "one or more groups of a's". It looks harmless.
const pattern = /^(a+)+$/;
pattern.test("aaaa!");        // one short run first: V8 compiles a pattern after its first use

const timings = {};
for (const length of [18, 20, 22, 24, 26]) {
  const input = "a".repeat(length) + "!";          // almost matches, then does not
  const started = performance.now();
  pattern.test(input);
  timings[length] = performance.now() - started;
  console.log(`${length} characters: ${timings[length].toFixed(1)} ms`);
}

const simpler = /^a+$/;                            // means exactly the same thing
const started = performance.now();
simpler.test("a".repeat(26) + "!");
const simplerMs = performance.now() - started;
console.log(`the simpler pattern, 26 characters: ${simplerMs.toFixed(2)} ms`);

check("four more characters took several times as long", timings[26] > 4 * timings[22], true);
check("the simpler pattern answered at once", simplerMs < 5, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46import { setImmediate as yieldToLoop } from "node:timers/promises";

// The longest time the loop went without running a 10 ms timer.
let last = performance.now();
let worstGap = 0;
const ticker = setInterval(() => {
  const now = performance.now();
  worstGap = Math.max(worstGap, now - last);
  last = now;
}, 10);

function score(i) {                           // a little work per item
  let x = 0;
  for (let j = 0; j < 400; j++) x += Math.sqrt(i * j);
  return x;
}
const ITEMS = 1_000_000;

async function measure(label, job) {
  await new Promise((resolve) => setTimeout(resolve, 30));
  worstGap = 0;
  last = performance.now();
  const started = performance.now();
  await job();
  const took = performance.now() - started;
  await new Promise((resolve) => setTimeout(resolve, 30));
  console.log(`${label}: took ${took.toFixed(0)} ms; longest gap between ticks ${worstGap.toFixed(0)} ms`);
  return { took, worstGap };
}

const inOneGo = await measure("in one go       ", async () => {
  let total = 0;
  for (let i = 0; i < ITEMS; i++) total += score(i);
});

const inChunks = await measure("in 10,000s      ", async () => {
  let total = 0;
  for (let i = 0; i < ITEMS; i++) {
    total += score(i);
    if (i % 10_000 === 0) await yieldToLoop();     // let everything else have a turn
  }
});
clearInterval(ticker);

check("in one go, nothing else ran for hundreds of milliseconds", inOneGo.worstGap > 200, true);
check("in chunks, the ticker was never held up for long", inChunks.worstGap < 100, true);

fib.mjs

1
2
3
4
5
6
7
8import { parentPort, workerData } from "node:worker_threads";

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

// workerData is the value the parent passed in; postMessage sends the answer back.
parentPort.postMessage(fib(workerData));

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import { Worker } from "node:worker_threads";

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

let ticks = 0;
const ticker = setInterval(() => ticks++, 10);
const pause = () => new Promise((resolve) => setTimeout(resolve, 30));

// 1. On the main thread.
await pause();
ticks = 0;
let started = performance.now();
const here = fib(38);
const hereMs = performance.now() - started;
const hereTicks = ticks;

// 2. In a worker.
await pause();
ticks = 0;
started = performance.now();
const there = await new Promise((resolve, reject) => {
  const worker = new Worker(new URL("./fib.mjs", import.meta.url), { workerData: 38 });
  worker.once("message", resolve);
  worker.once("error", reject);
});
const thereMs = performance.now() - started;
const thereTicks = ticks;
clearInterval(ticker);

console.log(`main thread: fib(38) = ${here} in ${hereMs.toFixed(0)} ms; the ticker ran ${hereTicks} times`);
console.log(`worker:      fib(38) = ${there} in ${thereMs.toFixed(0)} ms; the ticker ran ${thereTicks} times`);

check("the same answer either way", there, here);
check("on the main thread, nothing else ran", hereTicks, 0);
check("with a worker, the main thread stayed free", thereTicks > 10, true);

fib.mjs

1
2
3
4
5
6
7
8import { parentPort, workerData } from "node:worker_threads";

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

// workerData is the value the parent passed in; postMessage sends the answer back.
parentPort.postMessage(fib(workerData));

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import { Worker } from "node:worker_threads";
import { availableParallelism } from "node:os";

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}
const jobs = Array.from({ length: 8 }, () => 35);
const cores = availableParallelism();

let started = performance.now();
const oneByOne = jobs.map((n) => fib(n));
const oneByOneMs = performance.now() - started;

started = performance.now();
const inParallel = await Promise.all(jobs.map((n) => new Promise((resolve, reject) => {
  const worker = new Worker(new URL("./fib.mjs", import.meta.url), { workerData: n });
  worker.once("message", resolve);
  worker.once("error", reject);
})));
const parallelMs = performance.now() - started;
const speedup = oneByOneMs / parallelMs;

console.log(`this machine has ${cores} cores`);
console.log(`8 jobs, one after another: ${oneByOneMs.toFixed(0)} ms`);
console.log(`8 jobs, 8 workers:         ${parallelMs.toFixed(0)} ms  (${speedup.toFixed(1)} times as fast)`);

check("the same answers", inParallel, oneByOne);
check("several times faster, in proportion to the cores available", speedup > Math.min(cores, 8) / 3, true);

fib-service.mjs

1
2
3
4
5
6
7
8import { parentPort } from "node:worker_threads";

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

// Stays alive, answering one message after another.
parentPort.on("message", (n) => parentPort.postMessage(fib(n)));

pool.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import { Worker } from "node:worker_threads";

// A fixed set of workers, and a queue of jobs waiting for a free one.
export class WorkerPool {
  #idle = [];
  #queue = [];

  constructor(file, size) {
    for (let i = 0; i < size; i++) this.#idle.push(new Worker(file));
  }

  run(data) {
    return new Promise((resolve, reject) => {
      this.#queue.push({ data, resolve, reject });
      this.#next();
    });
  }

  #next() {
    if (this.#idle.length === 0 || this.#queue.length === 0) return;
    const worker = this.#idle.pop();
    const { data, resolve, reject } = this.#queue.shift();
    const done = (result, error) => {
      worker.off("message", onMessage);
      worker.off("error", onError);
      if (error) return reject(error);           // a crashed worker is not put back
      this.#idle.push(worker);
      resolve(result);
      this.#next();
    };
    const onMessage = (result) => done(result);
    const onError = (error) => done(undefined, error);
    worker.on("message", onMessage);
    worker.on("error", onError);
    worker.postMessage(data);
  }

  close() {
    return Promise.all(this.#idle.map((worker) => worker.terminate()));
  }
}

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import { Worker } from "node:worker_threads";
import { WorkerPool } from "./pool.mjs";

const file = new URL("./fib-service.mjs", import.meta.url);
const tasks = Array.from({ length: 40 }, () => 27);        // forty small jobs, a few ms each

// A fresh worker for every task.
let started = performance.now();
const fresh = await Promise.all(tasks.map((n) => new Promise((resolve, reject) => {
  const worker = new Worker(file);
  worker.once("message", (result) => { resolve(result); worker.terminate(); });
  worker.once("error", reject);
  worker.postMessage(n);
})));
const freshMs = performance.now() - started;

// Four workers, started once and reused.
started = performance.now();
const pool = new WorkerPool(file, 4);
const pooled = await Promise.all(tasks.map((n) => pool.run(n)));
const pooledMs = performance.now() - started;
await pool.close();

console.log(`40 tasks, a new worker each: ${freshMs.toFixed(0)} ms`);
console.log(`40 tasks, a pool of 4:       ${pooledMs.toFixed(0)} ms`);

check("the same answers", pooled, fresh);
check("the pool was faster, with a tenth of the workers", pooledMs < freshMs, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import { Worker } from "node:worker_threads";
import { once } from "node:events";

// A worker that reports the size of whatever it receives.
const worker = new Worker(`
  const { parentPort } = require("node:worker_threads");
  parentPort.on("message", (buffer) => parentPort.postMessage(buffer.byteLength));
`, { eval: true });
await once(worker, "online");

const data = new ArrayBuffer(200 * 1024 * 1024);          // 200 MB

let started = performance.now();
worker.postMessage(data);                                 // copied
const [copiedSize] = await once(worker, "message");
const copyMs = performance.now() - started;
console.log(`copied:      ${copyMs.toFixed(0)} ms; the worker got ${copiedSize / 1024 / 1024} MB; ours is still ${data.byteLength / 1024 / 1024} MB`);

started = performance.now();
worker.postMessage(data, [data]);                         // transferred
const [movedSize] = await once(worker, "message");
const transferMs = performance.now() - started;
console.log(`transferred: ${transferMs.toFixed(1)} ms; the worker got ${movedSize / 1024 / 1024} MB; ours is now ${data.byteLength} bytes`);
await worker.terminate();

check("transferring was more than ten times faster", copyMs > 10 * transferMs, true);
check("and left the sender with nothing", data.byteLength, 0);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import { Worker } from "node:worker_threads";
import { once } from "node:events";

// Each worker adds 1 to the same counter, a million times.
const code = `
  const { workerData } = require("node:worker_threads");
  const counter = new Int32Array(workerData.shared);
  for (let i = 0; i < 1_000_000; i++) {
    if (workerData.atomic) Atomics.add(counter, 0, 1);
    else counter[0]++;
  }
`;

async function count(atomic) {
  const shared = new SharedArrayBuffer(4);             // one 32-bit integer, seen by every thread
  const workers = Array.from({ length: 4 }, () =>
    new Worker(code, { eval: true, workerData: { shared, atomic } }));
  await Promise.all(workers.map((worker) => once(worker, "exit")));
  return new Int32Array(shared)[0];
}

const plain = await count(false);
const atomic = await count(true);
console.log(`4 workers × 1,000,000 with counter[0]++:    ${plain.toLocaleString("en")}`);
console.log(`4 workers × 1,000,000 with Atomics.add:     ${atomic.toLocaleString("en")}`);

check("plain ++ lost updates", plain < 4_000_000, true);
check("Atomics.add lost none", atomic, 4_000_000);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import { Worker } from "node:worker_threads";

const worker = new Worker(`throw new TypeError("the worker's own bug");`, { eval: true });

const seen = [];
worker.on("error", (err) => {
  seen.push(err.name);
  console.log("the parent got an error event:", err.name + ":", err.message);
});
worker.on("exit", (code) => {
  seen.push(code);
  console.log("the worker exited with code", code);
  console.log("and the parent is still running");
  check("an exception in a worker arrives as an error event, then exit 1", seen, ["TypeError", 1]);
});

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21function slugify(title) {
  return title.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "")
    .replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
}
const titles = Array.from({ length: 2000 }, (_, i) => `Café Menu, Item #${i}: Crème Brûlée & Friends`);

// The same work, twenty times.
const runs = [];
for (let run = 0; run < 20; run++) {
  const started = performance.now();
  for (const title of titles) slugify(title);
  runs.push(performance.now() - started);
}

const sorted = [...runs].sort((a, b) => a - b);
const median = sorted[Math.floor(sorted.length / 2)];
console.log("every run, in ms:", runs.map((ms) => ms.toFixed(1)).join(" "));
console.log(`first run ${runs[0].toFixed(1)} ms, median ${median.toFixed(1)} ms, fastest ${sorted[0].toFixed(1)} ms`);
console.log("one slug:", slugify(titles[0]));

check("the first run was noticeably slower than a typical one", runs[0] > 1.3 * median, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26function uniqueWithIncludes(items) {
  const seen = [];
  for (const item of items) if (!seen.includes(item)) seen.push(item);
  return seen;
}

function uniqueWithSet(items) {
  return [...new Set(items)];
}

const results = {};
for (const size of [2500, 5000, 10000]) {
  const items = Array.from({ length: size }, (_, i) => `visitor-${i}`);
  let started = performance.now();
  const a = uniqueWithIncludes(items);
  const includesMs = performance.now() - started;
  started = performance.now();
  const b = uniqueWithSet(items);
  const setMs = performance.now() - started;
  results[size] = { includesMs, setMs, same: a.length === b.length };
  console.log(`${String(size).padStart(5)} visitors: includes ${includesMs.toFixed(1).padStart(6)} ms, Set ${setMs.toFixed(2).padStart(5)} ms`);
}

check("both give the same answer", Object.values(results).every((r) => r.same), true);
check("doubling the input made includes about four times slower", results[10000].includesMs > 2.5 * results[5000].includesMs, true);
check("the Set was over twenty times faster at 10,000", results[10000].setMs * 20 < results[10000].includesMs, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import { createHistogram } from "node:perf_hooks";

let cache = null;
function handle(request) {
  if (request % 50 === 0) cache = null;                  // the cache expires now and then
  if (cache === null) {
    const rows = Array.from({ length: 200_000 }, (_, i) => (i * 7919) % 100_003);
    cache = rows.sort((a, b) => a - b);                  // the slow path: rebuild it
  }
  return cache[request % cache.length];
}

const histogram = createHistogram();                     // records whole numbers
for (let request = 0; request < 2500; request++) {
  const started = performance.now();
  handle(request);
  histogram.record(Math.max(1, Math.round((performance.now() - started) * 1000)));   // microseconds
}

const ms = (microseconds) => `${(microseconds / 1000).toFixed(2)} ms`;
console.log("requests:", histogram.count);
console.log("mean:    ", ms(histogram.mean));
console.log("median:  ", ms(histogram.percentile(50)));
console.log("p99:     ", ms(histogram.percentile(99)));
console.log("slowest: ", ms(histogram.max));

check("the median request was faster than the mean", histogram.percentile(50) < histogram.mean, true);
check("and the slowest one in a hundred took far longer than either", histogram.percentile(99) > 10 * histogram.mean, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
function snapshot(label) {
  gc();                                          // collect garbage first, so we measure what is live
  const m = process.memoryUsage();
  console.log(`${label.padEnd(24)} rss ${mb(m.rss).padStart(9)}  heapUsed ${mb(m.heapUsed).padStart(8)}  arrayBuffers ${mb(m.arrayBuffers).padStart(8)}`);
  return m;
}

const start = snapshot("at start");
const buffer = Buffer.alloc(100 * 1024 * 1024, 1);                    // 100 MB of bytes, all set to 1
const afterBuffer = snapshot("after a 100 MB Buffer");
const objects = Array.from({ length: 1_000_000 }, (_, i) => ({ i }));  // a million small objects
const afterObjects = snapshot("after 1,000,000 objects");

check("the Buffer lives outside the JavaScript heap",
      [afterBuffer.heapUsed - start.heapUsed < 5 * 1024 * 1024, afterBuffer.arrayBuffers - start.arrayBuffers > 99 * 1024 * 1024],
      [true, true]);
check("the objects live inside it", afterObjects.heapUsed - afterBuffer.heapUsed > 20 * 1024 * 1024, true);
check("both are still in use", [buffer.length, objects.length], [104857600, 1000000]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48const mb = (bytes) => (bytes / 1024 / 1024).toFixed(1);
const heap = () => { gc(); return process.memoryUsage().heapUsed; };

// A search endpoint remembers its results, to answer repeat searches instantly.
const cache = new Map();
function searchCached(query) {
  if (!cache.has(query)) cache.set(query, { query, results: "r".repeat(1000) + query });
  return cache.get(query);
}

// The same idea, holding at most 1,000 results: least recently used goes first.
class LruCache {
  #map = new Map();
  constructor(max) { this.max = max; }
  get(key) {
    if (!this.#map.has(key)) return undefined;
    const value = this.#map.get(key);
    this.#map.delete(key);                         // re-insert: a Map keeps insertion order,
    this.#map.set(key, value);                     // so the oldest entry is always first
    return value;
  }
  set(key, value) {
    this.#map.delete(key);
    this.#map.set(key, value);
    if (this.#map.size > this.max) this.#map.delete(this.#map.keys().next().value);
  }
}
const lru = new LruCache(1000);
function searchLru(query) {
  let hit = lru.get(query);
  if (!hit) lru.set(query, (hit = { query, results: "r".repeat(1000) + query }));
  return hit;
}

const growth = {};
for (const [name, search] of [["unbounded Map", searchCached], ["LRU of 1,000", searchLru]]) {
  const base = heap();
  growth[name] = [];
  for (let i = 1; i <= 40_000; i++) {
    search(`query ${i}`);                        // every search is different, as real ones are
    if (i % 10_000 === 0) growth[name].push(heap() - base);
  }
  console.log(`${name.padEnd(14)} growth after 10k, 20k, 30k, 40k searches: ${growth[name].map((b) => mb(b) + " MB").join(", ")}`);
}

const [first, , , last] = growth["unbounded Map"];
check("the unbounded cache grew with every new search", last > 3 * first, true);
check("the LRU stopped growing once it was full", growth["LRU of 1,000"][3] - growth["LRU of 1,000"][0] < 1024 * 1024, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const mb = (bytes) => (bytes / 1024 / 1024).toFixed(0);
const heap = () => { gc(); return process.memoryUsage().heapUsed; };

function attach(store) {
  const users = Array.from({ length: 100_000 }, (_, i) => ({ id: i }));
  // Extra data about each user, kept to one side.
  for (const user of users) store.set(user, { history: new Array(20).fill(user.id) });
  return users;
}

const kept = {};
for (const Store of [Map, WeakMap]) {
  const base = heap();
  const store = new Store();
  let users = attach(store);
  const withUsers = heap() - base;
  users = null;                                      // the program is finished with the users
  kept[Store.name] = heap() - base;
  console.log(`${Store.name.padEnd(7)} with the users: ${mb(withUsers)} MB; after dropping them: ${mb(kept[Store.name])} MB`);
  globalThis[Store.name + "Store"] = store;         // the store itself stays alive either way
}

check("the Map kept every user, and its data, alive", kept.Map > 20 * 1024 * 1024, true);
check("the WeakMap let them go", kept.WeakMap < 10 * 1024 * 1024, true);

grow.mjs

1
2
3
4
5
6
7const kept = [];
for (let i = 0; ; i++) {
  kept.push({ id: i, note: "x".repeat(100) + i });       // never let go of anything
  if (i % 50_000 === 0) {
    console.log(`${i.toLocaleString("en")} objects, heap ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)} MB`);
  }
}

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12import { spawnSync } from "node:child_process";

// Run grow.mjs with a deliberately small heap: 64 MB for long-lived objects.
const run = spawnSync(process.execPath, ["--max-old-space-size=64", "grow.mjs"], { encoding: "utf8" });

console.log(run.stdout.trim());
const fatal = run.stderr.split("\n").find((line) => line.startsWith("FATAL ERROR"));
console.log(fatal);
console.log("the process ended with the signal", run.signal);

check("node aborted with 'JavaScript heap out of memory'", fatal.endsWith("JavaScript heap out of memory"), true);
check("killed by SIGABRT, not a normal exit", [run.status, run.signal], [null, "SIGABRT"]);