Memory Management Glossary: A

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

absolute address
activation frame
activation record

Also known as

activation frame, function record.

An activation or function record is a data structure, associated with the invocation of a function, procedure, or control block that stores the variables, temporaries, and fixed-sized data that are local to the block, and the information required to return to the invoking context. It is often stored on a control stack.

In a register-based hardware architecture, the current activation record is typically partially stored in registers.

Closures and continuations are specializations of activation records in support of particular language features of LISP, Scheme and related languages.

Relevance to memory management

The current activation record is part of the state of the mutator, and is therefore a root to the collector(2). In languages that permit recursion, activation records have dynamic extent. In languages that permit closures or continuations, activation records may have indefinite extent. Although they may not be visible to the programmer, their memory(1) must be managed by the language run-time support. Because they are usually not visible to the programmer, they may be a source of inexplicable memory overhead.

See also

stack frame.

activation stack




An address is a specification of a memory location in an address space.

An address is almost always represented as an unsigned integer stored in a single machine word. The address is decoded by the hardware in order to access a location on a physical memory(2) device (such as a RAM) or some memory-mapped resource.

Diagram: A simplified view of addresses, address space, and locations on a 32-bit architecture.

A simplified view of addresses, address space, and locations on a 32-bit architecture.

Similar term


In the MPS

An address is represented by a value of the type mps_addr_t.

address space

An address space is the set of possible addresses. It can also be considered to be a partial function from addresses to locations.

Typically, addresses start at zero and run to 2n−1, where n is the address width (for example, 15, 16, 24, 32, 64), which is usually the same as the width of the address bus. This may not be true for segmented architectures.

In modern systems, large parts of the whole address space may be reserved by the operating system or architecture, or not mapped at any given time. The mapped part of the address space may be discontiguous or sparse.

address space layout randomization

Also known as


The random placement in address space of the stack, data segment, heap, and so on, of a process.

The purpose of ASLR is to make it harder for an attacker to exploit buffer overflow bugs, by making it harder to determine the addresses of data structures.

In the MPS

ASLR also makes it hard to prepare a repeatable test case for a program that performs computation based on the addresses of objects, for example, hashing objects by their address. See Address space layout randomization for techniques to deal with this.

address translation cache
address-ordered first fit

The allocation policy that always uses the suitable free block with the lowest address. One of the most common allocation policies in use. Commonly implemented by first fit on a single address-ordered free block chain. Sometimes just called “first fit”.

Related publication

Wilson et al. (1995).

aging space

In some generational garbage collection systems, when generations are divided into buckets, the aging space is where objects which survive a collection cycle stay until they are old enough to be promoted.

Opposite term

creation space.

algebraic data type

Algebraic data types aggregate or alternate a number of dissimilarly-typed objects. They are termed algebraic because they can be expressed using the sum and product operators, for example (a and b and c) or d.

Examples of algebraic data types include: structures, records, tuples, and unions.

Relevance to memory management

Algebraic data types are usually represented using a heap. Because of their non-uniformity, algebraic data types are more difficult to scan.


Alignment is a constraint on the address of an object in memory(2).

The constraint is usually that the object’s address must be a multiple of a power of two, 2n, and therefore that the least significant n bits of the address must be zero.

The bus hardware of many modern processors cannot access multi-byte(2) objects at any memory address. Often word-sized objects must be aligned to word boundaries, double-words to double-word boundaries, double-floats to 8-byte boundaries, and so on. If a program attempts to access an object that is incorrectly aligned, a bus error occurs.

Relevance to memory management

A memory manager must take care to allocate memory with an appropriate alignment for the object that is going to be stored there. Implementations of malloc have to allocate all blocks at the largest alignment that the processor architecture requires. Other reasons for aligning objects include using the least significant bits of the address for a tag.

Opposite term


See also

natural alignment.

In the MPS

An alignment is represented by the unsigned integral type mps_align_t. It must be a power of 2. The alignment of objects allocated in a pool may be specified by passing the MPS_KEY_ALIGN keyword argument when calling mps_pool_create_k().





Also known as


Allocation is the process of assigning resources. When requested to by the program, an application memory manager or allocator allocates a block of memory(2) for the program to store its data in. Allocation is also known as consing, from cons(1).

When faced with a request for memory from the program, a memory manager must choose a suitable block and hand it over, or fail. The choices made by the memory manager at this point can have a significant effect on the future efficiency of the program.

Allocation is rarely a simple issue. For example, programs usually allocate activation records (automatic variables, and so on) for functions from a processor stack simply by subtracting a number from their stack pointer. However, in a virtual memory system, this may extend the stack onto a previously unused page, in which case the operating system memory manager must carry out some quite complex operations in order to supply the program with backing store for the stack so that the program can continue.

Historical note

The term reserved was often used to mean “allocated”.

Similar term


Opposite term


See also


Related publication

Wilson et al. (1995).

In the MPS

See Allocation.

allocation frame

In the MPS

An allocation frame is a marker that can pushed onto an allocation point by calling mps_ap_frame_push(), and then popped by calling mps_ap_frame_pop() to indicate that all blocks allocated on the allocation point are dead (in the case of manual pools), or very likely dead (in the case of automatic pools). Allocation frames can be used by the client program to efficiently implement stack-like patterns of allocation.

allocation mechanism

The algorithm by which an allocator chooses a free block from which to satisfy an allocation request. An allocation mechanism is the implementation of an allocation policy.

A common mechanism is “first fit on an address-ordered free block chain, with eager coalescing”. This implements the address-ordered first fit policy, and commonly inherits that name, although there are many other mechanisms for implementing that policy, for example, “leftmost fit on a balanced tree of free blocks ordered by address”.

Related publication

Wilson et al. (1995).

allocation pattern

In the MPS

A hint to the MPS to expect a particular pattern of allocation on an allocation point. The MPS may use this hint to schedule its decisions as to when and what to collect. See Allocation patterns.

allocation point

In the MPS

An allocation point is an interface to a pool which provides fast buffered allocation, and defers the need for synchronization in a multi-threaded environment. Allocation points belong to the type mps_ap_t.

allocation point protocol

In the MPS

The protocol that ensures safe inline allocation on an allocation point. See Allocation point protocol.

allocation policy

Also known as

placement policy.

The concrete policy used by an allocator for choosing a free block to satisfy an allocation request.

For instance, “always allocate from the largest free block” (worst fit) or “use the most recently freed block suitable” (LIFO-ordered first fit).

Each allocation policy is motivated by an allocation strategy and implemented by an allocation mechanism.

Related publication

Wilson et al. (1995).

allocation strategy

The high-level design motivation or strategy, of an allocator, which uses observations or theories about patterns of allocation requests to justify an allocation policy.

For instance, “do not allow small long-lived objects to fragment large free(3) areas”, “allocate consecutive objects close together”, and so on. The allocation strategy motivates an allocation policy, which is implemented by an allocation mechanism.

Related publication

Wilson et al. (1995).


The term allocator is often used to refer to the memory manager, usually when it is a simple manual one.

Similar term

memory manager.

See also


ambiguous reference

Also known as

unsure reference.

An ambiguous or unsure reference is a value that is potentially a reference, but the collector(1) cannot prove that it is.

The presence of ambiguous references in a garbage-collected system requires the use of conservative garbage collection.

Opposite term

exact reference.

See also

floating garbage.

ambiguous root

An ambiguous root is a root containing ambiguous references.

Opposite term

exact root.

In the MPS

An ambiguous root has rank mps_rank_ambig().


The area of memory(2) used by malloc for allocation.

So named from a semi-mythical “malloc: corrupted arena” message supposedly emitted when some early versions became terminally confused.

See also


In the MPS

An arena is the data structure responsible for requesting memory(3) from the operating system, making it available to pools, and for garbage collection. Arenas belong to the type mps_arena_t. See Arenas.

arena class

In the MPS

A value of type mps_arena_class_t describing a class of arenas. Arena classes include client arenas and virtual memory arenas.


A declaration in a program of a condition that is expected always to be true, or which must be true in order for the program to continue to execute correctly.

In the MPS

Memory management mistakes often lead to overwriting errors that corrupt the data structures used by the memory manager to maintain memory. Except in the rash variety, most MPS functions assert the validity of the data structures they operate on. This means that memory management mistakes are detected as early as possible, when there may still be enough evidence in the heap to debug them. See Error handing.

asynchronous garbage collector

A collector(2) is asynchronous with respect to the mutator if it cannot be (easily) predicted when the collector will run.

This means that the mutator must ensure that formatted objects are always scannable.

atomic object
automatic memory management

Automatic memory management is a general term for techniques that automatically recycle unused memory(2).

It is not possible, in general, to automatically determine which objects are still live. Even if it didn’t depend on future input, there can be no general algorithm to prove that an object is live (cf. the Halting Problem). However, effective approximations are possible.

In tracing garbage collection, the approximation is that an object can’t be live unless it is reachable. In reference counting, the approximation is that an object can’t be live unless it is referenced. Analysis of the program text can reveal where objects die; A notable technique in this vein is region inference.

Hybrid algorithms are also possible.

Similar term

garbage collection.

Opposite term

manual memory management.

In the MPS

The MPS provides automatic memory management through pool classes such as AMC (Automatic Mostly-Copying), AMS (Automatic Mark and Sweep), and AWL (Automatic Weak Linked).

automatic storage duration

In C, objects that are declared with automatic storage duration are live for the duration of a block of code.

In most implementations of C, objects with automatic storage duration are allocated on the stack when a function is entered, and deallocated when it returns.

Opposite term

static storage duration.

Previous topic

Memory Management Glossary

Next topic

Memory Management Glossary: B


All MPS Kit releases


All open issues

Contact us
#memorypoolsystem on