External memory fragmentation

External memory fragmentation occurs when free capacity is divided among separated blocks so that a request for one sufficiently large contiguous block cannot be satisfied. It concerns the layout available to a particular allocator, rather than only the total free computer memory. In a fixed nonmoving pool, occupied blocks can separate free intervals that would have been useful if adjacent.^[ref]

For an original example, a104-byte pool contains free blocks of24,40 and16 bytes, separated by occupied blocks of16 and8 bytes. Total free capacity is80 bytes, but the largest free memory block is only40 bytes. A contiguous48-byte request therefore fails in this closed pool, assuming live blocks cannot move and ignoring metadata/alignment overhead.

Memory block coalescing merges adjacent free intervals. If the occupied16-byte block between the first two holes is released, the neighboring24,16 and40-byte intervals can form one80-byte free block. Coalescing does not merge across a still-occupied interval. Memory compaction instead moves live data to collect free space, which requires a way to preserve or update references. An allocator generally cannot relocate an arbitrary live block behind an unchanged C programming language pointer.^[ref]

The illustrative measure $1-L_{\max }/F_{\mathrm{free}}$ equals0.5 for the original layout, but it does not say that half the memory is universally unusable: requests no larger than16 bytes can still fit. Actual allocation success depends on request sizes and allocator policy. Internal fragmentation instead concerns unused space inside allocated units.

The contiguity requirement also needs its address space specified. A virtually contiguous block can use noncontiguous physical page frames through virtual memory. Physical page fragmentation and an application's heap holes are therefore different allocation-layer questions. Changing the physical mapping alone does not merge separated virtual holes around live objects.

The largest free memory block is the longest contiguous free region available within a specified allocation pool and address space. If free-block lengths are $s_1,\dots ,s_n$,For an empty free-block set, take $L_{\max }=0$. The largest block and total free capacity answer different questions: a contiguous request can fail even when $F_{\mathrm{free}}$ exceeds its size. This is the central layout issue in external memory fragmentation.^[ref]

For free lengths24,40 and16 bytes, $F_{\mathrm{free}}=80$ bytes and $L_{\max }=40$ bytes. A48-byte contiguous request fails in that fixed, nonmoving pool before metadata and memory alignment are considered. Coalescing an additional freed separator can increase $L_{\max }$ without requiring the allocator to obtain another region from the operating system.

Raw extent length can overstate payload capacity. For a block $[a,b)$, an illustrative header requirement $h$ and payload alignment $A$, choose aligned payload startThe aligned free-block capacity in this simple layout is $\max (b-p,0)$. A32-byte block starting at0 with an8-byte header and16-byte payload alignment has $p=16$ and only16 bytes of payload capacity. A24-byte payload therefore fails despite a raw32-byte extent. Actual allocator layouts can impose further constraints.

The quantity also depends on the allocation layer. A large virtually contiguous block need not occupy contiguous physical page frames. Comparing $L_{\max }$ values without specifying virtual versus physical space, allocator pool and usable payload convention can therefore mix distinct fragmentation problems.

Aligned free-block capacity is the usable payload that a particular free extent can supply after meeting memory alignment and metadata requirements. It differs from the raw extent length and from the largest free memory block. For an illustrative block $[a,b)$, header requirement $h$ and payload alignment $A>0$, the first permissible payload start isIf the allocator reserves no trailer or additional rounding, usable payload capacity is $\max (b-p,0)$. This formula belongs to the stated layout; it is not a universal allocator ABI.

For a free interval $[3,67)$ in byte offsets, an8-byte header and16-byte alignment give $p=16$. The raw64-byte extent then has51 bytes after the aligned start. Allocation alignment padding is $p-(a+h)=5$ bytes, in addition to the8-byte header. A48-byte payload fits this model, whereas a52-byte payload does not.

If allocated payload size must also be rounded to a multiple $q$, a requested size $R$ needs $q\lceil R/q\rceil$ usable bytes. For $q=8$ in the same example, the largest such payload is48 bytes: a49-byte request rounds to56 and fails. Header information and allocation granularity can therefore change the answer even when the alignment condition itself is satisfied.^[ref]

For integer addresses, the padding before the payload lies between0 and $A-1$ bytes. Splitting a chosen block can introduce another constraint: a leftover interval may be too small to hold a free record. A capacity calculation must consequently identify the actual header, alignment, rounding and remainder conventions rather than treating every raw free byte as payload.

Allocation alignment padding is the unused space inserted before an allocated payload so its address meets memory alignment. If a free extent starts at integer byte address $a$, an allocation header consumes $h$ bytes, and payload addresses must be multiples of positive integer $A$, the earliest permitted address and its padding areEquivalently, $P$ is the least nonnegative residue of $-(a+h)$ modulo $A$. The alignment padding bound is $0\le P\le A-1$. Already aligned payload starts have zero padding; adding a whole extra alignment unit in that case would waste space unnecessarily.

For an original example, let a free extent be $[3,67)$, with $h=8$ and $A=16$. Then $a+h=11$, $p=16$ and $P=5$ bytes. A24-byte payload ends at40, so the used prefix occupies37 bytes:8 for the header,5 for padding and24 for data. The remaining interval $[40,67)$ has27 bytes before other block-rounding or minimum free-block size requirements are applied. This accounting distinguishes padding from header storage and from payload-size rounding.

The same header and alignment can produce different padding at another address: $a=8$ gives $a+h=16$ and $P=0$. If the residues of $a+h$ were uniformly distributed over all16 possibilities, the mean padding would be7.5 bytes, obtained by averaging0 through15. An actual allocator can constrain its block starts, so that distribution is an explicit model assumption rather than a measured universal overhead.

Aligned free-block capacity must deduct this padding when testing whether a request fits. Allocation alignment padding can thus make two equally long free extents offer different usable capacities. OSTEP's separation of the allocated payload from its bookkeeping header is the basic layout issue behind this calculation; alignment adds the stated address constraint.^[ref]

The alignment padding bound limits the extra bytes needed to move an integer payload address to the next permitted memory alignment. Let $x=a+h$ be the first address after an allocated header, and let alignment require a multiple of a positive integer $A$. Withthe exact bound is $0\le P\le A-1$. It applies to the earliest aligned start, not to arbitrary extra space an allocator may choose to reserve.

To prove the bound, write $k=\lceil x/A\rceil$. The ceiling function gives $k-1<x/A\le k$, hence $0\le Ak-x<A$. Since $P=Ak-x$ is an integer number of bytes, $P\le A-1$. The endpoints can occur: an already aligned $x$ gives zero padding, while $x$ one byte beyond an aligned address gives $A-1$. This is also the statement that $P$ is the least nonnegative residue of $-x$ in modular arithmetic.

For an original example, $A=16$, header size $h=8$ and block start $a=9$ give $x=17$, $p=32$ and $P=15$. The worst-case bound is attained. Starting at $a=8$ instead gives $x=16$ and $P=0$. Identical header and payload sizes can therefore incur different allocation alignment padding at different addresses.

A sufficient address-independent reservation for a payload of $R$ bytes is $h+(A-1)+R$, before any trailer, block rounding or minimum free-block size constraint. For $h=8$, $A=16$ and $R=24$,47 bytes suffice under precisely that layout. A known starting address can require less: $a=3$ needs5 bytes of padding and a37-byte used prefix. Separating the payload from its metadata is the bookkeeping principle illustrated in OSTEP; the bound adds a worst-case alignment allowance.^[ref]

These inequalities concern mathematical integers. An implementation using bounded address arithmetic must separately prevent integer overflow when adding the header, padding allowance or payload. A wrapped sum cannot be justified by a correct bound over unbounded integers.