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