Page (computer memory)

Last updated

A page, memory page, or virtual page is a fixed-length contiguous block of virtual memory, described by a single entry in a page table. It is the smallest unit of data for memory management in an operating system that uses virtual memory. Similarly, a page frame is the smallest fixed-length contiguous block of physical memory into which memory pages are mapped by the operating system. [1] [2] [3]

Contents

A transfer of pages between main memory and an auxiliary store, such as a hard disk drive, is referred to as paging or swapping. [4]

Explanation

Computer memory is divided into pages so that information can be found more quickly.

The concept is named by analogy to the pages of a printed book. If a reader wanted to find, for example, the 5,000th word in the book, they could count from the first word. This would be time-consuming. It would be much faster if the reader had a listing of how many words are on each page. From this listing they could determine which page the 5,000th word appears on, and how many words to count on that page. This listing of the words per page of the book is analogous to a page table of a computer file system. [5]

Page size

Page size trade-off

Page size is usually determined by the processor architecture. Traditionally, pages in a system had uniform size, such as 4,096 bytes. However, processor designs often allow two or more, sometimes simultaneous, page sizes due to its benefits. There are several points that can factor into choosing the best page size. [6]

Page table size

A system with a smaller page size uses more pages, requiring a page table that occupies more space. For example, if a 232 virtual address space is mapped to 4  KiB (212 bytes) pages, the number of virtual pages is 220 = (232 / 212). However, if the page size is increased to 32 KiB (215 bytes), only 217 pages are required. A multi-level paging algorithm can decrease the memory cost of allocating a large page table for each process by further dividing the page table up into smaller tables, effectively paging the page table.

TLB usage

Since every access to memory must be mapped from virtual to physical address, reading the page table every time can be quite costly. Therefore, a very fast kind of cache, the translation lookaside buffer (TLB), is often used. The TLB is of limited size, and when it cannot satisfy a given request (a TLB miss) the page tables must be searched manually (either in hardware or software, depending on the architecture) for the correct mapping. Larger page sizes mean that a TLB cache of the same size can keep track of larger amounts of memory, which avoids the costly TLB misses.

Internal fragmentation

Rarely do processes require the use of an exact number of pages. As a result, the last page will likely only be partially full, wasting some amount of memory. Larger page sizes lead to a large amount of wasted memory, as more potentially unused portions of memory are loaded into the main memory. Smaller page sizes ensure a closer match to the actual amount of memory required in an allocation.

As an example, assume the page size is 1024 B. If a process allocates 1025 B, two pages must be used, resulting in 1023 B of unused space (where one page fully consumes 1024 B and the other only 1 B).

Disk access

When transferring from a rotational disk, much of the delay is caused by seek time, the time it takes to correctly position the read/write heads above the disk platters. Because of this, large sequential transfers are more efficient than several smaller transfers. Transferring the same amount of data from disk to memory often requires less time with larger pages than with smaller pages.

Getting page size programmatically

Most operating systems allow programs to discover the page size at runtime. This allows programs to use memory more efficiently by aligning allocations to this size and reducing overall internal fragmentation of pages.

Unix and POSIX-based operating systems

Unix and POSIX-based systems may use the system function sysconf(), [7] [8] [9] [10] [11] as illustrated in the following example written in the C programming language.

#include<stdio.h>#include<unistd.h> /* sysconf(3) */intmain(void){printf("The page size for this system is %ld bytes.\n",sysconf(_SC_PAGESIZE));/* _SC_PAGE_SIZE is OK too. */return0;}

In many Unix systems, the command-line utility getconf can be used. [12] [13] [14] For example, getconf PAGESIZE will return the page size in bytes.

Windows-based operating systems

Win32-based operating systems, such as those in the Windows 9x and Windows NT families, may use the system function GetSystemInfo() [15] [16] from kernel32.dll.

#include<stdio.h>#include<windows.h>intmain(void){SYSTEM_INFOsi;GetSystemInfo(&si);printf("The page size for this system is %u bytes.\n",si.dwPageSize);return0;}

Multiple page sizes

Some instruction set architectures can support multiple page sizes, including pages significantly larger than the standard page size. The available page sizes depend on the instruction set architecture, processor type, and operating (addressing) mode. The operating system selects one or more sizes from the sizes supported by the architecture. Note that not all processors implement all defined larger page sizes. This support for larger pages (known as "huge pages" in Linux, "superpages" in FreeBSD, and "large pages" in Microsoft Windows and IBM AIX terminology) allows for "the best of both worlds", reducing the pressure on the TLB cache (sometimes increasing speed by as much as 15%) for large allocations while still keeping memory usage at a reasonable level for small allocations.

Page sizes among architectures [17]
ArchitectureSmallest page sizeLarger page sizes
IA-32 (32-bit x86) [18] 4 KiB4  MiB in PSE mode, 2 MiB in PAE mode [19]
x86-64 [18] 4 KiB2 MiB, 1  GiB (only when the CPU has PDPE1GB flag)
IA-64 (Itanium) [20] 4 KiB8 KiB, 64 KiB, 256 KiB, 1 MiB, 4 MiB, 16 MiB, 256 MiB [19]
Power ISA [21] 4 KiB64 KiB, 16 MiB, 16 GiB
SPARC v8 with SPARC Reference MMU [22] 4 KiB256 KiB, 16 MiB
UltraSPARC Architecture 2007 [23] 8 KiB64 KiB, 512 KiB (optional), 4 MiB, 32 MiB (optional), 256 MiB (optional), 2 GiB (optional), 16 GiB (optional)
ARMv7 [24] 4 KiB64 KiB, 1 MiB ("section"), 16 MiB ("supersection") (defined by a particular implementation)
AArch64 [25] 4 KiB16 KiB, 64 KiB, 2 MiB, 32 MiB, 512 MiB, 1 GiB
RISCV32 [26] 4 KiB4 MiB ("megapage")
RISCV64 [26] 4 KiB2 MiB ("megapage"), 1 GiB ("gigapage"), 512 GiB ("terapage", only for CPUs with 43-bit address space or more), 256 TiB ("petapage", only for CPUs with 57-bit address space or more),

Starting with the Pentium Pro, and the AMD Athlon, x86 processors support 4 MiB pages (called Page Size Extension) (2 MiB pages if using PAE) in addition to their standard 4 KiB pages; newer x86-64 processors, such as AMD's newer AMD64 processors and Intel's Westmere [27] and later Xeon processors can use 1 GiB pages in long mode. IA-64 supports as many as eight different page sizes, from 4 KiB up to 256 MiB, and some other architectures have similar features.[ specify ]

Larger pages, despite being available in the processors used in most contemporary personal computers, are not in common use except in large-scale applications, the applications typically found in large servers and in computational clusters, and in the operating system itself. Commonly, their use requires elevated privileges, cooperation from the application making the large allocation (usually setting a flag to ask the operating system for huge pages), or manual administrator configuration; operating systems commonly, sometimes by design, cannot page them out to disk.

However, SGI IRIX has general-purpose support for multiple page sizes. Each individual process can provide hints and the operating system will automatically use the largest page size possible for a given region of address space. [28] Later work proposed transparent operating system support for using a mix of page sizes for unmodified applications through preemptible reservations, opportunistic promotions, speculative demotions, and fragmentation control. [29]

Linux has supported huge pages on several architectures since the 2.6 series via the hugetlbfs filesystem [30] and without hugetlbfs since 2.6.38. [31] Windows Server 2003 (SP1 and newer), Windows Vista and Windows Server 2008 support huge pages under the name of large pages. [32] Windows 2000 and Windows XP support large pages internally, but do not expose them to applications. [33] Beginning with version 9, Solaris supports large pages on SPARC and x86. [34] [35] FreeBSD 7.2-RELEASE features superpages. [36] Note that until recently in Linux, applications needed to be modified in order to use huge pages. The 2.6.38 kernel introduced support for transparent use of huge pages. [31] On Linux kernels supporting transparent huge pages, as well as FreeBSD and Solaris, applications take advantage of huge pages automatically, without the need for modification. [36]

See also

Related Research Articles

<span class="mw-page-title-main">Executable and Linkable Format</span> Standard file format for executables, object code, shared libraries, and core dumps.

In computing, the Executable and Linkable Format is a common standard file format for executable files, object code, shared libraries, and core dumps. First published in the specification for the application binary interface (ABI) of the Unix operating system version named System V Release 4 (SVR4), and later in the Tool Interface Standard, it was quickly accepted among different vendors of Unix systems. In 1999, it was chosen as the standard binary file format for Unix and Unix-like systems on x86 processors by the 86open project.

IA-32 is the 32-bit version of the x86 instruction set architecture, designed by Intel and first implemented in the 80386 microprocessor in 1985. IA-32 is the first incarnation of x86 that supports 32-bit computing; as a result, the "IA-32" term may be used as a metonym to refer to all x86 versions that support 32-bit computing.

<span class="mw-page-title-main">Minix</span> Unix-like operating system

MINIX is a Unix-like operating system based on a microkernel architecture. Since version 2.0, it has been POSIX compliant.

<span class="mw-page-title-main">Non-uniform memory access</span> Computer memory design used in multiprocessing

Non-uniform memory access (NUMA) is a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to the processor. Under NUMA, a processor can access its own local memory faster than non-local memory. NUMA is beneficial for workloads with high memory locality of reference and low lock contention, because a processor may operate on a subset of memory mostly or entirely within its own cache node, reducing traffic on the memory bus.

<span class="mw-page-title-main">64-bit computing</span> Computer architecture bit width

In computer architecture, 64-bit integers, memory addresses, or other data units are those that are 64 bits wide. Also, 64-bit central processing units (CPU) and arithmetic logic units (ALU) are those that are based on processor registers, address buses, or data buses of that size. A computer that uses such a processor is a 64-bit computer.

In computing, tar is a computer software utility for collecting many files into one archive file, often referred to as a tarball, for distribution or backup purposes. The name is derived from "tape archive", as it was originally developed to write data to sequential I/O devices with no file system of their own, such as devices that use magnetic tape. The archive data sets created by tar contain various file system parameters, such as name, timestamps, ownership, file-access permissions, and directory organization. POSIX abandoned tar in favor of pax, yet tar sees continued widespread use.

In computing, protected mode, also called protected virtual address mode, is an operational mode of x86-compatible central processing units (CPUs). It allows system software to use features such as segmentation, virtual memory, paging and safe multi-tasking designed to increase an operating system's control over application software.

<span class="mw-page-title-main">Memory management unit</span> Hardware translating virtual addresses to physical address

A memory management unit (MMU), sometimes called paged memory management unit (PMMU), is a computer hardware unit that examines all memory references on the memory bus, translating these requests, known as virtual memory addresses, into physical addresses in main memory.

x86-64 64-bit version of x86 architecture

x86-64 is a 64-bit version of the x86 instruction set, first announced in 1999. It introduced two new modes of operation, 64-bit mode and compatibility mode, along with a new 4-level paging mode.

In computing, Physical Address Extension (PAE), sometimes referred to as Page Address Extension, is a memory management feature for the x86 architecture. PAE was first introduced by Intel in the Pentium Pro, and later by AMD in the Athlon processor. It defines a page table hierarchy of three levels (instead of two), with table entries of 64 bits each instead of 32, allowing these CPUs to directly access a physical address space larger than 4 gigabytes (232 bytes).

Memory protection is a way to control memory access rights on a computer, and is a part of most modern instruction set architectures and operating systems. The main purpose of memory protection is to prevent a process from accessing memory that has not been allocated to it. This prevents a bug or malware within a process from affecting other processes, or the operating system itself. Protection may encompass all accesses to a specified area of memory, write accesses, or attempts to execute the contents of the area. An attempt to access unauthorized memory results in a hardware fault, e.g., a segmentation fault, storage violation exception, generally causing abnormal termination of the offending process. Memory protection for computer security includes additional techniques such as address space layout randomization and executable-space protection.

A translation lookaside buffer (TLB) is a memory cache that stores the recent translations of virtual memory to physical memory. It is used to reduce the time taken to access a user memory location. It can be called an address-translation cache. It is a part of the chip's memory-management unit (MMU). A TLB may reside between the CPU and the CPU cache, between CPU cache and the main memory or between the different levels of the multi-level cache. The majority of desktop, laptop, and server processors include one or more TLBs in the memory-management hardware, and it is nearly always present in any processor that uses paged or segmented virtual memory.

The NX bit (no-execute) is a technology used in CPUs to segregate areas of a virtual address space to store either data or processor instructions. An operating system with support for the NX bit may mark certain areas of an address space as non-executable. The processor will then refuse to execute any code residing in these areas of the address space. The general technique, known as executable space protection, also called Write XOR Execute, is used to prevent certain types of malicious software from taking over computers by inserting their code into another program's data storage area and running their own code from within this section; one class of such attacks is known as the buffer overflow attack.

Memory segmentation is an operating system memory management technique of dividing a computer's primary memory into segments or sections. In a computer system using segmentation, a reference to a memory location includes a value that identifies a segment and an offset within that segment. Segments or sections are also used in object files of compiled programs when they are linked together into a program image and when the image is loaded into memory.

In the x86 architecture, the CPUID instruction is a processor supplementary instruction allowing software to discover details of the processor. It was introduced by Intel in 1993 with the launch of the Pentium and SL-enhanced 486 processors.

The following is a timeline of virtualization development. In computing, virtualization is the use of a computer to simulate another computer. Through virtualization, a host simulates a guest by exposing virtual hardware devices, which may be done through software or by allowing access to a physical device connected to the machine.

In computing, Page Size Extension (PSE) refers to a feature of x86 processors that allows for pages larger than the traditional 4 KiB size. It was introduced in the original Pentium processor, but it was only publicly documented by Intel with the release of the Pentium Pro. The CPUID instruction can be used to identify the availability of PSE on x86 CPUs.

Second Level Address Translation (SLAT), also known as nested paging, is a hardware-assisted virtualization technology which makes it possible to avoid the overhead associated with software-managed shadow page tables.

Intel 5-level paging, referred to simply as 5-level paging in Intel documents, is a processor extension for the x86-64 line of processors. It extends the size of virtual addresses from 48 bits to 57 bits by adding an additional level to x86-64's multilevel page tables, increasing the addressable virtual memory from 256 TB to 128 PB. The extension was first implemented in the Ice Lake processors.

References

  1. ↑ Christopher Kruegel (2012-12-03). "Operating Systems (CS170-08 course)" (PDF). cs.ucsb.edu. Archived (PDF) from the original on 2016-08-10. Retrieved 2016-06-13.
  2. ↑ Martin C. Rinard (1998-08-22). "Operating Systems Lecture Notes, Lecture 9. Introduction to Paging". people.csail.mit.edu. Archived from the original on 2016-06-01. Retrieved 2016-06-13.
  3. ↑ "Virtual Memory: pages and page frames". cs.miami.edu. 2012-10-31. Archived from the original on 2016-06-11. Retrieved 2016-06-13.
  4. ↑ Belzer, Jack; Holzman, Albert G.; Kent, Allen, eds. (1981), "Virtual memory systems", Encyclopedia of computer science and technology, vol. 14, CRC Press, p. 32, ISBN   0-8247-2214-0
  5. ↑ Kazemi, Darius (2019-01-11). "RFC-11". 365 RFCs.
  6. ↑ Weisberg, P.; Wiseman, Y. (2009-08-10). Using 4KB Page Size for Virtual Memory is Obsolete. 2009 IEEE International Conference on Information Reuse & Integration. CiteSeerX   10.1.1.154.2023 . doi:10.1109/IRI.2009.5211562.
  7. ↑ limits.h  – Base Definitions Reference, The Single UNIX Specification , Version 4 from The Open Group
  8. ↑ sysconf  – System Interfaces Reference, The Single UNIX Specification , Version 4 from The Open Group
  9. ↑ sysconf(3)  –  Linux Library Functions Manual
  10. ↑ sysconf(3)  –  Darwin and macOS Library Functions Manual
  11. ↑ sysconf(3C)  –  Solaris 11.4 Basic Library Functions Reference Manual
  12. ↑ getconf  – Shell and Utilities Reference, The Single UNIX Specification , Version 4 from The Open Group
  13. ↑ getconf(1)  –  Linux User Commands Manual
  14. ↑ getconf(1)  –  Darwin and macOS General Commands Manual
  15. ↑ "GetSystemInfo function". Microsoft. 2021-10-13.
  16. ↑ "SYSTEM_INFO structure". Microsoft. 2022-09-23.
  17. ↑ "Hugepages - Debian Wiki". Wiki.debian.org. 2011-06-21. Retrieved 2014-02-06.
  18. 1 2 "Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3 (3A, 3B, 3C & 3D): System Programming Guide" (PDF). December 2016. p. 4-2.
  19. 1 2 "Documentation/vm/hugetlbpage.txt". Linux kernel documentation. kernel.org. Retrieved 2014-02-06.
  20. ↑ "Intel Itanium Architecture Software Developer's Manual Volume 2: System Architecture" (PDF). May 2010. p. 2:58.
  21. ↑ IBM Power Systems Performance Guide: Implementing and Optimizing. IBM Redbooks. February 2013. ISBN   978-0-7384-3766-8 . Retrieved 2014-03-17.
  22. ↑ "The SPARC Architecture Manual, Version 8". 1992. p. 249.
  23. ↑ "UltraSPARC Architecture 2007" (PDF). 2010-09-27. p. 427.
  24. ↑ "ARM Architecture Reference Manual ARMv7-A and ARMv7-R edition". Arm. 2014-05-20. p. B3-1324.
  25. ↑ "Translation granule". Learn the architecture - AArch64 memory management. Arm . Retrieved 2022-08-19.
  26. 1 2 Waterman, Andrew; Asanović, Krste; Hauser, John (2021). The RISC-V Instruction Set Manual Volume II: Privileged Architecture (PDF). pp. 79–87.
  27. ↑ "The Intel Xeon 5670: Six Improved Cores". AnandTech. Retrieved 2012-11-03.
  28. ↑ "General Purpose Operating System Support for Multiple Page Sizes" (PDF). static.usenix.org. Retrieved 2012-11-02.
  29. ↑ Navarro, Juan; Iyer, Sitararn; Druschel, Peter; Cox, Alan (December 2002). Practical, Transparent Operating System Support for Superpages (PDF). 5th Usenix Symposium on Operating Systems Design and Implementation.
  30. ↑ "Pages - dankwiki, the wiki of nick black" . Retrieved 2023-06-17.
  31. 1 2 Corbet, Jonathan. "Transparent huge pages in 2.6.38". LWN. Retrieved 2011-03-02.
  32. ↑ "Large-Page Support". Microsoft Docs. 2018-05-08.
  33. ↑ "AGP program may hang when using page size extension on Athlon processor". Support.microsoft.com. 2007-01-27. Retrieved 2012-11-03.
  34. ↑ "Supporting Multiple Page Sizes in the Solaris Operating System" (PDF). Sun BluePrints Online. Sun Microsystems. Archived from the original (PDF) on 2006-03-12. Retrieved 2008-01-19.
  35. ↑ "Supporting Multiple Page Sizes in the Solaris Operating System Appendix" (PDF). Sun BluePrints Online. Sun Microsystems. Archived from the original (PDF) on 2007-01-01. Retrieved 2008-01-19.
  36. 1 2 "FreeBSD 7.2-RELEASE Release Notes". FreeBSD Foundation. Retrieved 2009-05-03.
  37. ↑ "2.3.1 Read-Only Memory / 2.3.2 Program Random Access Memory". MCS-4 Assembly Language Programming Manual - The INTELLEC 4 Microcomputer System Programming Manual (PDF) (Preliminary ed.). Santa Clara, California, USA: Intel Corporation. December 1973. pp. 2-3–2-4. MCS-030-1273-1. Archived (PDF) from the original on 2020-03-01. Retrieved 2020-03-02. […] ROM is further divided into pages, each of which contains 256 bytes. Thus locations 0 through 255 comprise page 0 of ROM, location 256 through 511 comprise page 1 and so on. […] Program random access memory (RAM) is organized exactly like ROM. […]
  38. 1 2 "1. Introduction: Segment Alignment". 8086 Family Utilities - User's Guide for 8080/8085-Based Development Systems (PDF). Revision E (A620/5821 6K DD ed.). Santa Clara, California, USA: Intel Corporation. May 1982 [1980, 1978]. p. 1-6. Order Number: 9800639-04. Archived (PDF) from the original on 2020-02-29. Retrieved 2020-02-29.

Further reading

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.