Apage,memory page, orvirtual page is a fixed-length contiguous block ofvirtual memory, described by a single entry in apage table. It is the smallest unit of data for memory management in anoperating system that uses virtual memory. Similarly, apage frame is the smallest fixed-length contiguous block ofphysical memory into which memory pages are mapped by the operating system.[1][2][3]
A transfer of pages between main memory and an auxiliary store, such as ahard disk drive, is referred to aspaging or swapping.[4]
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 apage table of a computerfile system.[5]
 | This sectionneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources in this section. Unsourced material may be challenged and removed.(February 2015) (Learn how and when to remove this message) |
Page size is usually determined by the processor architecture. Traditionally, pages in a system had uniform size, such as 4,096bytes. 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]
A system with a smaller page size uses more pages, requiring apage table that occupies more space. For example, if a 232 virtualaddress 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.
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, thetranslation lookaside buffer (TLB), is often used. The TLB is of limited size, and when it cannot satisfy a given request (aTLB miss) the mapping must be fetched from the page table (either by hardware, firmware, 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 costly TLB misses.
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).
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.
Most operating systems allow programs to discover the page size atruntime. This allows programs to use memory more efficiently by aligning allocations to this size and reducing overall internal fragmentation of pages.
Unix-like systems may use the system functionsysconf(),[7][8][9][10][11] as illustrated in the following example written inthe 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-like systems, the command-line utilitygetconf can be used.[12][13][14]For example,getconf PAGESIZE will return the page size in bytes.
Win32-based operating systems, such as those in theWindows 9x andWindows NT families, may use the system functionGetSystemInfo()[15][16] fromkernel32.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;}
Someinstruction 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" inLinux, "superpages" inFreeBSD, and "large pages" inMicrosoft Windows andIBM AIX terminology) allows for "the best of both worlds", reducing the pressure on theTLB cache (sometimes increasing speed by as much as 15%) for large allocations while still keeping memory usage at a reasonable level for small allocations.
| Architecture | Smallest page size | Larger page sizes |
|---|---|---|
| IA-32 (32-bitx86)[18] | 4 KiB | 4 MiB inPSE mode, 2 MiB inPAE mode[19] |
| x86-64[18] | 4 KiB | 2 MiB, 1 GiB (only when the CPU hasPDPE1GB flag) |
| IA-64 (Itanium)[20] | 4 KiB | 8 KiB, 64 KiB, 256 KiB, 1 MiB, 4 MiB, 16 MiB, 256 MiB[19] |
| Power ISA[21] | 4 KiB | 64 KiB, 16 MiB, 16 GiB |
| SPARC v8 with SPARC Reference MMU[22] | 4 KiB | 256 KiB, 16 MiB |
| UltraSPARC Architecture 2007[23] | 8 KiB | 64 KiB, 512 KiB (optional), 4 MiB, 32 MiB (optional), 256 MiB (optional), 2 GiB (optional), 16 GiB (optional) |
| ARMv7[24] | 4 KiB | 64 KiB, 1 MiB ("section"), 16 MiB ("supersection") (defined by a particular implementation) |
| AArch64[25] | 4 KiB | 16 KiB, 64 KiB, 2 MiB, 32 MiB, 512 MiB, 1 GiB |
| RISCV32[26] | 4 KiB | 4 MiB ("megapage") |
| RISCV64[26] | 4 KiB | 2 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 thePentium Pro, and theAMD Athlon,x86 processors support 4 MiB pages (calledPage Size Extension) (2 MiB pages if usingPAE) in addition to their standard 4 KiB pages; newerx86-64 processors, such asAMD's newer AMD64 processors andIntel'sWestmere[27] and laterXeon processors can use 1 GiB pages inlong 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 contemporarypersonal computers, are not in common use except in large-scale applications, the applications typically found in large servers and incomputational 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 thehugetlbfs filesystem[30] and withouthugetlbfs since 2.6.38.[31]Windows Server 2003 (SP1 and newer),Windows Vista andWindows Server 2008 support huge pages under the name of large pages.[32]Windows 2000 andWindows XP support large pages internally, but do not expose them to applications.[33] Reserving large pages under Windows requires a corresponding right that thesystem administrator must grant to the user because large pages cannot be swapped out under Windows. Beginning with version 9,Solaris supports large pages onSPARC 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 andSolaris, applications take advantage of huge pages automatically, without the need for modification.[36]
limits.h – Base Definitions Reference,The Single UNIX Specification, Version 5 fromThe Open Groupsysconf – System Interfaces Reference,The Single UNIX Specification, Version 5 fromThe Open Groupsysconf(3) – Linux Library FunctionsManualsysconf(3) – Darwin andmacOS Library FunctionsManualsysconf(3C) – Solaris 11.4 Basic Library Functions ReferenceManualgetconf – Shell and Utilities Reference,The Single UNIX Specification, Version 5 fromThe Open Groupgetconf(1) – Linux User CommandsManualgetconf(1) – Darwin andmacOS General CommandsManual[…] 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. […]