Search Knowledge

© 2026 LIBREUNI PROJECT

Page 12 of 29

Address Spaces and Translation

Derive virtual-address translation from relocation and protection requirements, then use mappings to construct sparse, isolated, and intentionally shared address spaces.

Lesson briefVirtual memory · 5 h 30 min · 4 outcomes

Required knowledge

  • C pointers, arrays, object lifetime, and hexadecimal arithmetic
  • Physical memory, CPU privilege modes, and load/store execution
  • Integer division, remainders, powers of two, and basic invariants

Learning outcomes

  • Distinguish a virtual address, a physical address, and the address-space context that gives a virtual address meaning.
  • Derive and execute base-and-bound and paged translations, including bounds, permissions, offsets, and fault conditions.
  • Construct an address-space layout that combines private, shared, sparse, and guard mappings without violating isolation.
  • Diagnose overflow, fragmentation, aliasing, and stale-authority failures from an unfamiliar translation trace.

Assessment target

Given two processes, a finite physical-memory map, and an unseen translation scheme, derive the translation function, trace valid and invalid accesses, design one intentional shared mapping, quantify fragmentation, and defend the isolation invariant against an overflow or aliasing attack.

Scope boundary

  • Multilevel page-table encoding, TLB timing, replacement policy, NUMA placement, and speculative side channels require separate mechanism analyses.
  • Variable-sized segmentation and historical x86 segmentation modes are not surveyed.

Two independently linked programs both place code at virtual address 0x1000, grow a heap upward, and grow a stack downward. Loading both programs into one physical memory creates an immediate conflict if an address names a physical byte directly. Relocating every pointer when a process moves is not sufficient: pointers can be stored in files, registers, data structures, or generated while the program runs. A faulty process could also manufacture the physical address of another process’s data.

The missing mechanism is a controlled naming layer. A process issues a virtual address; the processor interprets that address through the process’s current address space; translation either yields an authorized physical address or raises an exception before the access completes.

Isolation invariant. A user-mode memory access may affect or reveal a physical byte only if the active address space contains a mapping for the requested virtual address and that mapping authorizes the requested operation.

The invariant contains three independent questions: Which address-space context is active? Which physical storage does the name select? Which operations does the mapping permit? Omitting any one turns translation into relocation without protection.

Names require a context

A virtual address is not globally meaningful. Model an address space as a partial function

TA:(v,a)↦{(p,allow)if address space A maps v and permits access a,faultotherwise.T_A : (v, a) \mapsto \begin{cases} (p, \text{allow}) & \text{if address space } A \text{ maps }v\text{ and permits access }a,\\ \text{fault} & \text{otherwise.} \end{cases}

Here vv is a virtual byte address, a∈{read,write,execute}a \in \{\text{read},\text{write},\text{execute}\} and pp is a physical byte address. The same bit pattern can produce different results under different contexts:

Context and accessMappingResult
process A reads 0x1800private data → frame 9, read/writephysical byte in frame 9
process B reads 0x1800private data → frame 27, read/writea different physical byte
process B executes 0x1800frame 27, read/write onlyprotection fault
process C reads 0x1800no mappingtranslation fault

Two virtual names may also intentionally denote one physical object. Shared libraries, shared-memory regions, and file-backed mappings rely on this aliasing. Isolation therefore does not require one-to-one translation. It requires that every alias be deliberate, authorized, and revoked safely.

Code
title "Virtual names, private frames, and an intentional alias"
rectangle "Process A address space" as A
rectangle "A: 0x1000–0x1fff\nread + execute" as AC
rectangle "A: 0x4000–0x4fff\nread + write" as AD
rectangle "Process B address space" as B
rectangle "B: 0x7000–0x7fff\nread + execute" as BC
rectangle "B: 0x4000–0x4fff\nread + write" as BD
rectangle "Physical frame 12\nshared code" as F12
rectangle "Physical frame 31\nA private data" as F31
rectangle "Physical frame 44\nB private data" as F44
A --> AC : owns mapping
A --> AD : owns mapping
B --> BC : owns mapping
B --> BD : owns mapping
AC --> F12 : translate
BC --> F12 : translate
AD --> F31 : translate
BD --> F44 : translate
Virtual names, private frames, and an intentional aliasVirtual names, private frames, and an intentional aliasProcess A address spaceA: 0x1000-0x1fffread + executeA: 0x4000-0x4fffread + writeProcess B address spaceB: 0x7000-0x7fffread + executeB: 0x4000-0x4fffread + writePhysical frame 12shared codePhysical frame 31A private dataPhysical frame 44B private dataowns mappingowns mappingowns mappingowns mappingtranslatetranslatetranslatetranslate

Retrieval — close the prose before answering. Why is the pair (virtual address, process identity) still insufficient to decide whether a store may proceed?

Reveal the diagnostic answerExpand

Identity and virtual address select a candidate mapping, but authority is operation-specific. A read-only code mapping may authorize a load and instruction fetch while rejecting a store. An answer that mentions only different physical locations has recovered relocation but not protection.

Address translation and operation authority

0 / 4 answered

Evaluate each statement regarding virtual address translation, memory isolation, and paging invariants:

Classify each option as correct or incorrect, or leave uncertain options unanswered (“I don't know”) and verify at any time.

1
A valid page table entry always guarantees that user-mode stores will succeed without raising a CPU fault.
2
Address translation checks operation permissions so read-only segments permit loads but trigger faults on stores.
3
Two distinct virtual page numbers in different address spaces can intentionally map to the same physical page frame.
4
Virtual address translation alters the lower page offset bits when mapping a virtual page to its physical frame.

Relocation by base and bound

The smallest useful translation mechanism assigns one contiguous physical region to a process. Let BB be the physical base and LL the length of the process’s virtual region. For an unsigned virtual address vv

T(v)={B+v0≤v<L,faultotherwise.T(v) = \begin{cases} B+v & 0 \le v < L,\\ \text{fault} & \text{otherwise.} \end{cases}

The bounds check must occur before the addition. If a fixed-width addition wraps, checking the physical result can authorize an address outside the allocated region.

Worked trace: a valid load and an overflow attack

Assume 16-bit addresses, B = 0x4000, and L = 0x1800.

  1. A load from v = 0x02F0 passes because 0x02F0 < 0x1800.
  2. Translation yields 0x4000 + 0x02F0 = 0x42F0.
  3. A load from v = 0xF100 fails the virtual bound and must fault.

An incorrect implementation first computes a 16-bit sum and then tests whether the result lies below B + L:

// Incorrect: wrapped addition occurs before authority is established.
uint16_t physical = base + virtual;
if (physical < base + length)
    return physical;

For base = 0x4000 and virtual = 0xF100, the sum wraps to 0x3100. A weak upper-bound-only test may accept the wrapped result. The safe form compares virtual with length, using an unsigned type whose width is part of the machine contract, and adds only after acceptance.

Worked trace: relocation without pointer rewriting

Process P executes a load from virtual 0x0710 while B = 0x2000; the physical access is 0x2710. The scheduler later runs P from a region beginning at 0x9000. Updating the privileged base register changes the same instruction’s physical access to 0x9710. P’s register and memory values remain virtual; no embedded pointer is rewritten.

Base-and-bound provides cheap relocation, but it imposes one contiguous extent. A 1 MiB heap and a 1 MiB stack separated by 1 GiB of unused virtual space either reserve that physical hole or cannot be represented by one pair. Growing the region can require physical relocation. Sharing one read-only library while keeping data private also needs more than one extent.

Application — execute before revealing. A 20-bit machine gives a process B = 0x62000 and L = 0x2A000. Classify virtual accesses 0x01FFC, 0x29FFF, and 0x2A000; compute every valid physical address.

Reveal the trace and error diagnosesExpand
  • 0x01FFC < 0x2A000, so it maps to 0x63FFC.
  • 0x29FFF < 0x2A000, so it maps to 0x8BFFF, the final byte in the region.
  • 0x2A000 equals the length and is outside the half-open interval [0, L); it faults.

Accepting the last address indicates an inclusive-upper-bound error. Subtracting one from every physical result indicates confusion between a region length and its final index.

Paging derives from sparse allocation

Paging divides virtual memory and physical memory into equal-size units. Let page size P=2kP=2^k bytes. For virtual address vv

VPN⁡(v)=⌊vP⌋,offset⁡(v)=v mod P.\operatorname{VPN}(v)=\left\lfloor \frac{v}{P}\right\rfloor, \qquad \operatorname{offset}(v)=v\bmod P.

A page-table entry maps a virtual page number (VPN) to a physical frame number (PFN) and carries control state such as validity and permissions. If the entry is valid and authorizes the access,

p=PFN⁡(VPN⁡(v))⋅P+offset⁡(v).p=\operatorname{PFN}(\operatorname{VPN}(v))\cdot P+\operatorname{offset}(v).

The offset is preserved because pages and frames have the same size. Translation changes the container, not the byte’s position within that container.

Worked trace: noncontiguous physical placement

Take a 16-bit virtual address, 1 KiB pages, and these entries:

VPNPFNPermissionPresent
0x000x12read + executeyes
0x010x2Bread + writeyes
0x02——no
0x3F0x07read + writeyes

Because P=1024=210P=1024=2^{10} the low ten bits are the offset.

  • Virtual 0x0634 has VPN 1 and offset 0x234. A read maps to 0x2B × 0x400 + 0x234 = 0xAE34.
  • Executing 0x0634 reaches a present page but violates its read + write permission; the result is a protection fault, not a translation.
  • Reading 0x0A10 selects VPN 2, whose entry is absent; the result is a not-present fault.
  • Writing 0xFE20 selects VPN 0x3F, offset 0x220, and maps to 0x1E20.

The final case demonstrates non-monotonic placement: a high virtual address can map to a low physical frame. Sorting virtual addresses does not sort physical addresses.

Fragmentation is relocated, not eliminated

Paging removes external fragmentation from allocation of individual frames: any free frame can hold any virtual page. It introduces internal fragmentation in the partially used final page of an allocation. An object of nn bytes consumes

⌈nP⌉P\left\lceil\frac{n}{P}\right\rceil P

bytes of mapped capacity, wasting that quantity minus nn when it cannot share the final page.

A 10,500-byte isolated region with 4 KiB pages needs three pages: 12,288 bytes, of which 1,788 bytes are unused. The waste is a property of allocation granularity, not evidence that those physical frames are adjacent.

Transfer — change the granularity. The same 10,500-byte region uses 2 KiB pages. Compute mapped capacity and waste, then state one cost that the smaller pages increase.

Reveal the calculation and trade-offExpand

Six 2 KiB pages provide 12,288 bytes, so this particular size still wastes 1,788 bytes. Smaller pages do not guarantee less waste for every object. They increase the number of mappings and therefore page-table memory and translation-cache pressure. A response that claims the waste must halve has treated an average tendency as a per-object theorem.

Constructing a process address space

An address space is a set of regions with different backing objects and authorities, not a promise that every address between the lowest and highest mapping is valid.

RegionTypical backingInitial materializationCommon authority
executable textexecutable filefile page on demand or at loadread + execute
read-only dataexecutable filefile pageread
writable dataprivate file imagefile page, then private on writeread + write
heapanonymous memoryzero-filled page on first touchread + write
memory-mapped filefile objectfile page on demandmapping-dependent
guard intervalnoneneverno access
user stackanonymous memorypolicy-bounded growthread + write, non-execute

The address-space manager records region-level intent; page tables record the translations currently installed. A valid region need not have a resident page yet. Conversely, a page-table entry left behind after its region is removed is stale authority.

Code
title "Sparse process address space"
rectangle "high virtual addresses" as HI
rectangle "trampoline / controlled kernel entry\nnot user-writable" as TR
rectangle "guard page\nno mapping" as GUARD1
rectangle "user stack\nRW, non-executable\ngrows within policy" as STACK
rectangle "unmapped interval" as HOLE
rectangle "mapped file\nprivate or shared" as MMAP
rectangle "heap\nRW anonymous" as HEAP
rectangle "guard interval" as GUARD2
rectangle "text + read-only data\nR-X / R--" as TEXT
rectangle "low virtual addresses" as LO
HI -down-> TR
TR -down-> GUARD1
GUARD1 -down-> STACK
STACK -down-> HOLE
HOLE -down-> MMAP
MMAP -down-> HEAP
HEAP -down-> GUARD2
GUARD2 -down-> TEXT
TEXT -down-> LO
Sparse process address spaceSparse process address spacehigh virtual addressestrampoline / controlled kernelentrynot user-writableguard pageno mappinguser stackRW, non-executablegrows within policyunmapped intervalmapped fileprivate or sharedheapRW anonymousguard intervaltext + read-only dataR-X / R--low virtual addresses

Worked trace: stack growth or invalid access?

Assume a stack region may grow into one designated unmapped page below its current lowest mapped page, down to a fixed maximum size. Its current mapped interval is [0x7FFF_D000, 0x8000_0000); [0x7FFF_C000, 0x7FFF_D000) is the current growth page, and the page below that is a non-growable guard.

  1. A store at 0x7FFF_CFF8 lands eight bytes below the current mapping, in the permitted one-page growth interval. The kernel may allocate a zeroed frame, install a non-executable user mapping, and retry.
  2. A store at 0x7FFE_0000 is far below the growth frontier. Treating every lower address as stack growth would let a stray pointer consume arbitrary memory and collide with another region. The access must fail.
  3. An instruction fetch from 0x7FFF_E100 targets a stack page. Presence is not enough; non-execute authority causes a protection fault.

The growth policy belongs to region metadata. A page-table miss alone cannot distinguish an intentional lazy page from an invalid pointer.

Application — design a map. Two worker processes need private 64 KiB heaps, one 12 KiB read-only lookup table shared at different virtual addresses, and one writable 8 KiB communication ring shared at the same virtual address. Draw the VPN→PFN relations for 4 KiB pages and state the permission invariant for each object.

Reveal an architectural verification modelExpand

A complete design has sixteen distinct heap frames per process, three table frames mapped into both address spaces without write permission, and two ring frames mapped read/write into both address spaces. The virtual addresses of the table may differ because sharing is defined by common PFNs, not common VPNs. The ring’s equal virtual address is a convenience, not a requirement. Complete verification requires separate PTE permissions in each address space and an explicit rule that no private heap PFN appears in the other process’s user mappings.

Common defects:

  • allocating six table frames loses sharing;
  • mapping the table writable loses its integrity contract;
  • requiring equal VPNs confuses virtual naming with physical identity;
  • sharing page-table entries between processes without context separation can expose unrelated mappings.

Boundary failures and adversarial cases

A pointer is not a physical address

Passing a user pointer to a device for direct memory access without pinning and mapping its pages gives the device an address in the wrong namespace. A device may use a bus or I/O virtual address, and the process mapping may change while the operation is in flight. Translation must occur in the correct agent’s context.

Presence does not imply authority

Marking code present and user-accessible while accidentally retaining write permission defeats write-xor-execute policy. The access does not fault because the mapping itself grants the wrong authority. Fault-handler testing cannot detect every over-permissive mapping; mapping construction needs invariant checks.

Unmapping is a concurrent revocation

Removing a page-table entry does not prove that no processor can use a cached translation. The kernel must invalidate stale translation state on every relevant processor before reusing the physical frame for a new security domain. Detailed invalidation mechanics are outside this scope, but the authority rule is immediate: frame reuse is forbidden until revocation is globally complete.

Aliases can disagree about policy

Mapping one physical frame writable through one alias and executable through another can defeat a policy checked per mapping. A system that requires write-xor-execute must reason about all aliases to the frame, not each PTE in isolation.

Retrieval plus boundary check. Classify each statement as invariant, common implementation choice, or false claim:

  1. Page translation preserves the offset within a page.
  2. Every process must map its shared library at the same virtual address.
  3. A valid PTE guarantees a user store may proceed.
  4. Any free physical frame can hold a virtual page of the same configured page size.
Reveal classificationsExpand
  1. Invariant for equal-size paging: the mapping substitutes the frame number and preserves the offset.
  2. False claim: different VPNs may map the same library frames; position-independent code makes this practical.
  3. False claim: user/supervisor and read/write/execute permissions still govern the operation.
  4. Implementation property under the stated paging model: equal-size frames eliminate the need for contiguous placement, although devices, huge pages, coloring, or physical constraints may narrow the eligible set.
Section Exercises

Deep Practice

Solve these problems to test and consolidate your understanding. Complete worked solutions and diagnostic hints are available for each problem.

Exercise 4.1.1: Virtual Page Number and Offset Bitwise Decomposition

Verificationapplication

A processor uses 32-bit virtual addresses with a 4 KiB page size 2122^{12} bytes). Given the virtual address 0x0045A8C4, determine:

  1. The page offset in hexadecimal.
  2. The Virtual Page Number (VPN) in hexadecimal.
  3. The resulting 32-bit physical address if the page table maps this VPN to Physical Frame Number (PFN) 0x1B02.
HintExpand

With 4 KiB pages, the lower 12 bits form the offset, while the upper 20 bits form the VPN.

Worked solutionExpand
  1. Page offset: With a 4 KiB page size, the offset width is log⁡2(4096)=12\log_2(4096) = 12 bits (the lowest 3 hex nybbles). For 0x0045A8C4, the lowest 12 bits are 0x8C4.
  2. Virtual Page Number (VPN): Shifting right by 12 bits VA≫12\mathrm{VA} \gg 12 extracts the upper 20 bits: VPN=⌊0x0045A8C4/4096⌋=0x0045A.\mathrm{VPN} = \lfloor \mathtt{0x0045A8C4} / 4096 \rfloor = \mathtt{0x0045A}.
  3. Physical address calculation: Paging preserves the page offset exactly. Substituting PFN 0x1B02 into the upper 20 bits gives: PA=(PFN≪12)∣offset=(0x1B02≪12)∣0x8C4=0x01B028C4.\mathrm{PA} = (\mathrm{PFN} \ll 12) \mid \text{offset} = (\mathtt{0x1B02} \ll 12) \mid \mathtt{0x8C4} = \mathtt{0x01B028C4}.

Exercise 4.1.2: Address Translation under Base-and-Bound Protection Registers

Constructionapplication

A system implements hardware base-and-bound memory relocation. A process is assigned a base register of 0x00300000 and a bound (limit) register of 0x00028000.

  1. Compute the translated physical address for a load instruction at virtual address 0x00014A00.
  2. Determine the hardware response for a load instruction at virtual address 0x00028000.
  3. Explain why the boundary check must use strict inequality v<Boundv < \text{Bound} rather than weak inequality v≤Boundv \le \text{Bound}
HintExpand

The bound defines the total length of the segment, so valid offsets range from 0 to Bound - 1.

Worked solutionExpand
  1. Valid load: The virtual offset v=0x00014A00v = \mathtt{0x00014A00} is strictly less than the bound 0x00028000\mathtt{0x00028000} Hardware translates the address by addition: PA=Base+v=0x00300000+0x00014A00=0x00314A00.\mathrm{PA} = \mathrm{Base} + v = \mathtt{0x00300000} + \mathtt{0x00014A00} = \mathtt{0x00314A00}.
  2. Boundary check: The access at v=0x00028000v = \mathtt{0x00028000} satisfies v=Boundv = \text{Bound} so v≮Boundv \not< \text{Bound} The MMU hardware raises a segmentation fault or memory protection exception prior to executing the bus cycle.
  3. Strict inequality rationale: A segment of length L=BoundL = \text{Bound} bytes occupies offsets 0,1,2,…,L−10, 1, 2, \dots, L - 1 An access at offset LL falls exactly one byte beyond the authorized allocated range. Using v≤Boundv \le \text{Bound} would expose an unallocated or neighboring byte, violating memory isolation.

Exercise 4.1.3: Constructing Dual Virtual Mappings to a Shared Physical Frame

Constructiontransfer

Two processes P1P_1 and P2P_2 share an inter-process communication ring buffer allocated at physical frame 0x04A0. P1P_1 maps the buffer as read-write at virtual page 0x100, while P2P_2 maps the buffer as read-only at virtual page 0x500.

  1. Construct the respective page table entry (PTE) fields (VPN, PFN, Read, Write, User) for both processes.
  2. If P1P_1 writes the value 0xDEADBEEF at virtual address 0x100040, what virtual address does P2P_2 read to observe this update?
  3. What occurs if P2P_2 executes a store instruction to its mapped address?
HintExpand

The two processes use different virtual page numbers that translate to the identical physical frame.

Worked solutionExpand
  1. PTE configuration:
    • For P1P_1 VPN=0x100↦PFN=0x04A0\mathrm{VPN} = \mathtt{0x100} \mapsto \mathrm{PFN} = \mathtt{0x04A0} with permissions R=1,W=1,X=0,U=1\mathrm{R}=1, \mathrm{W}=1, \mathrm{X}=0, \mathrm{U}=1
    • For P2P_2 VPN=0x500↦PFN=0x04A0\mathrm{VPN} = \mathtt{0x500} \mapsto \mathrm{PFN} = \mathtt{0x04A0} with permissions R=1,W=0,X=0,U=1\mathrm{R}=1, \mathrm{W}=0, \mathrm{X}=0, \mathrm{U}=1
  2. Aliased read: The write from P1P_1 occurs at intra-page offset 0x040 (since 0x100040 has VPN 0x100 and offset 0x040), modifying physical address (0x04A0≪12)+0x040=0x004A0040(\mathtt{0x04A0} \ll 12) + \mathtt{0x040} = \mathtt{0x004A0040} To read the same physical byte, P2P_2 accesses VPN 0x500 with the identical offset 0x040: VAP2=(0x500≪12)+0x040=0x00500040.\mathrm{VA}_{P2} = (\mathtt{0x500} \ll 12) + \mathtt{0x040} = \mathtt{0x00500040}.
  3. Protection enforcement: When P2P_2 attempts a store to VAP2\mathrm{VA}_{P2} the MMU validates the operation against P2P_2‘s PTE. Because W=0W = 0 the MMU aborts the store and raises a page-protection fault exception to the kernel, preserving the read-only contract.

Exercise 4.1.4: Isolation Invariant Defense in Sparse Address Space Layouts

Verificationsynthesis

A 64-bit operating system places a 4 KiB non-mapped guard page immediately below each thread stack and immediately above the process heap.

  1. Formulate the isolation invariant that explains how unmapped guard pages detect stack overflow and heap overrun.
  2. Suppose an application bug causes an unchecked pointer increment of 64 KiB in a single step, jumping over the 4 KiB guard page into adjacent valid data. Explain why guard pages cannot prevent this corruption.
HintExpand

A guard page traps accesses whose stride is strictly smaller than the guard page thickness.

Worked solutionExpand
  1. Isolation invariant for guard pages: Let virtual page gg be unmapped valid=0\mathrm{valid} = 0 Any instruction accessing v∈[page_start(g),page_end(g)]v \in [\mathrm{page\_start}(g), \mathrm{page\_end}(g)] immediately triggers an unhandled page fault exception before modifying memory. When stack frames grow sequentially by small increments <4 KiB< 4\text{ KiB} the stack pointer inevitably references page gg on overflow, allowing the kernel to terminate the offending thread or expand the stack safely without silent memory corruption.
  2. Large-stride failure: Guard pages rely on continuous, localized traversal. If an allocation or array access strides by 64 KiB, the calculated target virtual address vtarget=vstack−65536v_{\text{target}} = v_{\text{stack}} - 65536 skips entirely past the 4 KiB range of gg and lands directly on an active, mapped virtual page belonging to another segment. Because vtargetv_{\text{target}} possesses a valid PTE with write permissions, the hardware executes the store without faulting, silently corrupting unrelated data.

Exercise 4.1.5: Contrasting Paging Internal Fragmentation and Contiguous External Fragmentation

Descriptionapplication

Contrast the origin and manifestation of internal fragmentation in fixed-size paging with external fragmentation in variable-size contiguous memory allocation. State why modern operating systems accept internal fragmentation in exchange for eliminating external fragmentation.

HintExpand

Consider unused space inside allocated units versus unallocatable scattered free space between units.

Worked solutionExpand
  • Internal fragmentation: Occurs when memory is allocated in fixed-size discrete units (e.g., 4 KiB pages). If a process requests 5 KiB of heap space, the operating system must allocate two 4 KiB pages (8 KiB total). The remaining 3 KiB within the second page is allocated to the process but unused, representing internal waste. The average internal fragmentation per mapped segment is half a page P/2P/2
  • External fragmentation: Occurs in variable-size contiguous allocation schemes (such as pure segmentation or unpaged physical placement). As processes allocate, deallocate, and terminate at varying lifetimes, free physical memory becomes checkerboarded into small non-contiguous blocks. Total free memory may exceed a request, but no single contiguous chunk is large enough to satisfy it, requiring expensive memory compaction.
  • Architectural tradeoff: Paging completely eliminates external fragmentation at the physical level because any free physical frame can satisfy any virtual page request, regardless of physical location. Operating systems accept bounded internal fragmentation (at most a fraction of a page per region) because it avoids compaction overhead and enables non-contiguous, demand-paged allocation.

References & Further Reading