Fact-checked by Grok 2 weeks ago

Memory address

A memory address is a unique numerical identifier that specifies a particular location in a computer's main memory, where data or instructions are stored and retrieved.^[1] In computer architecture, these addresses enable the central processing unit (CPU) to access specific bytes within the memory hierarchy, typically organized as a linear sequence of addressable units.^[2] Addresses are fundamentally binary values, though they are often represented in hexadecimal notation for human readability and debugging purposes.^[3] During program execution, the CPU transmits memory addresses over the address bus to memory modules, indicating the exact location for reading or writing operations.^[1] Compilers or interpreters map variable names in source code to these hardware-defined memory addresses, facilitating the storage and manipulation of data.^[4] The size of a memory address determines the maximum addressable memory space; for instance, a 32-bit address supports up to 4 gigabytes of memory, while 64-bit addresses accommodate vastly larger capacities in contemporary systems.^[5] Modern operating systems employ virtual memory addressing to abstract physical memory limitations, where virtual addresses generated by programs are translated to physical addresses by the memory management unit (MMU).^[6] This mechanism enhances security through address space isolation, prevents direct access to physical hardware, and supports features like paging and segmentation for efficient memory allocation.^[6] Pointers, as variables that hold memory addresses, play a crucial role in dynamic memory management, allowing indirect access to data structures and enabling advanced programming techniques such as linked lists and recursion.^[7]

Fundamentals

Definition and Role

A memory address is a unique numerical identifier that specifies a particular byte or word within a computer's memory, enabling the central processing unit (CPU) to locate and access stored data or instructions.^[8] This identifier functions as a reference point in the memory hierarchy, allowing precise targeting of storage locations for efficient retrieval and manipulation.^[9] The concept of memory addressing emerged in the context of the von Neumann architecture, first outlined in a 1945 report that proposed a stored-program design where both instructions and data reside in the same memory unit, differentiated solely by their addresses.^[10] In this foundational model, addresses serve to organize memory as a linear array of cells, each capable of holding fixed-size units of information, thereby supporting the sequential execution of programs.^[11] In computing, memory addresses are essential for random access memory (RAM) operations, which underpin program execution and data management by permitting direct, non-sequential access to any memory location. Key operations facilitated by addresses include loading, where data is fetched from a specified address into a CPU register for processing; storing, which writes data from a register back to the designated address; and jumping, a control flow mechanism that redirects program execution to an instruction located at a particular address.^[12]

Address Representation

Memory addresses are fundamentally represented as binary numbers, consisting of a fixed number of bits that uniquely identify locations in a computer's memory space. In binary form, an address is a string of 0s and 1s; for instance, a 32-bit address spans 32 bits, allowing for $2^{32} distinct locations. This binary representation directly corresponds to the hardware's addressing mechanism, where each bit position contributes to the positional value in base-2.^[13]^[14] For human readability and compactness, addresses are commonly displayed and manipulated in hexadecimal notation, where each group of four binary bits (a nibble) is represented by a single hexadecimal digit ranging from 0-9 or A-F. This format condenses an 8-bit byte into two hexadecimal digits, making it efficient for representing memory locations; for example, the binary address 11111111 (255 in decimal) is written as 0xFF. Hexadecimal is the standard in programming and debugging tools because it aligns closely with binary while being more concise than decimal.^[15]^[13] The width of an address, measured in bits, determines the total addressable memory in a system, calculated as $2^n bytes, where n is the number of address bits. A 32-bit address width supports up to 4 GB ($2^{32} = 4,294,967,296 bytes) of memory, sufficient for many early personal computers but limiting for modern applications. In contrast, a 64-bit address width theoretically enables $2^{64} bytes, or approximately 18 exabytes, though practical implementations often use fewer bits (e.g., 48 bits) due to hardware constraints. This scaling is crucial for handling large datasets in contemporary systems.^[14]^[16] Memory addresses are typically treated as unsigned integers, interpreting the full bit range as positive values from 0 to $2^n - 1, which aligns with their role in indexing non-negative locations. However, in certain architectures, signed representations come into play for offset calculations in addressing modes, where negative offsets allow relative addressing backward from a base register (e.g., for accessing local variables or loop counters). This signed usage does not alter the absolute address itself but affects computations during address generation.^[16]^[17]^[18] When storing multi-byte addresses in memory—such as in pointer variables or data structures—the system's endianness dictates the byte order. In big-endian architectures, the most significant byte (MSB) is stored at the lowest memory address, mimicking human reading order (e.g., the number 0x12345678 has 0x12 at the base address). Conversely, little-endian systems, common in x86 processors, store the least significant byte (LSB) first (e.g., 0x78 at the base address). This ordering impacts address portability across systems and requires careful handling in network protocols or cross-platform code.^[19]

Address Types

Physical Addresses

A physical address is a hardware-specific identifier that corresponds directly to an actual location in the main memory, such as RAM, where data or instructions are stored.^[20] It represents the real, tangible position in the memory hardware, distinct from any software-generated abstractions.^[21] Physical addresses are generated by the memory management unit (MMU), a hardware component in the CPU that maps higher-level addresses to these concrete locations after any necessary translation.^[20] The range of possible physical addresses is constrained by the system's installed RAM size and the width of the address bus; for instance, a system with 8 GB of RAM typically utilizes up to 33 bits for addressing, as 2^33 bytes equals 8 GB.^[21] To access memory, the CPU transmits the physical address over the address bus to the memory controller, which decodes it into components like bank, row, and column selectors for DRAM chips, enabling direct hardware-level read or write operations without intervening abstraction layers.^[22] This mapping ensures precise targeting of storage cells in the DRAM array via signals such as row address strobe (RAS) and column address strobe (CAS).^[22] Physical addresses are inherently limited by the fixed hardware configuration, such as the number of address pins on the processor and the total capacity of installed RAM modules, which cannot be expanded without physical upgrades.^[21] Additionally, physical memory allocation is susceptible to fragmentation, where free memory becomes scattered into non-contiguous blocks due to repeated allocations and deallocations, complicating the provision of large contiguous regions needed for optimizations like huge pages or power-saving modes in modern DRAM.^[23] In contrast to virtual addresses, physical addresses provide no process isolation or relocation flexibility.^[20]

Virtual Addresses

A virtual address is an identifier generated by software, such as a program or operating system, to reference a location within a process's logical address space, independent of the underlying physical memory layout. This abstraction allows each process to operate as if it has exclusive access to a dedicated, contiguous memory region, typically starting from address 0x00000000 and extending to the maximum size defined by the system's addressing architecture, such as 4 GB for 32-bit systems.^[24]^[25] The primary purpose of virtual addresses is to provide memory protection, enable efficient sharing of physical resources among multiple processes, and create the illusion of a large, contiguous memory space that exceeds available physical RAM. By isolating each process's address space, virtual addressing prevents unauthorized access between processes, enhancing system security and stability. Additionally, it supports mechanisms like demand paging, where only actively needed portions of a process are loaded into physical memory, optimizing resource utilization.^[26] Virtual addresses are generated during the compilation and linking phases of program development, where the compiler assigns relative offsets within the program's code, data, and stack segments to form a complete address space for the process. Upon execution, the operating system assigns this virtual address space to the process, ensuring isolation from other processes' spaces. In systems like Multics, this generation was foundational to supporting multiprogramming environments with dynamic memory allocation.^[24]^[27] Key advantages of virtual addresses include simplifying software development by abstracting away physical memory constraints, such as fragmentation or limited capacity, thereby allowing programmers to focus on logical memory needs without hardware-specific optimizations. This approach also facilitates portability across different hardware platforms and supports advanced features like memory-mapped files and shared libraries. Virtual addresses are translated to physical addresses through hardware mechanisms like the memory management unit, a process detailed in subsequent sections on address resolution.^[26]^[28]

Address Resolution

Translation Mechanisms

Address translation is the process by which virtual addresses generated by programs are mapped to physical addresses in main memory, enabling isolation, protection, and efficient memory utilization. This conversion is primarily handled by the Memory Management Unit (MMU), a hardware component that uses data structures such as page tables for paging or segment descriptors for segmentation to perform the mapping. The MMU intercepts every memory access, translating the virtual address to a physical one before forwarding it to the memory system, which ensures that processes operate within their allocated memory regions without interfering with others.^[29]^[30] In paging systems, memory is partitioned into fixed-size units called pages, typically 4 KB in size, to simplify allocation and management. A virtual address is divided into two parts: the virtual page number (VPN), which identifies the page, and the page offset, which specifies the byte within the page. The VPN is computed as V = \left\lfloor \frac{\text{virtual address}}{\text{page size}} \right\rfloor, and it serves as an index into a page table that maps the VPN to a physical frame number (PFN). The resulting physical address is then PFN × page size + offset. To support large address spaces without excessive memory overhead, multi-level page tables are employed, where the VPN is split across multiple levels (e.g., page directory and page table indices) for hierarchical lookup, reducing the size of each table while covering vast virtual spaces.^[30]^[31]^[32] Segmentation provides an alternative mechanism where memory is organized into variable-sized segments, each representing logical units such as code, data, or stack sections. A virtual address consists of a segment selector and an offset; translation adds the base address stored in a segment register (or descriptor table) to the offset, yielding the physical address, while bounds checks ensure the offset does not exceed the segment's limit. This approach allows flexible allocation aligned with program structure but can lead to external fragmentation due to varying segment sizes.^[33]^[34]^[29] To mitigate the latency of table lookups, which can involve multiple memory accesses, the Translation Lookaside Buffer (TLB) acts as a small, fast hardware cache holding recent virtual-to-physical mappings. On a TLB hit, translation completes in a single cycle; misses trigger a page table walk, incurring significant delays that can degrade overall system performance if hit rates fall below 99% in typical workloads. Modern processors employ multi-level TLBs and prefetching techniques to boost coverage and hit rates.^[35]^[36]^[37] During context switching, when the operating system changes the active process, the MMU loads a new set of translation structures, necessitating TLB flushing or invalidation to prevent stale entries from the previous process's address space from causing incorrect mappings or security violations. This operation, often implemented via inter-processor interrupts in multiprocessor systems, ensures address space isolation but introduces overhead, prompting optimizations like process-tagged TLB entries to avoid full flushes. The translated physical address ultimately determines the location in physical memory where data is read or written.^[38]^[39]^[40]

Unit of Resolution

In computer architecture, the unit of resolution refers to the smallest addressable element in memory, which determines the granularity of data access. Most modern systems are byte-addressable, where each individual byte (8 bits) has a unique memory address, allowing precise access to sub-word portions of data.^[41] This design supports flexible handling of variable-sized data types and is standard in architectures like x86-64 and ARM.^[42] In contrast, older systems were often word-addressable, where the smallest unit is a multi-bit word, such as the 12-bit words in the PDP-8 minicomputer or the 64-bit words in the Cray-1 supercomputer, requiring accesses to entire words rather than individual bytes.^[43]^[44] The CPU's word size, typically 32 or 64 bits in contemporary processors, influences access efficiency but does not alter the underlying address granularity in byte-addressable systems. For instance, when accessing a full word in a byte-addressable memory, the address increments by the word size in bytes—such as 8 bytes (2³) for a 64-bit word—to reach the next aligned word.

\text{Address increment for next word} = \text{word size in bytes}

This ensures that multi-byte data structures are fetched efficiently without partial byte overlaps, though the total number of addressable units depends on the address width (e.g., 64 bits allowing up to 2⁶⁴ bytes).^[41]^[45] Alignment requirements further impact resolution by mandating that data accesses start at addresses that are multiples of the data type's size to avoid penalties. Unaligned accesses, such as loading a 4-byte integer from an odd-byte boundary, can incur performance penalties on certain architectures; however, modern x86 processors handle them efficiently with minimal overhead, while stricter platforms like older ARM or SPARC may trap or slow down significantly.^[46] Compilers often insert padding bytes to enforce alignment, optimizing for the native word size. Data types are sized relative to the word to facilitate efficient processing; for example, in a 64-bit system, a 32-bit integer occupies 4 bytes, a single-precision float uses 4 bytes, and a double-precision float spans 8 bytes, all addressable at byte granularity but ideally aligned to their size for optimal performance.^[47]^[48] This sizing allows sub-word operations without wasting address space, though it requires careful management to prevent alignment issues.

Memory Organization

Address Spaces

In computer architecture, an address space refers to the range of addresses available to a process for referencing memory locations, serving as an abstraction that provides each program with a private view of memory.^[49] This space can be structured as a contiguous range, such as from 0 to $2^{32} - 1 in typical 32-bit systems, encompassing 4 gigabytes of potential addresses.^[50] Alternatively, it may employ a segmented layout to organize different regions logically.^[49] The layout of an address space commonly divides into user space and kernel space to ensure isolation and security. User space occupies the lower portion of the address range, accessible only by the process, while kernel space resides in the upper portion, shared across processes and reserved for operating system operations.^[51] Within user space, key segments include the code (text) segment at lower addresses for executable instructions, followed by the data segment, the heap for dynamic allocations that grows upward toward higher addresses, and the stack at the high end that grows downward to accommodate function calls and local variables.^[49]^[52] This opposing growth direction between heap and stack helps prevent collisions as memory usage expands.^[49] In 64-bit systems like Linux on x86-64, the virtual address space per process is typically 48-bit canonical addresses with 4-level paging, yielding a total of 256 terabytes, with user space allocated 128 terabytes (from 0 to $2^{47} - 1) and kernel space the remaining 128 terabytes starting at higher addresses. Support for 5-level paging, available since Linux kernel 4.15 (as of 2025), extends this to 57-bit virtual addresses (128 pebibytes total), with user space up to 64 pebibytes (0 to $2^{56} - 1).^[53] These virtual addresses within the space are mapped to physical memory via hardware mechanisms such as page tables. To optimize resource utilization, operating systems like Linux employ memory overcommitment, permitting processes to allocate virtual memory exceeding available physical RAM by assuming not all pages will be accessed simultaneously; excess demand is handled through swapping to disk or the out-of-memory killer if necessary.^[54] This approach enhances efficiency but requires careful configuration to avoid system instability.^[54]

Location Contents

Memory addresses in computer systems hold various types of contents essential for program execution and data management. Primarily, these include machine code instructions, which are binary representations of operations fetched and executed by the processor. Data such as variables and arrays occupy other addresses, representing the operands and results processed during computation. Additionally, metadata like pointers—values that store other memory addresses—reside at specific locations to facilitate indirect referencing and dynamic structures.^[55]^[56]^[55] The volatility of contents at memory addresses varies by the underlying hardware. In random access memory (RAM), contents are temporary and volatile, meaning they are lost when power is removed, requiring reloading upon system restart. In contrast, read-only memory (ROM) stores non-volatile contents that persist without power, typically holding firmware or boot instructions.^[57]^[58] Access patterns to memory contents are governed by protection mechanisms to ensure system integrity. Instructions in code segments are often designated as read-only to prevent modification during execution, while data areas support read-write access for updates. Some architectures enforce execute-only permissions on instruction regions, restricting reads or writes to mitigate security risks like code injection.^[59]^[60]^[59] Pointers enable self-referential structures by storing addresses that point to other locations, forming chains like linked lists where each node contains data and a pointer to the next node. This allows dynamic allocation and traversal without fixed-size arrays, with each pointer value acting as a reference within the broader address space.^[61]^[62]

Addressing Techniques

Common Schemes

Common schemes for specifying memory addresses in computer architectures provide the foundational mechanisms by which instructions reference operands in memory. These schemes balance simplicity, flexibility, and efficiency, allowing processors to access data without excessive complexity in instruction encoding. Direct addressing, immediate addressing, relative addressing, and base-register addressing represent the most prevalent approaches, each suited to different use cases in program execution.^[63] In direct addressing, the memory address is explicitly contained within the instruction itself, forming the effective address directly. For example, an instruction like LOAD 0x1000 retrieves the operand from the absolute location 0x1000 in memory. This mode is straightforward and requires only one memory reference, making it efficient for fixed-location accesses, though it limits the addressable space to the size of the instruction's address field.^[63]^[64] Immediate addressing embeds the operand value directly in the instruction rather than specifying a memory address, so it does not constitute a true addressing mode for memory access. Instead, it provides constants or initial values immediately available to the processor, such as in an ADD #5 operation that adds the literal 5 to a register. This avoids memory fetches, saving execution cycles, but the operand size is constrained by the instruction field length, often smaller than a full word.^[63] Relative addressing computes the effective address by adding an offset from a reference point, typically the program counter (PC), to support position-independent code that relocates without modification. For instance, a branch instruction with a +4 offset jumps to the address PC + 4, exploiting spatial locality in sequential code execution. This mode conserves address bits in instructions and facilitates efficient short-range jumps or loads, though it restricts accesses to nearby memory regions.^[63]^[65] Base-register addressing forms the effective address by adding an offset to the contents of a base register, commonly used for accessing structured data like arrays. In this scheme, the instruction specifies the base register and offset, yielding an address such as base_register + 8 for the eighth array element assuming 8-byte entries. It expands the addressable range beyond instruction limits and supports dynamic relocation, requiring an additional register access but enabling flexible data handling.^[63]^[64] The evolution of these schemes reflects advancements in processor design, starting with limited options in 8-bit microprocessors like the Intel 8008 (1972), which relied on basic absolute and register modes due to constrained instruction space and few registers. Early 8-bit systems emphasized simplicity to fit within small silicon budgets, often using single-accumulator absolute addressing. As 16-bit architectures emerged, more modes like indexing and indirection were added for efficiency. By the 1980s, RISC designs such as MIPS simplified these to a core set—primarily register, immediate, and PC-relative—prioritizing load/store operations and abundant registers to reduce memory accesses and compiler complexity. This shift, driven by transistor scaling and compiler optimizations, streamlined addressing for pipelined execution while maintaining compatibility with common schemes.^[65]^[64]

Modes in Instruction Sets

Addressing modes in instruction sets define how operands are located in memory or registers during instruction execution, enabling efficient access to data structures like arrays or pointers. These modes vary across architectures but commonly include direct, indirect, indexed, and register-based variants to balance flexibility and performance. They form the foundation for common addressing schemes by specifying operand location through combinations of registers, immediates, and displacements. Indexed addressing computes the effective address by adding an index value, often from a register, to a base address, which is particularly useful for traversing arrays or tables. The formula for the effective address in scaled indexed mode is:

\text{Effective address} = \text{base} + (\text{index} \times \text{scale})

where the scale factor (typically 1, 2, 4, or 8) accounts for data element sizes like bytes or words.^[66] This mode reduces the need for multiple instructions in loop constructs, as seen in array access patterns. Indirect addressing loads or stores data by dereferencing a pointer stored in a register or memory location, allowing dynamic memory access without hardcoding addresses. For example, an instruction like LOAD (R1) retrieves the value at the memory address held in register R1, supporting operations on linked structures or function pointers.^[45] This mode introduces an extra memory access compared to direct addressing, impacting latency in pointer-heavy code. Register indirect addressing operates solely through registers, where the register contains the effective address without additional memory fetches for indirection. This is akin to indirect addressing but avoids a secondary dereference, making it faster for register-to-memory transfers in load/store architectures.^[67] It is commonly used in architectures like ARM for base register offsets in load/store instructions.^[68] In the ARM architecture, load/store instructions support offset addressing modes, including register offsets and scaled variants, where the effective address is base plus an immediate or register-shifted value, facilitating efficient stack operations and array indexing.^[67] Similarly, the x86 instruction set employs complex modes such as [base + index * scale + displacement], allowing up to three components for flexible memory access in a single instruction, as detailed in Intel's architecture manuals.^[66] More complex addressing modes, while reducing instruction count, increase instruction decode complexity and time due to additional hardware logic for address calculation, leading to higher power consumption and potential pipeline stalls in modern processors. This trade-off favors simpler modes in RISC designs for faster execution, as opposed to CISC's broader mode support.

Memory Models

Flat Models

In flat memory models, the address space is organized as a single, contiguous linear array, enabling uniform access to memory locations without the need for segmentation. This approach treats memory as a straightforward sequence of bytes, where addresses are interpreted directly as offsets within the entire space. For example, in a 32-bit flat model, the full 4 GB (2^{32} bytes) of addressable memory is accessible using linear addresses ranging from 0 to 4,294,967,295, providing a simple and predictable addressing scheme.^[69]^[70] Flat models are widely adopted in embedded systems, where simplicity and direct hardware access are prioritized, as well as in modern operating systems like Linux running on x86-64 processors. In these environments, the model eliminates the complexities of segment registers by setting them to zero or using them minimally, allowing programs to operate within a vast, uninterrupted virtual address space. For instance, Linux on x86-64 employs a flat model in 64-bit mode, leveraging the processor's long mode to support up to 2^{48} bytes of virtual memory in a linear fashion.^[69]^[71]^[72] The primary advantages of flat models include simplified programming and debugging, as developers can use straightforward pointer arithmetic without handling segment boundaries or related faults. This uniformity reduces overhead in code generation for compilers and avoids issues like segment overlap or limit violations, while efficiently supporting large-scale applications that require expansive address spaces. Additionally, the model facilitates easier porting of software across platforms that share similar linear addressing conventions.^[73]^[74]^[75] Implementation of flat models relies on paging for address translation, where virtual addresses are mapped directly to physical memory pages without intervening segmentation layers. This involves configuring segment descriptors to span the entire address space—such as base address 0 and limit covering all bytes—allowing the memory management unit (MMU) to perform efficient, hardware-accelerated translations via page tables. In practice, this setup ensures that linear virtual addresses are resolved to physical locations solely through paging structures, maintaining the model's seamless linearity.^[69]^[70]

Segmented and Paged Models

In segmented memory models, the address space of a process is divided into variable-sized logical units known as segments, each corresponding to a meaningful portion of the program such as code, data, stack, or heap.^[76] This division allows segments to be placed independently in physical memory, supporting sparse address spaces and enabling sharing of common segments like code across processes.^[76] A virtual address in this model consists of a segment identifier (or selector) and an offset within that segment; the physical address is computed by adding the offset to the base address of the segment, as stored in a per-process segment table that also includes limit checks for protection.^[77] For example, in early architectures like the Intel 8086, a 16-bit segment selector shifted left by 4 bits (multiplied by 16) is added to a 16-bit offset to form a 20-bit physical address, allowing access to 1 MB of memory despite 16-bit registers.^[78] Paging, in contrast, partitions both the virtual address space and physical memory into fixed-size units called pages (typically 4 KB) and page frames, respectively, facilitating non-contiguous allocation without regard to logical structure.^[79] Virtual addresses are split into a page number (virtual page number, or VPN) and an offset; the page table maps each VPN to a physical frame number, with the physical address formed by combining the frame number and offset.^[79] To handle large address spaces efficiently, multi-level page tables are employed, where higher-level directories point to lower-level tables, reducing memory overhead for sparse mappings—modern systems like x86-64 use four levels for 48-bit virtual addresses.^[80] This approach supports demand paging, where pages are loaded into memory only when accessed, and provides isolation through valid/invalid bits in page table entries.^[81] Many systems combine segmentation and paging to leverage the strengths of both, creating a hybrid model where segments are further subdivided into fixed-size pages for mapping to physical memory.^[77] In this setup, a virtual address includes a segment selector, a page number within the segment, and an offset; the segment table points to a page table for that segment, enabling logical organization alongside efficient physical allocation and enhanced protection through layered checks.^[77] This combination, as seen in architectures supporting both mechanisms, allows for variable segment sizes for programmer-visible modularity while using paging to mitigate fragmentation and support sharing at the page level.^[77] The primary trade-offs between these models revolve around flexibility, efficiency, and fragmentation: segmentation excels in logical division and sharing but suffers from external fragmentation due to variable sizes, leading to scattered free holes that complicate allocation.^[76] Paging promotes physical efficiency and eliminates external fragmentation through uniform sizes but introduces internal fragmentation, where partially used pages waste space (up to half a page per allocation on average).^[79] Hybrid models balance these by providing segmentation's modularity with paging's compaction, though at the cost of increased translation complexity and overhead from multiple table lookups.^[77] Overall, paging has become more prevalent in modern systems for its hardware support and reduced fragmentation, while segmentation offers conceptual benefits for structured programming.^[81]

References

[1]
Memory addresses - Computer Science at Emory
A memory address identifies the location of memory cells (bytes). Addresses transmitted on the address bus are memory addressss. Believe if or not: Program ...
[2]
6.4. Main Memory — CS160 Reader - Chemeketa CS
Main memory is a sequence of bytes, each with a unique address, consisting of groups of 8 bits. Addresses are binary numbers, often displayed as hexadecimal.
[3]
[PDF] Lecture #6: Computer Hardware (Memory)
Memory Addresses - Computer Main Memory consists of sequential numbered bytes. - The numbers for each byte is called an Address. Internally addresses are ...
[4]
Programming - Computer Memory Layout
Each position in memory has a number (called its address!). The compiler (or interpreter) associates your variable names with memory addresses. In some ...
[5]
Memory MAYHEM! Memory, Byte Ordering and Alignment
In computers, the location in memory of an element is called the element's address. Addressing is actually rather complicated in the real world because an ...
[6]
[PDF] CSE 220: Systems Programming - Virtual Memory
Virtual addresses are locations in program address space. Physical addresses are locations in actual hardware RAM. With virtual memory, the two need not be ...
[7]
Pointers & Memory - Dartmouth Computer Science
Pointers are variables storing memory addresses, allowing programs to access memory. Memory is a sequence of bytes, each with a numeric address.
[8]
Memory Address - an overview | ScienceDirect Topics
A memory address is defined as a unique identifier assigned to a specific location in memory, which is determined by the size of the system's bus and allows ...
[9]
How The Computer Works: The CPU and Memory
An address register, which keeps track of where a given instruction or piece of data is stored in memory. Each storage location in memory is identified by an ...
[10]
[PDF] First draft report on the EDVAC by John von Neumann - MIT
Further memory requirements of the type (d) are required in problems which depend on given constants, fixed parameters, etc. (g) Problems which are solved by ...
[11]
Von Neumann Architecture - an overview | ScienceDirect Topics
The von Neumann architecture, first proposed in the seminal 1945 paper by John von Neumann, describes a computer design in which the computational unit, known ...Introduction · Core Components and... · Limitations and Modern...
[12]
Read and Write operations in Memory - GeeksforGeeks
Dec 28, 2024 · Memory Address Register (MAR) is the address register which is used to store the address of the memory location where the operation is being ...
[13]
Lecture 4 - CS50
A variable that stores an address is called a pointer, which we can think of as a value that “points” to a location in memory. · We can use the * operator (in an ...
[14]
[PDF] CSE351: Memory, Data, & Addressing I - Washington
CSE351 covers memory, data, addressing, machine code, C, x86 assembly, virtual memory, and how the CPU executes instructions and memory stores data.Missing: textbook | Show results with:textbook
[15]
Hexadecimal system: describes locations in memory, colors
Sep 14, 2005 · The hexadecimal system is commonly used by programmers to describe locations in memory because it can represent every byte (i.e., eight bits) ...
[16]
C Programming Course Notes - Pointers
Memory addresses on most modern computers are either 32-bit or 64-bit unsigned integers, though this may vary with particular computer architectures.<|separator|>
[17]
4.1. Number Bases and Unsigned Integers - Dive Into Systems
In fact, the only context where you're likely to find them is in representing memory addresses. ... unsigned number line and (b) a finite unsigned number line.
[18]
Addressing Modes - Robert G. Plantz
The CPU determines the memory address for a load or store by adding a positive or negative offset to a value in a base register. The way in which the CPU ...
[19]
How Endianness Works: Big-Endian vs. Little Endian | Barr Group
Jan 1, 2002 · Big endian the most significant byte of any multibyte data field is stored at the lowest memory address, which is also the address of the larger ...<|control11|><|separator|>
[20]
7.5: Logical vs Physical Address
### Summary of Physical Address in Memory
[21]
Physical Address Space - an overview | ScienceDirect Topics
Physical Address Space refers to the actual memory locations where data is stored in a computer system, as opposed to virtual address spaces.Conclusion And Future... · 21.2 Memory Model Evolution · 5.4 Virtualizing Memory
[22]
[PDF] DRAM: Architectures, Interfaces, and Systems A Tutorial
For a given physical address, there are a number of ways to map the bits of the physical address to generate the. “memory address” in terms of device ID, Row ...
[23]
The New Costs of Physical Memory Fragmentation
Nov 3, 2024 · A case study in Linux reveals that the operating system reasonably minimizes fragmentation up to huge page size, but falls short when it comes to larger ...
[24]
CS322: Virtual Memory - Gordon College
Virtual memory is an extension of paging/segmentation, mapping logical addresses to physical addresses, and doesn't require all pages to be in memory at once.
[25]
[PDF] Chapter 10: Virtual Memory
Virtual memory separates user logical memory from physical memory, allowing only part of a program to be in memory, and the logical address space to be larger.
[26]
Operating Systems: Virtual Memory
Virtual memory allows programs to use a larger address space than physical memory, loading only needed portions of processes on demand, and can be larger than ...Missing: generation advantages
[27]
[PDF] Virtual Memory, Processes, and Sharing in MULTICS - andrew.cmu.ed
In this paper we explain some of the more fundamental aspects of the ~ULTICS design. The concepts of "process" and "address space" are defined, some details of ...Missing: original | Show results with:original
[28]
The Multics virtual memory: concepts and design - ACM Digital Library
Multics provides direct hardware addressing by user and system programs of all information, independent of its physical storage location.Missing: original | Show results with:original
[29]
[PDF] PDF
◇ Translation (or relocation) mechanism: MMU. – Each load and store supplied virtual address. – translated to real address by MMU (memory management unit). – ...
[30]
[PDF] Virtual Memory - Computer Systems: A Programmer's Perspective
The address translation hardware reads the page table each time it converts a virtual address to a physical address. The operating system is responsible for ...
[31]
[PDF] Virtual Memory: Systems
Jul 1, 2014 · Page physical base address: 40 most significant bits of physical page address ... ▫ Can index into cache while address translation taking place.
[32]
[PDF] Parallel Computer Architecture and Programming CMU 15-418/15 ...
Sep 28, 2023 · VMM should be able to “context switch” guests. Hardware must ... - Avoid flushing TLB. - Use nested page tables instead of shadow page ...
[33]
Operating Systems Lecture Notes Lecture 15 Segments
Each segment is a variable-sized chunk of memory. An address is a segment,offset pair. Each segment has protection bits that specify which kind of accesses can ...
[34]
[PDF] CS111, Lecture 22 - Dynamic Address Translation
• Add segment's base to virtual address to produce physical address ... Encoding segment + offset rigidly divides virtual addresses (how many bits for.
[35]
[PDF] Computer Systems
Mar 21, 2022 · ▫ PTE hit still costs cache delay. ⬛ Solution: Translation Lookaside Buffer (TLB). ▫ Dedicated cache for page table entries. ▫ TLB hit ...Missing: rate | Show results with:rate
[36]
Rethinking TLB Designs in Virtualized Environments
This paper presents an innovative scheme to reduce the cost of address translations by using a very large Translation Lookaside Buffer that is part of memory, ...
[37]
https://ieeexplore.ieee.org/document/7446100
[38]
[PDF] Virtual memory - Stanford Secure Computer Systems Group
- Segment register base + pointer val = linear address. - Page translation happens on linear addresses. • Two levels of protection and translation check.
[39]
[PDF] Hybrid TLB Coalescing: Improving TLB Translation Coverage under ...
Jun 24, 2017 · Considering the fact that the native. Linux kernel for x86 flushes the TLB on context switches, the cost of invalidating the TLB can be ...
[40]
16.1 Annotated Slides | Computation Structures
Since this context switch in effect changes all the entries in the page table, the OS would also have to invalidate all the entries in the TLB cache. This ...
[41]
Memory interface – Clayton Cafiero - University of Vermont
Oct 28, 2025 · Word-addressable vs byte-addressable. Most modern processors are byte-addressable: every byte has a unique address. However, memory is often ...
[42]
Other Architectures
On most modern machines, the addressable unit is the byte ii. Many older machines, and some modern ones, are only word addressable iii. Some machines have ...<|control11|><|separator|>
[43]
[PDF] CS311 Lecture: The Architecture of a Simple Computer
Jul 30, 2003 · It is more common to find actual computer systems today having memory systems that are byte-addressable - so each 8 bit byte has its own address ...
[44]
[PDF] CRAY-1 Computer Technology
The 4K X 1. bit random access memory (RAM) chips are arranged to give a word length of 64 bits plus 8 bits for single error correction, ...Missing: addressable | Show results with:addressable
[45]
[PDF] 4. Addressing modes - Illinois Institute of Technology
Addressing modes are the different ways the address of an operand in memory is specified and calculated.
[46]
Data alignment: Straighten up and fly right - IBM Developer
Feb 8, 2005 · Writing some tests illustrates the performance penalties of unaligned memory access. The test is simple: you read, negate, and write back ...
[47]
[PDF] Alignment, Padding, and Packing
Some platforms will raise a hardware error for unaligned access. Most platforms suffer a performance penalty for unaligned access. © 2025 Ethan Blanton ...
[48]
[PDF] Data Types and Addressing Modes 29 - UNL School of Computing
A byte is eight bits, a word is 2 bytes (16 bits), a doubleword is 4 bytes (32 bits), and a quadword is 8 bytes (64 bits).
[49]
Data representation – CS 61 2019
The size of that integer is the machine's word size; for example, on x86-64, a pointer occupies 8 bytes, and a pointer to an object located at address ...
[50]
[PDF] The Abstraction: Address Spaces - cs.wisc.edu
One major goal of a virtual memory (VM) system is transparency2. The OS should implement virtual memory in a way that is invisible to the running program. Thus, ...Missing: seminal | Show results with:seminal
[51]
Virtual Address Space (Memory Management) - Win32 apps
Jan 7, 2021 · The virtual address space for 32-bit Windows is 4 gigabytes (GB) in size and divided into two partitions: one for use by the process and the other reserved for ...Missing: 0 | Show results with:0
[52]
Virtual Address Spaces - Windows drivers | Microsoft Learn
Jun 28, 2024 · Typically, the lower 2 gigabytes are used for user space, and the upper 2 gigabytes are used for system space.
[53]
The Stack, The Heap, and Dynamic Memory Allocation - CS 3410
The stack starts at a high memory address and grows downward as the program calls more functions. By starting these two segments at opposite “ends” of the ...
[54]
22.3. Memory Management — The Linux Kernel documentation
Architecture defines a 64-bit virtual address. Implementations can support less. Currently supported are 48- and 57-bit virtual addresses. Bits 63 through to ...
[55]
Documentation for /proc/sys/vm - The Linux Kernel documentation
This value contains a flag that enables memory overcommitment. When this flag is 0, the kernel compares the userspace memory request size against total memory ...
[56]
2. Instruction Set Architecture - UMD Computer Science
2. An address field that designates a memory address or a processor register. The number of bits depends on the size of memory or the number of registers.Missing: equation | Show results with:equation
[57]
[PDF] Instruction Codes - Systems I: Computer Organization and Architecture
The instructions are stored in computer memory in the same manner that data is stored. • The control unit interprets these instructions and uses the operations ...
[58]
CPU, GPU, ROM, and RAM - E 115 - NC State University
RAM (Random Access Memory) is your computer's fast, temporary, and volatile memory. Unlike ROM, RAM loses all its content when the computer is turned off. It ...
[59]
21. Memory Hierarchy Design - Basics - UMD Computer Science
As we move away from the processor, the speed decreases, cost decreases and the size increases. The registers and cache memories are closer to the processor, ...
[60]
Operating Systems: Main Memory
A bit or bits can be added to the page table to classify a page as read-write, read-only, read-write-execute, or some combination of these sorts of things. ...
[61]
15. Inside a Modern CPU - University of Iowa
The instruction-fetch stage needs read-only memory access, while the memory-access stage needs read-write memory access. ... write-only access. Pipeline ...
[62]
[PDF] Topic 11 Linked Lists - Texas Computer Science
– self-referential: a node that has the ability to refer to another node of ... a reference (pointer) to the next. Create a new Node very time we add.
[63]
[PDF] Lecture P9: Pointers and Linked Lists - cs.Princeton
Ex 2: Arizona. Pointer = VARIABLE that holds memory address. Allow function to change inputs. Create self-referential data structures.
[64]
[PDF] Addressing Modes
Simplest form of addressing. • Operand = A. • This mode can be used to define and use constants or set initial values of variables.
[65]
[PDF] ECE 552 / CPS 550 Advanced Computer Architecture I Lecture 2 ...
Evolution of Addressing Modes. 1. Single accumulator, absolute address. Load x. AC ← M[x]. 2. Single accumulator, index registers. Load x, IX. AC ← M[x + (IX)].
[66]
[PDF] RISC, CISC, and ISA Variations - CS@Cornell
Early computers had one register! • Two registers short of a MIPS instruction! • Requires memory-based addressing mode. • Example: add 200 // ...
[67]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
This manual is Volume 2 of the Intel 64 and IA-32 manual, covering instruction set reference (A-Z) and is part of a four volume set.
[68]
Addressing modes - Arm Developer
Addressing modes use a base register and offset. The offset can be immediate, register, or scaled. Modes include offset, pre-indexed, and post-indexed.
[69]
Loads and stores - addressing - Arm Developer
There are several addressing modes that define how the address is formed. Base register - The simplest form of addressing is a single register.
[70]
Intel® 64 and IA-32 Architectures Software Developer Manuals
Oct 29, 2025 · Overview. These manuals describe the architecture and programming environment of the Intel® 64 and IA-32 architectures.
[71]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
To implement a basic flat memory model with the IA-32 architecture, at least two segment descriptors must be created, one for referencing a code segment and ...
[72]
Does Linux not use segmentation but only paging?
Sep 15, 2018 · The base and limit of CS/DS/ES/SS are all 0 / -1 in 32 and 64-bit mode. This is called a flat memory model because all pointers point into the ...<|control11|><|separator|>
[73]
https://www.c-jump.com/CIS77/ASM/Memory/M77_0230_x86_protected_flat_advantages.htm
[74]
23. Advantages of Flat Memory Model - c-jump
Advantages of Flat Memory Model. 32-bit Protected Mode supports much larger data structures than Real mode. Because code, data, and stack reside in the same ...
[75]
memory - Flat addressing vs. segmented addressing
Aug 3, 2013 · A flat memory model is generally easier for people to understand, because it is possible to construct a simple mapping between addresses and numbers.
[76]
Flat Memory Model
The memory model used by OS/2 Version 2.0 is known as a flat memory model. This term refers to the fact that memory is regarded as a single large linear address ...
[77]
[PDF] Segmentation - cs.wisc.edu
What segmentation allows the OS to do is to place each one of those segments in different parts of physical memory, and thus avoid filling physical memory with ...
[78]
Memory Management, Segmentation, and Paging - UCSD CSE
Paging splits the address space into equal sized units called pages. While segmentation splits the memory into unequal units that may have sizes more ...
[79]
[PDF] Appendix D - Architecture and Compilers Group
It simply takes the contents of a segment register, shifts it left 4 bits, and adds it to the 16-bit offset, forming a 20-bit physical address.
[80]
[PDF] Paging: Introduction - cs.wisc.edu
To record where each virtual page of the address space is placed in physical memory, the operating system usually keeps a per-process data structure known ...
[81]
Page Tables and Address Translation - Brown CS
We can think of a multi-level page table structure (x86-64 uses four levels; x86-32 used two) as a tree. Multiple levels reduce space needed because when we ...
[82]
[PDF] Paging - Memory Management Today - LASS
– The OS lays the process down on pages and the paging hardware translates virtual addresses to actual physical addresses in memory.