mirror of
git://git.sv.gnu.org/emacs.git
synced 2026-01-03 10:31:37 -08:00
625 lines
14 KiB
ReStructuredText
625 lines
14 KiB
ReStructuredText
.. _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:`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:`derived type`
|
|
: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:`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:`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:`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:`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`
|