The intent of this file is to give a brief summary of hugetlbpage support inthe Linux kernel.  This support is built on top of multiple page size supportthat is provided by most of modern architectures.  For example, IA-32architecture supports 4K and 4M (2M in PAE mode) page sizes, IA-64architecture supports multiple page sizes 4K, 8K, 64K, 256K, 1M, 4M, 16M,256M.  A TLB is a cache of virtual-to-physical translations.  Typically thisis a very scarce resource on processor.  Operating systems try to make bestuse of limited number of TLB resources.  This optimization is more criticalnow as bigger and bigger physical memories (several GBs) are more readilyavailable.Users can use the huge page support in Linux kernel by either using the mmapsystem call or standard SYSv shared memory system calls (shmget, shmat).First the Linux kernel needs to be built with CONFIG_HUGETLB_PAGE (presentunder Processor types and feature)  and CONFIG_HUGETLBFS (present under filesystem option on config menu) config options.The kernel built with hugepage support should show the number of configuredhugepages in the system by running the "cat /proc/meminfo" command.  /proc/meminfo also provides information about the total number of hugetlbpages configured in the kernel.  It also displays information about thenumber of free hugetlb pages at any time.  It also displays information aboutthe configured hugepage size - this is needed for generating the properalignment and size of the arguments to the above system calls.The output of "cat /proc/meminfo" will have output like:.....HugePages_Total: xxxHugePages_Free:  yyyHugepagesize:    zzz KB/proc/filesystems should also show a filesystem of type "hugetlbfs" configuredin the kernel./proc/sys/vm/nr_hugepages indicates the current number of configured hugetlbpages in the kernel.  Super user can dynamically request more (or free somepre-configured) hugepages. The allocation( or deallocation) of hugetlb pages is posible only if there areenough physically contiguous free pages in system (freeing of hugepages ispossible only if there are enough hugetlb pages free that can be transfered back to regular memory pool).Pages that are used as hugetlb pages are reserved inside the kernel and cannot be used for other purposes. Once the kernel with Hugetlb page support is built and running, a user canuse either the mmap system call or shared memory system calls to start usingthe huge pages.  It is required that the system administrator preallocateenough memory for huge page purposes.  Use the following command to dynamically allocate/deallocate hugepages:	echo 20 > /proc/sys/vm/nr_hugepagesThis command will try to configure 20 hugepages in the system.  The successor failure of allocation depends on the amount of physically contiguousmemory that is preset in system at this time.  System administrators may wantto put this command in one of the local rc init file.  This will enable thekernel to request huge pages early in the boot process (when the possibilityof getting physical contiguous pages is still very high).If the user applications are going to request hugepages using mmap systemcall, then it is required that system administrator mount a file system oftype hugetlbfs:	mount none /mnt/huge -t hugetlbfs <uid=value> <gid=value> <mode=value>		 <size=value> <nr_inodes=value>This command mounts a (pseudo) filesystem of type hugetlbfs on the directory/mnt/huge.  Any files created on /mnt/huge uses hugepages.  The uid and gidoptions sets the owner and group of the root of the file system.  By defaultthe uid and gid of the current process are taken.  The mode option sets themode of root of file system to value & 0777.  This value is given in octal.By default the value 0755 is picked. The size option sets the maximum value ofmemory (huge pages) allowed for that filesystem (/mnt/huge). The size isrounded down to HPAGE_SIZE.  The option nr_inode sets the maximum number ofinodes that /mnt/huge can use.  If the size or nr_inode options are notprovided on command line then no limits are set.  For size and nr_inodesoptions, you can use [G|g]/[M|m]/[K|k] to represent giga/mega/kilo. For example, size=2K has the same meaning as size=2048. An example is given at the end of this document. read and write system calls are not supported on files that reside on hugetlbfile systems.A regular chown, chgrp and chmod commands (with right permissions) could beused to change the file attributes on hugetlbfs.Also, it is important to note that no such mount command is required if theapplications are going to use only shmat/shmget system calls.  Users whowish to use hugetlb page via shared memory segment should be a member ofa supplementary group and system admin needs to configure that gid into/proc/sys/vm/hugetlb_shm_group.  It is possible for same or differentapplications to use any combination of mmaps and shm* calls.  Though themount of filesystem will be required for using mmaps./* Example of using hugepage in user application using Sys V shared memory * system calls.  In this example, app is requesting memory of size 256MB that * is backed by huge pages.  Application uses the flag SHM_HUGETLB in shmget * system call to informt the kernel that it is requesting hugepages.  For * IA-64 architecture, Linux kernel reserves Region number 4 for hugepages. * That means the addresses starting with 0x800000....will need to be * specified. */#include <sys/types.h>#include <sys/shm.h>#include <sys/types.h>#include <sys/mman.h>#include <errno.h>extern int errno;#define SHM_HUGETLB 04000#define LPAGE_SIZE      (256UL*1024UL*1024UL)#define         dprintf(x)  printf(x)#define ADDR (0x8000000000000000UL)main(){        int shmid;        int     i, j, k;        volatile        char    *shmaddr;        if ((shmid =shmget(2, LPAGE_SIZE, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W ))< 0) {                perror("Failure:");                exit(1);        }        printf("shmid: 0x%x\n", shmid);        shmaddr = shmat(shmid, (void *)ADDR, SHM_RND) ;        if (errno != 0) {                perror("Shared Memory Attach Failure:");                exit(2);        }        printf("shmaddr: %p\n", shmaddr);        dprintf("Starting the writes:\n");        for (i=0;i<LPAGE_SIZE;i++) {                shmaddr[i] = (char) (i);                if (!(i%(1024*1024))) dprintf(".");        }        dprintf("\n");        dprintf("Starting the Check...");        for (i=0; i<LPAGE_SIZE;i++)                if (shmaddr[i] != (char)i)                        printf("\nIndex %d mismatched.");        dprintf("Done.\n");        if (shmdt((const void *)shmaddr) != 0) {                perror("Detached Failure:");                exit (3);        }}**************************************************************************************************************************************/* Example of using hugepage in user application using mmap  * system call.  Before running this application, make sure that * administrator has mounted the hugetlbfs (on some directory like /mnt) using * the command mount -t hugetlbfs nodev /mnt * In this example, app is requesting memory of size 256MB that * is backed by huge pages.  Application uses the flag SHM_HUGETLB in shmget * system call to informt the kernel that it is requesting hugepages.  For * IA-64 architecture, Linux kernel reserves Region number 4 for hugepages. * That means the addresses starting with 0x800000....will need to be * specified. */#include <unistd.h>#include <stdio.h>#include <sys/mman.h>#include <fcntl.h>#include <errno.h>#define FILE_NAME "/mnt/hugepagefile"#define LENGTH (256*1024*1024)#define PROTECTION (PROT_READ | PROT_WRITE)#define FLAGS   MAP_SHARED |MAP_FIXED#define ADDRESS (char *)(0x60000000UL + 0x8000000000000000UL)extern errno;check_bytes(char *addr){        printf("First hex is %x\n", *((unsigned int *)addr));}write_bytes(char *addr){        int i;        for (i=0;i<LENGTH;i++)                *(addr+i)=(char)i;}read_bytes(char *addr){        int i;        check_bytes(addr);        for (i=0;i<LENGTH;i++)                if (*(addr+i)!=(char)i) {                        printf("Mismatch at %d\n", i);                        break;                }}main(){        unsigned long addr = 0;        int fd ;        fd = open(FILE_NAME, O_CREAT|O_RDWR, 0755);        if (fd < 0) {                perror("Open failed");                exit(errno);        }        addr = (unsigned long)mmap(ADDRESS, LENGTH, PROTECTION, FLAGS, fd, 0);        if (errno != 0)                perror("mmap failed");        printf("Returned address is %p\n", addr);        check_bytes((char*)addr);        write_bytes((char*)addr);        read_bytes((char *)addr);}