Tag
inline-caches
- Sep 19, 2026 Cache Miss Handling and Patching Code at the Access Site What happens on the first execution of a property access, how the runtime rewrites the site without breaking other threads, and why the patched instruction must be safe to overwrite atomically. language runtimes
- Jul 23, 2026 Prototype Chain Guards and Validity Cells Why a compiled access through a prototype is invalidated by an assignment to the prototype rather than by a failed layout check, and how a one-word cell makes that invalidation cheap. language runtimes
- Jun 10, 2026 Superinstruction Selection and In-Place Opcode Quickening How interpreters fuse frequent opcode pairs and rewrite instructions after first execution, and why every such rewrite needs an invalidation path. language runtimes
- May 12, 2026 Hidden Classes and Inline Caches in Dynamic Object Models How a runtime gives dictionary-shaped objects a fixed layout, why each property access site remembers its last hit, and when the cache is invalidated. programming languages
- Mar 17, 2026 Array Element Kinds and Representation Transitions How a homogeneous array of small integers becomes an array of doubles and then an array of boxed values, why the transitions are one-way, and what the kind check costs on each read. language runtimes
- Feb 20, 2026 The Dictionary Object Model and the Cost of a Name Lookup How a dynamically typed object resolves a property name through a per-object table, what a single access costs in instructions and bytes, and which conditions must hold before the lookup can become a fixed offset. language runtimes
- Dec 8, 2025 Inline Caches and Polymorphic Call Sites How a call site learns the shapes it has seen, what a megamorphic site costs, and why cache invalidation is the hard part of making dynamic dispatch fast. programming languages
- Feb 5, 2025 Monomorphic Inline Caches and the Guard That Makes Them Work How a single cached layout and offset turn a dynamic property access into a compare and a load, what the guard must verify beyond layout identity, and why one shape is the case worth optimizing hardest. language runtimes
- Nov 18, 2024 Type Feedback and Inline Caches in Dynamic Call Sites How a runtime records which types actually reach a polymorphic operation, how an inline cache turns that history into a few comparisons, and why monomorphic feedback changes what the compiler can generate. language runtimes
- Aug 13, 2024 Type Feedback and the Speculation Budget How a runtime decides what to speculate about from what the interpreter observed, why the counters that trigger optimization are the same counters that guard it, and what happens when a speculative bet loses. language runtimes
- Dec 26, 2023 Polymorphic and Megamorphic Inline Caches What a cache does when a second and then a fourth layout arrives at the same site, how the compare chain and the hash stub differ, and where the threshold between them sits. language runtimes
- Oct 4, 2023 Object Shapes, Inline Caches, and the Cost of a Polymorphic Site Why property access is fast when objects share a hidden class, how shapes transition, and what turns an inline cache from a lookup into a hash probe. web platform