Linux-2.6.12-rc2
[linux-3.10.git] / Documentation / vm / hugetlbpage.txt
1
2 The intent of this file is to give a brief summary of hugetlbpage support in
3 the Linux kernel.  This support is built on top of multiple page size support
4 that is provided by most modern architectures.  For example, i386
5 architecture supports 4K and 4M (2M in PAE mode) page sizes, ia64
6 architecture supports multiple page sizes 4K, 8K, 64K, 256K, 1M, 4M, 16M,
7 256M and ppc64 supports 4K and 16M.  A TLB is a cache of virtual-to-physical
8 translations.  Typically this is a very scarce resource on processor.
9 Operating systems try to make best use of limited number of TLB resources.
10 This optimization is more critical now as bigger and bigger physical memories
11 (several GBs) are more readily available.
12
13 Users can use the huge page support in Linux kernel by either using the mmap
14 system call or standard SYSv shared memory system calls (shmget, shmat).
15
16 First the Linux kernel needs to be built with CONFIG_HUGETLB_PAGE (present
17 under Processor types and feature)  and CONFIG_HUGETLBFS (present under file
18 system option on config menu) config options.
19
20 The kernel built with hugepage support should show the number of configured
21 hugepages in the system by running the "cat /proc/meminfo" command.  
22
23 /proc/meminfo also provides information about the total number of hugetlb
24 pages configured in the kernel.  It also displays information about the
25 number of free hugetlb pages at any time.  It also displays information about
26 the configured hugepage size - this is needed for generating the proper
27 alignment and size of the arguments to the above system calls.
28
29 The output of "cat /proc/meminfo" will have output like:
30
31 .....
32 HugePages_Total: xxx
33 HugePages_Free:  yyy
34 Hugepagesize:    zzz KB
35
36 /proc/filesystems should also show a filesystem of type "hugetlbfs" configured
37 in the kernel.
38
39 /proc/sys/vm/nr_hugepages indicates the current number of configured hugetlb
40 pages in the kernel.  Super user can dynamically request more (or free some
41 pre-configured) hugepages. 
42 The allocation( or deallocation) of hugetlb pages is posible only if there are
43 enough physically contiguous free pages in system (freeing of hugepages is
44 possible only if there are enough hugetlb pages free that can be transfered 
45 back to regular memory pool).
46
47 Pages that are used as hugetlb pages are reserved inside the kernel and can
48 not be used for other purposes. 
49
50 Once the kernel with Hugetlb page support is built and running, a user can
51 use either the mmap system call or shared memory system calls to start using
52 the huge pages.  It is required that the system administrator preallocate
53 enough memory for huge page purposes.  
54
55 Use the following command to dynamically allocate/deallocate hugepages:
56
57         echo 20 > /proc/sys/vm/nr_hugepages
58
59 This command will try to configure 20 hugepages in the system.  The success
60 or failure of allocation depends on the amount of physically contiguous
61 memory that is preset in system at this time.  System administrators may want
62 to put this command in one of the local rc init file.  This will enable the
63 kernel to request huge pages early in the boot process (when the possibility
64 of getting physical contiguous pages is still very high).
65
66 If the user applications are going to request hugepages using mmap system
67 call, then it is required that system administrator mount a file system of
68 type hugetlbfs:
69
70         mount none /mnt/huge -t hugetlbfs <uid=value> <gid=value> <mode=value>
71                  <size=value> <nr_inodes=value>
72
73 This command mounts a (pseudo) filesystem of type hugetlbfs on the directory
74 /mnt/huge.  Any files created on /mnt/huge uses hugepages.  The uid and gid
75 options sets the owner and group of the root of the file system.  By default
76 the uid and gid of the current process are taken.  The mode option sets the
77 mode of root of file system to value & 0777.  This value is given in octal.
78 By default the value 0755 is picked. The size option sets the maximum value of
79 memory (huge pages) allowed for that filesystem (/mnt/huge). The size is
80 rounded down to HPAGE_SIZE.  The option nr_inode sets the maximum number of
81 inodes that /mnt/huge can use.  If the size or nr_inode options are not
82 provided on command line then no limits are set.  For size and nr_inodes
83 options, you can use [G|g]/[M|m]/[K|k] to represent giga/mega/kilo. For 
84 example, size=2K has the same meaning as size=2048. An example is given at 
85 the end of this document. 
86
87 read and write system calls are not supported on files that reside on hugetlb
88 file systems.
89
90 A regular chown, chgrp and chmod commands (with right permissions) could be
91 used to change the file attributes on hugetlbfs.
92
93 Also, it is important to note that no such mount command is required if the
94 applications are going to use only shmat/shmget system calls.  Users who
95 wish to use hugetlb page via shared memory segment should be a member of
96 a supplementary group and system admin needs to configure that gid into
97 /proc/sys/vm/hugetlb_shm_group.  It is possible for same or different
98 applications to use any combination of mmaps and shm* calls.  Though the
99 mount of filesystem will be required for using mmaps.
100
101 *******************************************************************
102
103 /*
104  * Example of using hugepage memory in a user application using Sys V shared
105  * memory system calls.  In this example the app is requesting 256MB of
106  * memory that is backed by huge pages.  The application uses the flag
107  * SHM_HUGETLB in the shmget system call to inform the kernel that it is
108  * requesting hugepages.
109  *
110  * For the ia64 architecture, the Linux kernel reserves Region number 4 for
111  * hugepages.  That means the addresses starting with 0x800000... will need
112  * to be specified.  Specifying a fixed address is not required on ppc64,
113  * i386 or x86_64.
114  *
115  * Note: The default shared memory limit is quite low on many kernels,
116  * you may need to increase it via:
117  *
118  * echo 268435456 > /proc/sys/kernel/shmmax
119  *
120  * This will increase the maximum size per shared memory segment to 256MB.
121  * The other limit that you will hit eventually is shmall which is the
122  * total amount of shared memory in pages. To set it to 16GB on a system
123  * with a 4kB pagesize do:
124  *
125  * echo 4194304 > /proc/sys/kernel/shmall
126  */
127 #include <stdlib.h>
128 #include <stdio.h>
129 #include <sys/types.h>
130 #include <sys/ipc.h>
131 #include <sys/shm.h>
132 #include <sys/mman.h>
133
134 #ifndef SHM_HUGETLB
135 #define SHM_HUGETLB 04000
136 #endif
137
138 #define LENGTH (256UL*1024*1024)
139
140 #define dprintf(x)  printf(x)
141
142 /* Only ia64 requires this */
143 #ifdef __ia64__
144 #define ADDR (void *)(0x8000000000000000UL)
145 #define SHMAT_FLAGS (SHM_RND)
146 #else
147 #define ADDR (void *)(0x0UL)
148 #define SHMAT_FLAGS (0)
149 #endif
150
151 int main(void)
152 {
153         int shmid;
154         unsigned long i;
155         char *shmaddr;
156
157         if ((shmid = shmget(2, LENGTH,
158                             SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W)) < 0) {
159                 perror("shmget");
160                 exit(1);
161         }
162         printf("shmid: 0x%x\n", shmid);
163
164         shmaddr = shmat(shmid, ADDR, SHMAT_FLAGS);
165         if (shmaddr == (char *)-1) {
166                 perror("Shared memory attach failure");
167                 shmctl(shmid, IPC_RMID, NULL);
168                 exit(2);
169         }
170         printf("shmaddr: %p\n", shmaddr);
171
172         dprintf("Starting the writes:\n");
173         for (i = 0; i < LENGTH; i++) {
174                 shmaddr[i] = (char)(i);
175                 if (!(i % (1024 * 1024)))
176                         dprintf(".");
177         }
178         dprintf("\n");
179
180         dprintf("Starting the Check...");
181         for (i = 0; i < LENGTH; i++)
182                 if (shmaddr[i] != (char)i)
183                         printf("\nIndex %lu mismatched\n", i);
184         dprintf("Done.\n");
185
186         if (shmdt((const void *)shmaddr) != 0) {
187                 perror("Detach failure");
188                 shmctl(shmid, IPC_RMID, NULL);
189                 exit(3);
190         }
191
192         shmctl(shmid, IPC_RMID, NULL);
193
194         return 0;
195 }
196
197 *******************************************************************
198
199 /*
200  * Example of using hugepage memory in a user application using the mmap
201  * system call.  Before running this application, make sure that the
202  * administrator has mounted the hugetlbfs filesystem (on some directory
203  * like /mnt) using the command mount -t hugetlbfs nodev /mnt. In this
204  * example, the app is requesting memory of size 256MB that is backed by
205  * huge pages.
206  *
207  * For ia64 architecture, Linux kernel reserves Region number 4 for hugepages.
208  * That means the addresses starting with 0x800000... will need to be
209  * specified.  Specifying a fixed address is not required on ppc64, i386
210  * or x86_64.
211  */
212 #include <stdlib.h>
213 #include <stdio.h>
214 #include <unistd.h>
215 #include <sys/mman.h>
216 #include <fcntl.h>
217
218 #define FILE_NAME "/mnt/hugepagefile"
219 #define LENGTH (256UL*1024*1024)
220 #define PROTECTION (PROT_READ | PROT_WRITE)
221
222 /* Only ia64 requires this */
223 #ifdef __ia64__
224 #define ADDR (void *)(0x8000000000000000UL)
225 #define FLAGS (MAP_SHARED | MAP_FIXED)
226 #else
227 #define ADDR (void *)(0x0UL)
228 #define FLAGS (MAP_SHARED)
229 #endif
230
231 void check_bytes(char *addr)
232 {
233         printf("First hex is %x\n", *((unsigned int *)addr));
234 }
235
236 void write_bytes(char *addr)
237 {
238         unsigned long i;
239
240         for (i = 0; i < LENGTH; i++)
241                 *(addr + i) = (char)i;
242 }
243
244 void read_bytes(char *addr)
245 {
246         unsigned long i;
247
248         check_bytes(addr);
249         for (i = 0; i < LENGTH; i++)
250                 if (*(addr + i) != (char)i) {
251                         printf("Mismatch at %lu\n", i);
252                         break;
253                 }
254 }
255
256 int main(void)
257 {
258         void *addr;
259         int fd;
260
261         fd = open(FILE_NAME, O_CREAT | O_RDWR, 0755);
262         if (fd < 0) {
263                 perror("Open failed");
264                 exit(1);
265         }
266
267         addr = mmap(ADDR, LENGTH, PROTECTION, FLAGS, fd, 0);
268         if (addr == MAP_FAILED) {
269                 perror("mmap");
270                 unlink(FILE_NAME);
271                 exit(1);
272         }
273
274         printf("Returned address is %p\n", addr);
275         check_bytes(addr);
276         write_bytes(addr);
277         read_bytes(addr);
278
279         munmap(addr, LENGTH);
280         close(fd);
281         unlink(FILE_NAME);
282
283         return 0;
284 }