.. _glossary:

Memory Management Glossary
**************************

.. include:: alphabet.txt

.. toctree::
   :maxdepth: 1
   :hidden:

   a
   b
   c
   d
   e
   f
   g
   h
   i
   k
   l
   m
   n
   o
   p
   q
   r
   s
   t
   u
   v
   w
   z

All
===

:term:`absolute address <physical address>`
:term:`activation frame <activation record>`
:term:`activation record`
:term:`activation stack <control stack>`
:term:`active <live>`
:term:`address`
:term:`address space`
:term:`address space layout randomization`
:term:`address translation cache <translation lookaside buffer>`
:term:`address-ordered first fit`
:term:`aging space`
:term:`algebraic data type`
:term:`alignment`
:term:`alive <live>`
:term:`allocate`
:term:`allocation frame`
:term:`allocation mechanism`
:term:`allocation pattern`
:term:`allocation point`
:term:`allocation point protocol`
:term:`allocation policy`
:term:`allocation strategy`
:term:`allocator`
:term:`ambiguous reference`
:term:`ambiguous root`
:term:`arena`
:term:`arena class`
:term:`ASLR <address space layout randomization>`
:term:`assertion`
:term:`asynchronous garbage collector`
:term:`ATC <translation lookaside buffer>`
:term:`atomic object <leaf object>`
:term:`automatic memory management`
:term:`automatic storage duration`

:term:`backing store`
:term:`barrier (1)`
:term:`barrier (2)`
:term:`barrier hit <protection fault>`
:term:`base pointer`
:term:`best fit`
:term:`BIBOP`
:term:`big bag of pages <BIBOP>`
:term:`binary buddies`
:term:`bit array <bitmap>`
:term:`bit table <bitmap>`
:term:`bit vector <bitmap>`
:term:`bitmap`
:term:`bitmap marking`
:term:`bitmapped fit`
:term:`bitmask`
:term:`bitset <bitmap>`
:term:`black`
:term:`blacklisting`
:term:`black-listing`
:term:`block`
:term:`bounds error <overwriting error>`
:term:`boxed`
:term:`break-table`
:term:`brk`
:term:`broken heart`
:term:`bucket`
:term:`buddy system`
:term:`buffer`
:term:`bus error`
:term:`byte (1)`
:term:`byte (2)`
:term:`byte (3)`
:term:`byte (4)`

:term:`C89 <C90>`
:term:`C90`
:term:`C99`
:term:`cache (1)`
:term:`cache (2)`
:term:`cache memory <cache (1)>`
:term:`cache policy`
:term:`caching (3)`
:term:`cactus stack`
:term:`card`
:term:`card marking`
:term:`cell <object>`
:term:`Cheney collector`
:term:`Cheney scan <Cheney collector>`
:term:`clamped state`
:term:`client arena`
:term:`client object`
:term:`client pointer`
:term:`client program <mutator>`
:term:`closure`
:term:`coalesce`
:term:`cold end`
:term:`collect`
:term:`collection <collection cycle>`
:term:`collection cycle`
:term:`collector (1) <garbage collector>`
:term:`collector (2)`
:term:`color`
:term:`colour`
:term:`commit limit`
:term:`committed (1) <mapped>`
:term:`committed (2)`
:term:`compactifying <compaction>`
:term:`compaction`
:term:`composite object`
:term:`comprehensive`
:term:`concurrent garbage collection <parallel garbage collection>`
:term:`condemned set`
:term:`connected`
:term:`cons (1)`
:term:`cons (2) <allocate>`
:term:`conservative garbage collection`
:term:`constant root`
:term:`constructor (1)`
:term:`constructor (2)`
:term:`continuation`
:term:`control stack`
:term:`cool`
:term:`copying garbage collection`
:term:`core`
:term:`creation space`
:term:`critical path`
:term:`crossing map`
:term:`cyclic data structure`

:term:`dangling pointer`
:term:`data stack`
:term:`dead`
:term:`deallocate <free (1)>`
:term:`debugging pool`
:term:`deferred coalescing`
:term:`deferred reference counting`
:term:`dependent object`
:term:`derived pointer <interior pointer>`
:term:`destructor (1)`
:term:`destructor (2)`
:term:`DGC <distributed garbage collection>`
:term:`direct method`
:term:`dirty bit`
:term:`distributed garbage collection`
:term:`double buddies`
:term:`double free`
:term:`doubleword`
:term:`doubly weak hash table`
:term:`DRAM <dynamic memory>`
:term:`dynamic allocation <heap allocation>`
:term:`dynamic extent`
:term:`dynamic memory`
:term:`dynamic RAM <dynamic memory>`

:term:`ecru <off-white>`
:term:`edge`
:term:`entry table (1)`
:term:`entry table (2)`
:term:`exact garbage collection`
:term:`exact reference`
:term:`exact root`
:term:`exact segregated fit`
:term:`execution stack <control stack>`
:term:`exit table`
:term:`extent <lifetime>`
:term:`external fragmentation`

:term:`fencepost`
:term:`fence post`
:term:`fencepost error`
:term:`fence post error`
:term:`Fibonacci buddies`
:term:`FIFO-ordered first fit`
:term:`file mapping <memory mapping>`
:term:`finalization`
:term:`finalized block`
:term:`first fit`
:term:`fix`
:term:`flip`
:term:`floating garbage`
:term:`foreign code`
:term:`format`
:term:`format method`
:term:`formatted object`
:term:`forward method`
:term:`forwarding marker`
:term:`forwarding object`
:term:`forwarding pointer`
:term:`fragmentation`
:term:`frame <in-band header>`
:term:`free (1)`
:term:`free (2)`
:term:`free (3)`
:term:`free (4) <unmapped>`
:term:`free block`
:term:`free block chain`
:term:`free list`
:term:`free store <heap>`
:term:`freestore <heap>`
:term:`from space`
:term:`fromspace`
:term:`function pointer`
:term:`function record <activation record>`

:term:`garbage`
:term:`garbage collection`
:term:`garbage collector`
:term:`GB <gigabyte>`
:term:`GC <garbage collection>`
:term:`General Protection Fault`
:term:`generation`
:term:`generation chain`
:term:`generation scavenging <generational garbage collection>`
:term:`generational garbage collection`
:term:`generational hypothesis`
:term:`gigabyte`
:term:`good fit`
:term:`GPF <General Protection Fault>`
:term:`grain`
:term:`graph`
:term:`gray`
:term:`grey`
:term:`gray list`
:term:`grey list`

:term:`handle`
:term:`header <in-band header>`
:term:`heap`
:term:`heap allocation`
:term:`hit`
:term:`hit rate`
:term:`hot`
:term:`hot end`
:term:`huge page`

:term:`immediate data`
:term:`immune set`
:term:`immutable`
:term:`immutable object <value object>`
:term:`in-band header`
:term:`in parameter`
:term:`in/out parameter`
:term:`incremental garbage collection`
:term:`incremental update`
:term:`indefinite extent`
:term:`indexed fit`
:term:`indirect method`
:term:`infant mortality <generational hypothesis>`
:term:`inline allocation (1)`
:term:`inline allocation (2)`
:term:`inter-generational pointer`
:term:`interior pointer`
:term:`internal fragmentation`
:term:`invalid page fault`
:term:`inverted page table`
:term:`inverted page-table`
:term:`is-forwarded method`

:term:`kB <kilobyte>`
:term:`keyword argument`
:term:`kilobyte`

:term:`large object area`
:term:`large page <huge page>`
:term:`leaf object`
:term:`leak <memory leak>`
:term:`life <lifetime>`
:term:`lifetime`
:term:`LIFO-ordered first fit`
:term:`limited-field reference count`
:term:`linear addressing`
:term:`live`
:term:`load`
:term:`locality of reference`
:term:`location <memory location>`
:term:`location dependency`
:term:`lock free`
:term:`logical address <virtual address>`
:term:`longword <doubleword>`

:term:`machine word <word>`
:term:`main memory`
:term:`malloc`
:term:`manual memory management`
:term:`mapped`
:term:`mapping`
:term:`mark-compact`
:term:`mark-sweep`
:term:`mark-and-sweep`
:term:`marking`
:term:`MB <megabyte>`
:term:`megabyte`
:term:`memoization <caching (3)>`
:term:`memory (1)`
:term:`memory (2)`
:term:`memory (3) <main memory>`
:term:`memory (4)`
:term:`memory bandwidth`
:term:`memory cache <cache (1)>`
:term:`memory hierarchy <storage hierarchy>`
:term:`memory leak`
:term:`memory location`
:term:`memory management`
:term:`Memory Management Unit <MMU>`
:term:`memory manager`
:term:`memory mapping`
:term:`memory protection <protection>`
:term:`message`
:term:`message queue`
:term:`message type`
:term:`misaligned <unaligned>`
:term:`miss`
:term:`miss rate`
:term:`mmap`
:term:`MMU`
:term:`mostly-copying garbage collection`
:term:`mostly-exact garbage collection <semi-conservative garbage collection>`
:term:`mostly-precise garbage collection <semi-conservative garbage collection>`
:term:`moving garbage collector`
:term:`moving memory manager`
:term:`mutable`
:term:`mutator`

:term:`nailing <pinning>`
:term:`natural alignment`
:term:`nepotism`
:term:`next fit`
:term:`new space`
:term:`newspace <tospace>`
:term:`node`
:term:`non-moving garbage collector`
:term:`non-moving memory manager`
:term:`nursery generation <nursery space>`
:term:`nursery space`

:term:`object`
:term:`object format`
:term:`object pointer`
:term:`off-white`
:term:`old space <fromspace>`
:term:`oldspace <fromspace>`
:term:`one-bit reference count`
:term:`opaque type`
:term:`out parameter`
:term:`out-of-band header`
:term:`overcommit`
:term:`overwriting error`

:term:`padding`
:term:`padding method`
:term:`padding object`
:term:`page`
:term:`page fault`
:term:`page marking`
:term:`page protection <protection>`
:term:`page table`
:term:`paged in`
:term:`paged out`
:term:`paging`
:term:`palimpsest`
:term:`parallel garbage collection`
:term:`parked state`
:term:`perfect fit`
:term:`phantom reachable`
:term:`phantomly reachable`
:term:`phantom reference`
:term:`physical address`
:term:`physical address space`
:term:`physical memory (1)`
:term:`physical memory (2)`
:term:`physical storage <physical memory (2)>`
:term:`pig in the python`
:term:`pig in the snake <pig in the python>`
:term:`pinning`
:term:`placement policy <allocation policy>`
:term:`platform`
:term:`plinth`
:term:`pointer`
:term:`pool`
:term:`pool class`
:term:`postmortem state`
:term:`precise garbage collection <exact garbage collection>`
:term:`precise reference <exact reference>`
:term:`precise root <exact root>`
:term:`premature free`
:term:`premature promotion <premature tenuring>`
:term:`premature tenuring`
:term:`primary storage <main memory>`
:term:`promotion`
:term:`protectable root`
:term:`protected`
:term:`protection`
:term:`protection exception <protection fault>`
:term:`protection fault`
:term:`protection violation <protection fault>`

:term:`quadword`

:term:`RAM`
:term:`random access memory <RAM>`
:term:`ramp allocation`
:term:`rank`
:term:`rash`
:term:`raw <unwrapped>`
:term:`reachable`
:term:`read barrier`
:term:`read fault`
:term:`read-only memory <ROM>`
:term:`real memory (1)`
:term:`real memory (2) <physical memory (1)>`
:term:`reclaim`
:term:`recycle`
:term:`reference`
:term:`reference counting`
:term:`reference object`
:term:`region inference`
:term:`register`
:term:`register set partitioning`
:term:`relocation`
:term:`remembered set`
:term:`remote reference`
:term:`replicating garbage collector`
:term:`reserved`
:term:`resident`
:term:`resident set`
:term:`result code`
:term:`resurrection`
:term:`ROM`
:term:`root`
:term:`root description`
:term:`root mode`
:term:`root set`

:term:`sbrk`
:term:`scalar data type`
:term:`scan`
:term:`scan method`
:term:`scan state`
:term:`scavenging garbage collection <copying garbage collection>`
:term:`SDRAM`
:term:`segmentation violation`
:term:`segmented addressing`
:term:`segregated allocation cache`
:term:`segregated fit`
:term:`segregated free list`
:term:`segregated free-list`
:term:`semi-conservative garbage collection`
:term:`semi-space`
:term:`semi-space collector <two-space collector>`
:term:`sequential fit`
:term:`sequential store buffer`
:term:`shared memory`
:term:`simple object`
:term:`simple segregated storage`
:term:`size`
:term:`size class`
:term:`skip method`
:term:`smart pointer`
:term:`snap-out`
:term:`snapshot at the beginning`
:term:`soft reference`
:term:`softly reachable`
:term:`space leak <memory leak>`
:term:`spare commit limit`
:term:`spare committed memory`
:term:`spaghetti stack <cactus stack>`
:term:`splat`
:term:`split`
:term:`SRAM <static memory (1)>`
:term:`SSB <sequential store buffer>`
:term:`stack`
:term:`stack allocation`
:term:`stack frame`
:term:`stack record <stack frame>`
:term:`static allocation`
:term:`static memory (1)`
:term:`static memory (2)`
:term:`static object`
:term:`static RAM <static memory (1)>`
:term:`static storage duration`
:term:`stepper function`
:term:`sticky reference count <limited-field reference count>`
:term:`stop-and-copy collection`
:term:`storage <memory (1)>`
:term:`storage hierarchy`
:term:`storage level`
:term:`storage management <memory management>`
:term:`store (1)`
:term:`store (2) <memory (1)>`
:term:`stretchy vector`
:term:`strict segregated fit`
:term:`strong reference`
:term:`strong root`
:term:`strong tri-color invariant`
:term:`strong tri-colour invariant`
:term:`strong tricolor invariant`
:term:`strong tricolour invariant`
:term:`strongly reachable`
:term:`suballocator`
:term:`subgraph`
:term:`superpage <huge page>`
:term:`sure reference <exact reference>`
:term:`swap space`
:term:`swapped in`
:term:`swapped out`
:term:`swapping`
:term:`sweeping`
:term:`synchronous garbage collector`

:term:`tabling <caching (3)>`
:term:`tag`
:term:`tagged architecture`
:term:`tagged reference`
:term:`TB (1) <terabyte>`
:term:`TB (2) <translation lookaside buffer>`
:term:`telemetry filter`
:term:`telemetry label`
:term:`telemetry stream`
:term:`tenuring <promotion>`
:term:`terabyte`
:term:`termination <finalization>`
:term:`thrash`
:term:`thread`
:term:`threatened set <condemned set>`
:term:`TLB <translation lookaside buffer>`
:term:`to space`
:term:`tospace`
:term:`trace`
:term:`tracing garbage collection`
:term:`translation buffer`
:term:`translation lookaside buffer`
:term:`transparent alias`
:term:`transparent type`
:term:`transport`
:term:`transport snap-out <snap-out>`
:term:`treadmill`
:term:`tri-color invariant`
:term:`tri-colour invariant`
:term:`tricolor invariant`
:term:`tricolour invariant`
:term:`tri-color marking`
:term:`tri-colour marking`
:term:`tricolor marking`
:term:`tricolour marking`
:term:`two-space collector`
:term:`two space collector`
:term:`type-accurate garbage collection <exact garbage collection>`
:term:`type punning`

:term:`unaligned`
:term:`unboxed`
:term:`unclamped state`
:term:`undead`
:term:`unmapped`
:term:`unprotected`
:term:`unreachable`
:term:`unsure reference <ambiguous reference>`
:term:`unwrapped`
:term:`use after free <premature free>`

:term:`value object`
:term:`variety`
:term:`vector data type`
:term:`virtual address`
:term:`virtual address space`
:term:`virtual memory`
:term:`virtual memory arena`
:term:`visitor function <stepper function>`
:term:`VM (1) <virtual memory>`
:term:`VM (2)`

:term:`weak-key hash table`
:term:`weak-value hash table`
:term:`weak hash table`
:term:`weak reference (1)`
:term:`weak reference (2)`
:term:`weak root`
:term:`weak tri-color invariant`
:term:`weak tri-colour invariant`
:term:`weak tricolor invariant`
:term:`weak tricolour invariant`
:term:`weakly reachable`
:term:`weighted buddies`
:term:`weighted reference counting`
:term:`white`
:term:`word`
:term:`working set`
:term:`worst fit`
:term:`wrapped`
:term:`wrapper`
:term:`write barrier`
:term:`write fault`

:term:`ZCT <zero count table>`
:term:`zero count table`