Skip to content

v26: computed property lookups with concatenated keys that miss keep every key alive (unbounded heap growth) #67505

Open

Description

@dogfootruler-kr

Version

v26.13.1 (V8 14.6.202.34-node.40). Also reproduced on v26.5.0. Also observed on Linux with v26.10.0.

Platform

Darwin arm64 (macOS); also Linux

Subsystem

V8

What steps will reproduce the bug?

A computed property load on a plain object, where the key is a freshly concatenated string and the property is absent, keeps every such key reachable for the life of the process. Heap grows without bound.

// node --expose-gc repro.mjs [concat|plain|hasOwn]
const table = {};
for (let i = 0; i < 300; i++) table[`key-${i}`] = i;

const lookups = {
  concat: (s) => table[s + ".x"],                // grows without bound on Node 26
  plain: (s) => table[s],                        // stable
  hasOwn: (s) => Object.hasOwn(table, s + ".x"), // stable
};
const lookup = lookups[process.argv[2] ?? "concat"];

const heapMB = () => {
  globalThis.gc();
  return Math.round(process.memoryUsage().heapUsed / 1048576);
};

console.log(process.version, process.argv[2] ?? "concat", "start", heapMB(), "MB");
for (let round = 1; round <= 8; round++) {
  for (let i = 0; i < 400_000; i++) lookup(`some/unique/string-${Math.random()}-${i}`);
  console.log("after", round * 400_000, "misses:", heapMB(), "MB");
}

How often does it reproduce? Is there a required condition?

Every time on v26.x. The key has to come from a concatenation (s + ".x") and miss on the object. With a pre-existing string key (table[s]), Object.hasOwn, in or Map#has, the heap stays flat.

What is the expected behavior? Why is that the expected behavior?

Heap after gc() stays flat. That is what v20.20.2, v22.22.3, v24.15.0 and v24.18.0 (V8 13.6) do with the same script:

v24.18.0 concat start 3 MB
after 3200000 misses: 3 MB

What do you see instead?

v26.13.1 concat start 4 MB
after 400000 misses: 69 MB
after 800000 misses: 133 MB
after 1200000 misses: 182 MB
after 1600000 misses: 263 MB
after 2000000 misses: 312 MB
after 2400000 misses: 361 MB
after 2800000 misses: 474 MB
after 3200000 misses: 523 MB

plain and hasOwn stay at 3–4 MB on v26.13.1.

Additional information

In a heap snapshot, the retained key strings hang off large arrays (about 8 MB each, one per lookup site) that are referenced from the lookup function's FeedbackVector / FeedbackCell. So the keyed-load feedback seems to keep its keys strongly.

This shows up in practice in long-running HTTP servers. For example, a static-file check like assets[path + '.gz'] || assets[path + '.br'] running on every request turns every distinct request URL into permanent heap. We saw about 13 MB/h of growth, and processes got OOM-killed after a couple of days. Our workaround was to switch those lookups to Object.hasOwn.

Activity

  1. Renegade334 commented on Nov 18, 2026

    @Renegade334
    Member

    Looks to be a V8 caching issue. For now, replacing s1 + s2 with a template string literal does suppress it.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions