mhtirogla
Home
Systems
API
Pricing
About
Log in
← Back
Home
›
Systems
›
Operating systems and runtimes
jit-vm
JIT-compiling VM
V8, HotSpot
System
Techniques · 18
Primitives · 28
jit-vm
Deoptimization
compilers · medium: Speculate with guards, and on failure rebuild the slow-tier frames from compile-time metadata and resume there, so optimized code may assume the common case.
›
Escape analysis
compilers · medium: Prove which allocations never outlive or leave their creator, then put them on the stack, split them into scalars, or drop their locks.
›
Function inlining
compilers · medium: Inline call sites by cost model and call-graph order; enables downstream optimizations
Generational garbage collection
compilers · medium: Split the heap by age, collect the small young region often and cheaply, and rarely touch old data; wins whenever most objects die young.
›
Global value numbering
compilers · medium: Detect equivalent computations in SSA form to remove redundancy
Incremental and concurrent garbage…
compilers · medium: Trace the heap in small steps or on other threads while the program runs, and use barriers to keep the collector's view correct.
›
Inline caches
compilers · medium: Per-call-site cache of "this object shape, that slot or target", turning dynamic property and method lookup into a compare and a load.
›
Machine code emission
compilers · low: Encode instructions to bytes for x86-64 and AArch64, branch relaxation, constant pools
SSA form
compilers · low: Give every variable exactly one definition, merging at joins with phi functions; def-use becomes explicit and optimizations turn sparse and cheap.
›
Hidden classes (shapes)
compilers · low: Objects that gained the same properties in the same order share one layout descriptor, so a property is an index and the layout is one comparable id.
›
Bytecode interpreter
compilers · low: Register/stack VM dispatch loop for executing compiled plans or rules (SQLite VDBE, nftables)
Executable memory under W^X
compilers · low: How JITs and code generators emit machine code under W^X: RW to RX flips, dual mappings, per-thread write toggles, and the instruction-cache flush.
›
Value tagging and NaN-boxing
compilers · low: Pack the type and the payload of any value into one 64-bit word, using spare low bits of aligned pointers or the unused payload of NaNs, so type tests are one mask compare.
›
Strongly connected components
graphs · low: Tarjan/Kosaraju SCCs for cycle detection in dependency graphs
Mark-sweep garbage collection
compilers · low: Find everything reachable from the roots, free the rest in place; handles cycles, never moves objects, and is the base of most production collectors.
›
Dirty page tracking
hardware-os · low: Write-protection or PML logs of modified guest/process pages
Dominator tree
compilers · low: Dominators via Lengauer-Tarjan or Cooper-Harvey-Kennedy; dominance frontiers for SSA
Hash consing
data-structures · low: Intern structurally equal immutable terms so equality is pointer comparison and sharing is maximal
Memory ordering
concurrency · low: What Relaxed, Acquire, Release and SeqCst atomics actually guarantee, what they cost on x86 and ARM, and which one each pattern needs.
›
Tree pattern matching
compilers · low: Matching AST patterns with metavariables
Interval tree
data-structures · low: Index of ranges that answers "which intervals overlap this point or range?" in O(log n + k); static sorted-array form is the compact, cache-friendly choice.
›
Numa aware allocation
hardware-os · low: Allocate memory and pin threads on the local NUMA node; first-touch and interleave policies
Slab allocator
systems · low: Pre-carve pages into equal-size slots per size class with an in-place free list: O(1) alloc and free, no external fragmentation, cache-warm reuse.
›
+ 11 more techniques
+ 12 more primitives
System
Techniques · 18
Primitives · 28
jit-vm
Deoptimization
compilers · medium: Speculate with guards, and on failure rebuild the slow-tier frames from compile-time metadata and resume there, so optimized code may assume the common case.
›
Escape analysis
compilers · medium: Prove which allocations never outlive or leave their creator, then put them on the stack, split them into scalars, or drop their locks.
›
Function inlining
compilers · medium: Inline call sites by cost model and call-graph order; enables downstream optimizations
Generational garbage collection
compilers · medium: Split the heap by age, collect the small young region often and cheaply, and rarely touch old data; wins whenever most objects die young.
›
Global value numbering
compilers · medium: Detect equivalent computations in SSA form to remove redundancy
Incremental and concurrent garbage…
compilers · medium: Trace the heap in small steps or on other threads while the program runs, and use barriers to keep the collector's view correct.
›
Inline caches
compilers · medium: Per-call-site cache of "this object shape, that slot or target", turning dynamic property and method lookup into a compare and a load.
›
Instruction selection
compilers · medium: Cover the IR with target instruction patterns at least cost; greedy maximal munch is simple, dynamic programming over a tree or DAG is optimal.
›
JIT compilation
compilers · medium: Run cold code in a cheap tier, count executions, and compile only what gets hot, trading warm-up time and memory for peak speed.
›
On-stack replacement
compilers · medium: Count loop back-edges, compile code that can start at a loop header, and copy the live frame state into it, so one running call gets faster.
›
Register allocation
compilers · medium: Map unlimited virtual registers onto a few machine registers, spilling the rest to the stack; linear scan is fast, graph coloring and splitting allocators give better code.
›
Thread caching allocator
systems · medium: General-purpose malloc with size classes, per-thread caches and free-list sharding (tcmalloc, mimalloc)
Call graph construction
compilers · medium: Building call graphs with dynamic dispatch resolution (CHA, RTA)
Copying gc
compilers · medium: Cheney semispace copying collection: bump allocation, forwarding pointers, compaction for free
Dataflow analysis
compilers · medium: Compute a fact per program point (live variables, reaching definitions, available expressions) by iterating transfer functions over the CFG to a fixed point.
›
Stack unwinding
compilers · medium: Frame-pointer, DWARF CFI and compact unwinding of call stacks
Graph coloring
graphs · medium: Greedy/DSatur colouring for conflict-free assignment such as radio channels
Debug info (DWARF)
compilers · medium: DWARF stores a tree of typed entries (DIEs), a line-number bytecode, unwind tables and location expressions that map machine state back to source; pick it for ELF/Mach-O debug builds.
›
Machine code emission
compilers · low: Encode instructions to bytes for x86-64 and AArch64, branch relaxation, constant pools
SSA form
compilers · low: Give every variable exactly one definition, merging at joins with phi functions; def-use becomes explicit and optimizations turn sparse and cheap.
›
Hidden classes (shapes)
compilers · low: Objects that gained the same properties in the same order share one layout descriptor, so a property is an index and the layout is one comparable id.
›
Bytecode interpreter
compilers · low: Register/stack VM dispatch loop for executing compiled plans or rules (SQLite VDBE, nftables)
Executable memory under W^X
compilers · low: How JITs and code generators emit machine code under W^X: RW to RX flips, dual mappings, per-thread write toggles, and the instruction-cache flush.
›
Value tagging and NaN-boxing
compilers · low: Pack the type and the payload of any value into one 64-bit word, using spare low bits of aligned pointers or the unused payload of NaNs, so type tests are one mask compare.
›
Strongly connected components
graphs · low: Tarjan/Kosaraju SCCs for cycle detection in dependency graphs
Mark-sweep garbage collection
compilers · low: Find everything reachable from the roots, free the rest in place; handles cycles, never moves objects, and is the base of most production collectors.
›
Dirty page tracking
hardware-os · low: Write-protection or PML logs of modified guest/process pages
Dominator tree
compilers · low: Dominators via Lengauer-Tarjan or Cooper-Harvey-Kennedy; dominance frontiers for SSA
Hash consing
data-structures · low: Intern structurally equal immutable terms so equality is pointer comparison and sharing is maximal
Memory ordering
concurrency · low: What Relaxed, Acquire, Release and SeqCst atomics actually guarantee, what they cost on x86 and ARM, and which one each pattern needs.
›
Tree pattern matching
compilers · low: Matching AST patterns with metavariables
Interval tree
data-structures · low: Index of ranges that answers "which intervals overlap this point or range?" in O(log n + k); static sorted-array form is the compact, cache-friendly choice.
›
Numa aware allocation
hardware-os · low: Allocate memory and pin threads on the local NUMA node; first-touch and interleave policies
Slab allocator
systems · low: Pre-carve pages into equal-size slots per size class with an in-place free list: O(1) alloc and free, no external fragmentation, cache-warm reuse.
›
Control-flow graph
compilers · low: Split a linear instruction list into basic blocks and connect them by jumps; the graph every optimizer, SSA builder and dataflow pass walks.
›
Name resolution
compilers · low: Bind every use of a name to its declaration with a scope stack, handling shadowing, hoisting and closure capture in one AST walk.
›
BFS and DFS
graphs · low: The two basic graph traversals; BFS gives hop distances and levels, DFS gives discovery/finish order for cycles, components and topological order.
›
Arena allocator
systems · low: Allocate by bumping a pointer through big chunks and free everything at once: a few instructions per allocation for objects sharing a lifetime.
›
Topological sort
graphs · low: Order the vertices of a DAG so every edge points forward; the core of build systems, schedulers and dependency resolution, with cycle detection for free.
›
Calling conventions abi
compilers · low: System V, Windows x64 and AAPCS64 ABIs: argument registers, stack frames, struct passing, FFI
Executable formats elf pe
compilers · low: ELF, PE and Mach-O: sections, segments, symbol tables, relocations, dynamic loading
d-ary heap
data-structures · low: Array heap with d children per node (d = 4 typical): half the binary heap's depth, siblings in one cache line, faster priority queues.
›
Varint (LEB128)
compression · low: Variable-length integers in 7-bit groups with a continuation bit; small numbers take 1 byte, the wire format of Protobuf, WebAssembly and DWARF.
›
String interning
data-structures · low: Store each distinct string once and refer to it by id
Swiss table
data-structures · low: Open-addressing hash table that filters 8-16 slots at once with 1-byte hash tags and SIMD, giving fast lookups at 87.5 % load.
›
Sparse matrices (CSR)
numerics · low: Compressed sparse row stores only nonzeros as row pointers, column indices and values; SpMV streams them once, so it is memory-bandwidth bound.
›
Copy for AI
Similar systems
Share the most building blocks with this one.
compiler
19 %
wasm-runtime
19 %
bytecode-interpreter
17 %