Contiguous Memory Mechanism Overview

• Contiguous Memory (CM) Mechanism is a memory management approach that maintains uninterrupted memory blocks, vital for efficient GPU and accelerator performance.
• It employs algorithms, such as ClassSort, to handle dynamic allocation with constant move operations and controlled amortized costs.
• Practical implementations like Mosaic and Virtual Memory Stitching optimize address translation and reduce fragmentation in modern computing systems.

Contiguous Memory (CM) Mechanism refers to a class of allocation, management, and compaction methodologies in computing systems that guarantee or exploit contiguous physical or virtual memory regions. These mechanisms have been studied across hardware/software boundaries for applications ranging from array layout maintenance to GPU memory defragmentation and address translation optimization. CM is central wherever indivisible, physically contiguous memory is a resource constraint, as in FPGA configuration, large-object allocation, TLB coalescing, and ML accelerator caches.

1. Foundational Models and Theoretical Properties

At its core, a contiguous memory mechanism manages a memory pool (typically modeled as an array $A[1 \dots |A|]$) subdivided into contiguous blocks (“modules” or “objects”), each requiring an uninterrupted interval $A[s \dots s+m_i-1]$ of size $m_i$ (Bender et al., 2011). Allocation, deallocation, and dynamic rearrangement are constrained such that:

• Each module occupies a contiguous and non-overlapping region;
• Relocations (move operations) can only target free, contiguous blocks disjoint from the source;
• Modules may not be split or aliased with indirection—entire physical blocks are moved.

Free intervals (“holes”) and module intervals are explicitly tracked. Offline defragmentation, e.g., sorting all modules to one end, has a proven $\Theta(n^2)$ lower and upper bound on moves in the worst case, even if sufficient space exists (e.g., “SortArray” algorithm). The optimal defragmentation (maximizing the largest free contiguous interval) is strongly NP-complete via reduction from 3-PARTITION (Bender et al., 2011).

In the online context, such as dynamic insertion/deletion, the “ClassSort” algorithm partitions module sizes into power-of-two classes, using redundant binary counters for buffer management to guarantee $O(1)$ moves per update and an amortized total cost of $O(m_i \log M)$ per operation, where $M$ is the largest module seen (Bender et al., 2011).

2. Practical Realizations in Modern Systems

2.1 GPU Memory and Virtual Memory Systems

GPUs and accelerators have motivated significant advancements in CM mechanisms due to their constraints on TLB reach, demand-paging granularity, and allocation patterns.

2.1.1 En-masse Allocation and In-place Coalescing

Mosaic (Ausavarungnirun et al., 2018) leverages large contiguous allocations by dividing physical memory into 2MB “frames” where 512 contiguous 4KB base pages map linearly. These frames are owned by a single protection domain, and contiguous virtual allocations are filled sequentially into frame bitmaps. On full occupancy, a single page-table update coalesces 512 4KB base pages into a large-page (2MB) mapping with zero migration cost—minimizing TLB misses while preserving 4KB-granularity demand-paging traffic.

2.1.2 Virtual Memory Stitching and Fragmentation Reduction

GMLake introduces Virtual Memory Stitching (VMS), enabling the assembly of non-contiguous physical blocks into a logically contiguous virtual region via low-level CUDA VM APIs (cuMemAddressReserve, cuMemCreate, cuMemMap, cuMemSetAccess) (Guo et al., 2024). Allocator logic splits, merges, and caches “primitive” and “stitched” blocks, maintaining