Production Case Study: How V8 Optimizes JS Arrays (SMI, Double & Holey Elements)

Inside V8's Elements Kinds Lattice: SMI, Double & Tagged Pointers

To execute array loops at near-native C++ speeds while preserving full ECMAScript semantics, V8 classifies the backing store of every JSArray along two orthogonal dimensions:

1. Payload Representation (SMI vs DOUBLE vs Generic ELEMENTS):
   • SMI_ELEMENTS (Small Integers): Stores 31-bit signed integers (on 64-bit V8 with pointer compression) directly inside the backing store as immediate tagged words (least significant bit 0), requiring zero heap box allocations.
   • DOUBLE_ELEMENTS (Unboxed IEEE-754 float64): As soon as you push 3.14 or NaN into an SMI array, V8 reallocates the backing store into a contiguous C++ double[] array (8 bytes per element) so TurboFan can emit raw SSE/AVX floating-point instructions without pointer dereferencing.
   • ELEMENTS (Tagged Object Pointers): Pushing a string, object, or function forces V8 to box all numbers and store an array of tagged heap pointers—reintroducing pointer chasing!
2. Density Invariant (PACKED vs HOLEY):
   • PACKED_*: Guarantees that every index $i \in [0, \text{length} - 1]$ contains an initialized value. Reading a[i] requires only a single bounds check i < a.length and a direct memory load.
   • HOLEY_*: Created when you allocate new Array(1000), write past the end a[10] = 1, or execute delete a[2]. Uninitialized slots contain a special sentinel (the_hole). Because JavaScript mandates that reading a missing property must walk up Array.prototype and Object.prototype, reading the_hole in a HOLEY array forces V8 to check prototype guards or bail out of JIT fast paths!

Visualizing V8 Backing Store Layouts & The Irreversible Lattice

The SVG diagram below traces the exact transition lattice and shows why PACKED_DOUBLE_ELEMENTS stores raw 64-bit IEEE-754 floats inline whereas HOLEY_ELEMENTS scatters boxed HeapNumber objects across the V8 heap.

Writing V8-Friendly High-Performance JavaScript & TypedArrays

The JavaScript patterns below demonstrate how to preserve PACKED elements kinds and when to bypass V8's lattice entirely using Float64Array / Int32Array.

// V8 Performance Engineering: Avoiding Irreversible Lattice Degradations

// 1. ANTI-PATTERN: Pre-allocating with new Array(N) permanently brands the array
// as HOLEY_SMI_ELEMENTS, even after you fill every single slot!
function sumHoleyAntiPattern(n) {
  const arr = new Array(n); // Immediate transition to HOLEY_SMI_ELEMENTS!
  for (let i = 0; i < n; i++) arr[i] = i;
  let sum = 0;
  for (let i = 0; i < arr.length; i++) sum += arr[i];
  return sum;
}

// 2. PRODUCTION PATTERN A: Start with [] (PACKED_SMI_ELEMENTS) and push sequentially,
// OR for fixed-size numeric buffers, use TypedArrays (Int32Array / Float64Array)
// which CANNOT become holey and CANNOT box elements!
function sumPackedOrTyped(n) {
  const vec = new Int32Array(n); // Guaranteed contiguous unboxed 32-bit ints (16 per cache line)
  for (let i = 0; i < n; i++) vec[i] = i;
  let sum = 0;
  for (let i = 0; i < vec.length; i++) sum += vec[i];
  return sum;
}

// 3. ANTI-PATTERN: Storing -0 or NaN or undefined in an integer counter array
// Note: In V8, -0 cannot be represented as an SMI (because 0 is already an SMI),
// so arr.push(-0) silently transitions PACKED_SMI_ELEMENTS -> PACKED_DOUBLE_ELEMENTS!