How V8 Garbage Collector Works in JavaScript

// Conceptual view of V8's heap layout
 
const heapSpaces = {
  newSpace: {
    description: "Young generation: newly allocated objects",
    size: "1-8 MB (configurable)",
    gcAlgorithm: "Scavenge (semi-space copying)",
    frequency: "Very frequent (every few ms under pressure)",
    pauseTime: "Sub-millisecond to ~1ms",
    divided: ["from-space (active)", "to-space (copy target)"],
  },
 
  oldSpace: {
    description: "Old generation: objects promoted from new space",
    gcAlgorithm: "Mark-Sweep-Compact",
    frequency: "Less frequent",
    pauseTime: "10-100ms+ (mitigated by incremental/concurrent)",
  },
 
  largeObjectSpace: {
    description: "Objects larger than a page (~500KB)",
    note: "Never moved, collected by mark-sweep only",
  },
 
  codeSpace: {
    description: "Compiled machine code from JIT (TurboFan/Maglev)",
    note: "Managed separately from data objects",
  },
 
  mapSpace: {
    description: "Hidden classes (Maps/Shapes) used by objects",
    note: "Describes object structure for property access optimization",
  },
};

// Conceptual illustration of V8's scavenge algorithm
 
function scavenge(fromSpace, toSpace) {
  // Step 1: Scan roots for references into from-space
  const worklist = [];
  for (const root of getRoots()) {
    if (isInFromSpace(root.target)) {
      worklist.push(root);
    }
  }
 
  // Step 2: Copy live objects from from-space to to-space
  let toPointer = toSpace.start;
 
  while (worklist.length > 0) {
    const ref = worklist.pop();
    const obj = ref.target;
 
    if (obj.forwardingAddress) {
      // Already copied: update reference to new location
      ref.target = obj.forwardingAddress;
      continue;
    }
 
    if (obj.survivalCount >= 2) {
      // Survived enough scavenges: promote to old space
      const promoted = copyToOldSpace(obj);
      ref.target = promoted;
      obj.forwardingAddress = promoted;
    } else {
      // Copy to to-space
      const copy = copyTo(obj, toPointer);
      toPointer += obj.size;
      copy.survivalCount++;
      ref.target = copy;
      obj.forwardingAddress = copy;
    }
 
    // Add this object's references to the worklist
    for (const childRef of getReferences(ref.target)) {
      if (isInFromSpace(childRef.target)) {
        worklist.push(childRef);
      }
    }
  }
 
  // Step 3: Swap spaces (to-space becomes the new from-space)
  swap(fromSpace, toSpace);
  // Old from-space is now empty and becomes the new to-space
}

// V8's Mark-Sweep-Compact for old generation
 
// PHASE 1: MARK (incremental + concurrent)
// - Start from roots, traverse all reachable objects
// - Uses tri-color marking: white (unvisited), grey (visited, children pending), black (done)
function incrementalMark(timeBudgetMs) {
  const deadline = performance.now() + timeBudgetMs;
 
  while (greyList.length > 0 && performance.now() < deadline) {
    const obj = greyList.pop();
 
    for (const child of getReferences(obj)) {
      if (child.color === "white") {
        child.color = "grey";
        greyList.push(child);
      }
    }
 
    obj.color = "black"; // Fully processed
  }
 
  // If grey list is not empty, continue in next increment
  return greyList.length === 0;
}
 
// PHASE 2: SWEEP (concurrent)
// - Scan heap pages and add unmarked objects to free lists
// - Runs on a background thread (main thread continues executing JS)
 
// PHASE 3: COMPACT (parallel)
// - Move surviving objects to reduce fragmentation
// - Updates all references to moved objects
// - Only needed for heavily fragmented pages

// V8's GC execution model
 
const gcPipeline = {
  incrementalMarking: {
    description: "Mark phase split into small chunks",
    thread: "Main thread (interleaved with JS execution)",
    pausePerChunk: "< 1ms",
    benefit: "Avoids long pauses by spreading work",
  },
 
  concurrentMarking: {
    description: "Mark phase runs on background threads",
    thread: "Helper threads (parallel to main thread)",
    pauseTime: "Near zero (only brief synchronization pauses)",
    benefit: "Most marking happens without pausing JS",
  },
 
  concurrentSweeping: {
    description: "Free lists built by background threads",
    thread: "Helper threads",
    pauseTime: "Zero (completely off main thread)",
    benefit: "Memory reclamation without any pause",
  },
 
  parallelCompaction: {
    description: "Multiple threads compact memory simultaneously",
    thread: "Helper threads + main thread",
    pauseTime: "Reduced by parallelism",
    benefit: "Faster compaction for fragmented heaps",
  },
 
  parallelScavenge: {
    description: "Young gen scavenge uses multiple threads",
    thread: "Main thread + helper threads",
    pauseTime: "Reduced by 50-70%",
    benefit: "Faster young gen collection",
  },
};

// Write barrier: tracks cross-generation references
 
// When you write: oldObject.child = youngObject
// V8 inserts a write barrier that records this in a "remembered set"
 
// Conceptual write barrier
function writeBarrier(object, field, value) {
  object[field] = value;
 
  if (isInOldSpace(object) && isInNewSpace(value)) {
    // Record this reference so scavenge can find it
    rememberedSet.add({ object, field });
  }
}
 
// This allows scavenge to be efficient:
// - Only scan remembered set + stack roots for new space references
// - No need to scan the entire old space

// Objects are promoted from young gen to old gen based on survival
 
// V8 promotion heuristics:
// 1. Survived at least one scavenge cycle
// 2. New space is filling up (promotion pressure)
// 3. Object is large enough to warrant direct old-space allocation
 
// Impact on your code:
function efficientAllocation() {
  // SHORT-LIVED: stays in young gen, collected cheaply
  for (let i = 0; i < 1000; i++) {
    const temp = { x: i, y: i * 2 };
    processItem(temp);
    // `temp` dies here, collected in young gen scavenge
  }
 
  // LONG-LIVED: promoted to old gen
  const cache = new Map();
  for (let i = 0; i < 100; i++) {
    cache.set(i, { data: computeExpensive(i) });
  }
  // `cache` and all its entries survive multiple scavenges
  // They get promoted to old space
 
  return cache;
}

// V8 uses idle time notifications from the embedder (Chrome/Node.js)
// to schedule non-urgent GC work
 
// Chrome tells V8: "You have X ms of idle time before the next frame"
// V8 uses this to:
// - Complete pending incremental marking steps
// - Perform minor GC (scavenge) if young space pressure is moderate
// - Finalize concurrent sweeping
// - Start background compaction
 
// In Chrome: tied to requestAnimationFrame idle periods
// In Node.js: tied to event loop idle phases
 
// You can help by using requestIdleCallback for heavy work:
function processLargeDataset(items) {
  let index = 0;
 
  function processChunk(deadline) {
    while (index < items.length && deadline.timeRemaining() > 2) {
      processItem(items[index]);
      index++;
    }
 
    if (index < items.length) {
      requestIdleCallback(processChunk);
    }
  }
 
  requestIdleCallback(processChunk);
}

// Node.js exposes V8 heap statistics
const v8 = require("v8");
 
function getHeapStats() {
  const stats = v8.getHeapStatistics();
 
  return {
    totalHeapMB: (stats.total_heap_size / (1024 * 1024)).toFixed(2),
    usedHeapMB: (stats.used_heap_size / (1024 * 1024)).toFixed(2),
    heapLimitMB: (stats.heap_size_limit / (1024 * 1024)).toFixed(2),
    mallocedMB: (stats.malloced_memory / (1024 * 1024)).toFixed(2),
    externalMB: (stats.external_memory / (1024 * 1024)).toFixed(2),
  };
}
 
// Per-space breakdown
function getSpaceStats() {
  return v8.getHeapSpaceStatistics().map((space) => ({
    name: space.space_name,
    sizeMB: (space.space_size / (1024 * 1024)).toFixed(2),
    usedMB: (space.space_used_size / (1024 * 1024)).toFixed(2),
    available: (space.space_available_size / (1024 * 1024)).toFixed(2),
  }));
}
 
// Monitor GC events (Node.js 16+)
const { PerformanceObserver } = require("perf_hooks");
 
const gcObserver = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.log(`GC: ${entry.detail.kind} - ${entry.duration.toFixed(2)}ms`);
    // kind: 1 = Scavenge, 2 = Mark-Sweep-Compact, 4 = Incremental marking
  }
});
 
gcObserver.observe({ entryTypes: ["gc"] });

// 1. Keep object shapes consistent (hidden classes)
// GOOD: all objects have the same shape
function createPoint(x, y) {
  return { x, y };
}
 
// BAD: different property orders create different hidden classes
const p1 = { x: 1, y: 2 };
const p2 = { y: 2, x: 1 }; // Different hidden class
 
// 2. Avoid deleting properties (deoptimizes hidden classes)
// BAD:
delete obj.property;
// GOOD:
obj.property = undefined;
 
// 3. Pre-allocate arrays when size is known
// GOOD:
const arr = new Array(1000);
for (let i = 0; i < 1000; i++) arr[i] = i;
 
// BAD: grows dynamically, causing repeated reallocation
const arr2 = [];
for (let i = 0; i < 1000; i++) arr2.push(i);