Optimal Heap Limits for Reducing Browser Memory Use

TL;DR

This paper introduces a new framework for setting heap limits in garbage-collected runtimes, deriving an optimal rule that reduces memory usage and garbage collection time without communication between heaps.

Contribution

The paper proposes the square-root heap limit rule, an optimal method for allocating memory across multiple heaps to minimize total memory and garbage collection time.

Findings

Reduces memory usage by approximately 16% in real-world web pages.

Achieves up to 30% reduction in garbage collection time on benchmarks.

Demonstrates effectiveness of the rule in a prototype for V8 JavaScript engine.

Abstract

Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal "square-root" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage.