Page (computing): Wikis

Advertisements

Note: Many of our articles have direct quotes from sources you can cite, within the Wikipedia article! This article doesn't yet, but we're working on it! See more info or our list of citable articles.

Encyclopedia

(Redirected to Page (computer memory) article)

From Wikipedia, the free encyclopedia

"Page size" redirects to this article. For information on paper see Paper size

In the context of computer virtual memory, a page, memory page, or virtual page is a fixed-length block of main memory that is contiguous in both physical memory addressing and virtual memory addressing. A page is usually the smallest unit of data for the following:

Virtual memory abstraction allows a page that does not currently reside in main memory to be addressed and used. If a program tries to access a location in such page, an exception called a page fault is generated. The hardware or operating system is notified and loads the required page from auxiliary store automatically. A program addressing the memory has no knowledge of a page fault or a process following it. Thus a program can address more (virtual) RAM than physically exists in the computer.

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

Contents

Page size trade-off

Page size is usually determined by processor architecture. Traditionally, pages in a system had uniform size, for example 4096 bytes. However, processor designs often allow two or more, sometimes simultaneous, page sizes due to the benefits and penalties. There are several points that can factor into choosing the best page size.

Advertisements

Page size versus 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 4KB (212 bytes) pages, the number of virtual pages is 220 (= 232 / 212). However, if the page size is increased to 32KB (215 bytes), only 217 pages are required.

Page size versus 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 typically 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 of pages

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 clearly increase the potential for wasted memory this way, 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 1MB. If a process allocates 1025KB, two pages must be used, resulting in 1023KB of unused space (where one page fully consumes 1024KB and the other only 1KB).

Page size versus disk access

When transferring from 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.

Determining the page size in a program

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 <stdio.h>
#include <unistd.h> // sysconf(3)
 
int main(void) {
    printf("The page size for this system is %ld bytes.\n",
           sysconf(_SC_PAGESIZE)); // _SC_PAGE_SIZE is OK too.
 
    return 0;
}

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 system, such as Windows 9x, and NT may use the system function GetSystemInfo() from kernel32.dll.

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

Huge pages

Intel x86 supports 4MB pages (called Page Size Extension) (2MB pages if using PAE) in addition to its standard 4kB pages, and other architectures may often have similar features. IA-64 supports as many as eight different page sizes, from 4kB up to 256MB. This support for huge pages (known as superpages in FreeBSD, and large pages in Microsoft Windows terminology) allows for "the best of both worlds", reducing the pressure on the TLB cache (sometimes increasing speed by as much as 15%, depending on the application and the allocation size) for large allocations while still keeping memory usage at a reasonable level for small allocations.

Huge pages, despite being implemented in most contemporary personal computers, are not in common use except in large servers and computational clusters. 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.

Linux has supported huge pages on several architectures since the 2.6 series via the hugetlbfs filesystem[2]. Windows Server 2003 (SP1 and newer), Windows Vista and Windows Server 2008 support huge pages under the name of large pages. Windows 2000 and Windows XP support large pages internally[3], but are not exposed to applications. Solaris beginning with version 9 supports large pages on SPARC and x86.[4][5] FreeBSD 7.2-RELEASE features superpages.[6] Note that in Linux, applications need to be modified in order to use huge pages. On FreeBSD and Solaris, applications take advantage of huge pages automatically, without the need for modification.

Newer AMD64 processors can use 1GB pages in long mode, as well as Intel's upcoming [url=http://it.anandtech.com/IT/showdoc.aspx?i=3769]Westmere[/url] processors.

References

  1. ^ Belzer, Jack; Holzman, Albert G.; Kent, Allen, eds. (1981), "Virtual memory systems", Encyclopedia of computer science and technology, 14, CRC Press, pp. 32, ISBN 0824722140, http://books.google.com/books?id=KUgNGCJB4agC&printsec=frontcover 
  2. ^ http://dank.qemfd.net/dankwiki/index.php/Pages
  3. ^ http://support.microsoft.com/kb/270715
  4. ^ "Supporting Multiple Page Sizes in the Solaris Operating System". Sun BluePrints Online. Sun Microsystems. http://www.sun.com/blueprints/0304/817-5917.pdf. Retrieved 2008-01-19. 
  5. ^ "Supporting Multiple Page Sizes in the Solaris Operating System Appendix". Sun BluePrints Online. Sun Microsystems. http://www.sun.com/blueprints/0304/817-6242.pdf. Retrieved 2008-01-19. 
  6. ^ "FreeBSD 7.2-RELEASE Release Notes". FreeBSD Foundation. http://www.freebsd.org/releases/7.2R/relnotes-detailed.html. Retrieved 2009-05-03. 

Further reading

  • Dandamudi, Sivarama P. (2003). Fundamentals of Computer Organization and Design (1st ed.). Springer. pp. 740–741. ISBN 038795211X. 

See also


In a context of computer virtual memory, a page, memory page, or virtual page is a fixed-length block of main memory, that is contiguous in both physical memory addressing and virtual memory addressing. A page is usually a smallest unit of data for the following:

Virtual memory abstraction allows a page that does not currently reside in main memory to be addressed and used. If a program tries to access a location in such page, it generates an exception called a page fault. The hardware or operating system is notified and loads the required page from auxiliary store automatically. A program addressing the memory has no knowledge of a page fault or a process following it. In consequence a program may be easily allowed to address more RAM than actually exists in the computer.

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

Contents

Page size trade-off

Page size is usually determined by a processor architecture. Traditionally, pages in a system had uniform size, for example 4096 bytes. However, processor designs often allow two or more, sometimes simultaneous, page sizes due to the benefits and penalties. There are several points that can factor into choosing the best page size.

Page size versus 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 4KB (212 bytes) pages, the number of virtual pages is 220 (= 232 / 212). However, if the page size is increased to 32KB (215 bytes), only 217 pages are required.

Page size versus 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 typically 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 of pages

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 clearly increase the potential for wasted memory this way, 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 1MB. If a process allocates 1025KB, two pages must be used, resulting in 1023KB of unused space (where one page fully consumes 1024KB and the other only 1KB).

Page size versus disk access

When transferring from disk, much of the delay is caused by the seek time. Because of this, large sequential transfers are more efficient than several smaller transfers. Transferring larger pages from disk to memory therefore does not require much more time than transferring smaller pages.

Determining the page size in a program

Most operating systems allow programs to determine 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.

  1. include
  2. include // sysconf(3)

int main() { printf("The page size for this system is %ld bytes.\n", sysconf(_SC_PAGESIZE)); // _SC_PAGE_SIZE is OK too.

return 0; }

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 system, such as Windows 9x, NT, ReactOS, may use the system function GetSystemInfo() from kernel32.dll.

  1. include
  2. include

int main() { SYSTEM_INFO si; GetSystemInfo(&si);

printf("The page size for this system is %u bytes.\n", si.dwPageSize);

return 0; }

Huge pages

Intel x86 supports 4MB pages (2MB pages if using PAE) in addition to its standard 4kB pages, and other architectures may often have similar features. IA-64 supports as many as eight different page sizes, from 4kB up to 256MB. This support for huge pages (known as superpages in FreeBSD, and large pages in Microsoft Windows terminology) allows for "the best of both worlds", reducing the pressure on the TLB cache (sometimes increasing speed by as much as 15%, depending on the application and the allocation size) for large allocations while still keeping memory usage at a reasonable level for small allocations.

Huge pages, despite being implemented in most contemporary personal computers, are not in common use except in large servers and computational clusters. 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.

Linux has supported huge pages on several architectures since the 2.6 series via the hugetlbfs filesystem[2]. Windows Server 2003 (SP1 and newer), Windows Vista and Windows Server 2008 support huge pages under the name of large pages. Windows Server 2000 and Windows XP support large pages internally[3], but are not exposed to applications. Solaris beginning with version 9 supports large pages on SPARC and x86.[4] [5] FreeBSD 7.2-RELEASE features superpages.[6] Note that in Linux, applications need to be modified in order to use huge pages. On FreeBSD and Solaris, applications take advantage of huge pages automatically, without the need for modification.

References

  1. Belzer, Jack; Holzman, Albert G.; Kent, Allen, eds. (1981), "Virtual memory systems", Encyclopedia of computer science and technology, 14, CRC Press, pp. 32, ISBN 0824722140, http://books.google.com/books?id=KUgNGCJB4agC&printsec=frontcover 
  2. http://dank.qemfd.net/dankwiki/index.php/Pages
  3. http://support.microsoft.com/kb/270715
  4. "Supporting Multiple Page Sizes in the Solaris Operating System". Sun BluePrints Online. Sun Microsystems. http://www.sun.com/blueprints/0304/817-5917.pdf. Retrieved on 2008-01-19. 
  5. "Supporting Multiple Page Sizes in the Solaris Operating System Appendix". Sun BluePrints Online. Sun Microsystems. http://www.sun.com/blueprints/0304/817-6242.pdf. Retrieved on 2008-01-19. 
  6. "FreeBSD 7.2-RELEASE Release Notes". FreeBSD Foundation. http://www.freebsd.org/releases/7.2R/relnotes-detailed.html. Retrieved on 2009-5-3. 

Further Reading

  • Dandamudi, Sivarama P. (2003). Fundamentals of Computer Organization and Design (1st ed.). Springer. pp. 740–741. ISBN 038795211X. 

See also


Advertisements






Got something to say? Make a comment.
Your name
Your email address
Message