page (computer memory)

A page, memory page, or virtual page is a fixed-length contiguous block of

virtual memory

, described by a single entry in the page table. It is the smallest unit of data for memory management in a virtual memory

operating system

. Similarly, a page frame is the smallest fixed-length contiguous block of physical memory into which memory pages are mapped by the operating system.

A transfer of pages between main memory and an auxiliary store, such as a

hard disk drive

, is referred to as

paging

or swapping.

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.

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 2³² virtual address space is mapped to 4 KiB (2¹² bytes) pages, the number of virtual pages is 2²⁰ = (2³² / 2¹²). However, if the page size is increased to 32 KiB (2¹⁵ bytes), only 2¹⁷ 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 large amount of wasted memory, as more potentially unused portions of memory are loaded into 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 KiB. If a process allocates 1025 KiB, two pages must be used, resulting in 1023 KiB of unused space (where one page fully consumes 1024 KiB and the other only 1 KiB).

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(), as illustrated in the following example written in the C programming language.

#include
#include /* sysconf(3) */

int main(void)

In many Unix systems, the command-line utility getconf can be used.
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