Raspberry Pi 上的 HugePages 4
HugePages on Raspberry Pi 4
我需要有关在 raspberry pi 4 运行ning raspberry pi OS 64 位上管理大页面的帮助。
网上没找到多少靠谱的资料。
首先我重新编译内核源代码启用 Memory Management options --->Transparent Hugepage Support 选项。
当我 运行 命令时：
grep -i huge /proc/meminfo
输出为：
AnonHugePages: 319488 kB
ShmemHugePages: 0 kB
FileHugePages: 0 k
和运行命令：
cat /sys/kernel/mm/transparent_hugepage/enabled
输出是：
[always] madvise never
所以我认为应该设置透明大页面（AnonHugePages）。
我需要使用 HugePages 使用 mmap 函数映射最大的连续内存块，c 代码。
mem = mmap(NULL,buf_size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
查看 https://www.man7.org/linux/man-pages/man2/mmap.2.html 有两个标志来管理大页面：MAP_HUGETLB 标志和 MAP_HUGE_2MB、MAP_HUGE_1GB 标志。
我的问题是：要使用HugePages，我应该这样映射吗？
mem = mmap(NULL,buf_size,PROT_READ|PROT_WRITE,MAP_SHARED,MAP_HUGETLB,fd,0);
内核配置：
CONFIG_SYS_SUPPORTS_HUGETLBFS=y
CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y
CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y
CONFIG_HAVE_ARCH_HUGE_VMAP=y
CONFIG_TRANSPARENT_HUGEPAGE=y
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set
CONFIG_TRANSPARENT_HUGE_PAGECACHE=y
# CONFIG_HUGETLBFS is not set
大页面是一种通过减少 TLB 未命中次数来提高应用程序性能的方法。该机制将连续的标准物理页面（典型大小为 4 KB）合并为一个大页面（例如 2 MB）。 Linux 以两种方式实现此功能：透明大页面和显式大页面。
透明大页面
透明大页面 (THP) 由内核透明管理。用户 space 应用程序无法控制它们。内核尽可能地尽可能分配大页面，但不能保证。此外，THP 可能会引入开销，因为名为 khugepaged 的底层“垃圾收集器”内核守护进程负责合并物理页面以生成大页面。这可能会消耗 CPU 时间，并对 运行ning 应用程序的性能产生不良影响。在具有时间关键应用程序的系统中，通常建议停用 THP。
THP 可以在引导命令行上禁用（参见本答案的末尾）或从 sysfs:
中的 shell
$ cat /sys/kernel/mm/transparent_hugepage/enabled
always [madvise] never
$ sudo sh -c "echo never > /sys/kernel/mm/transparent_hugepage/enabled"
$ cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]
N.B.：存在一些关于 THP evaluation/issues 性能的有趣论文：
- Transparent Hugepages: measuring the performance impact;
- Settling the Myth of Transparent HugePages for Databases.
显式大页面
如果在应用程序级别需要大页面（即来自用户 space）。 HUGETLBFS 内核配置必须设置为激活 hugetlbfs 伪文件系统（内核配置器中的菜单类似于：“文件系统”—— > “伪文件系统” --> “HugeTLB 文件系统支持”）。在内核源码树中这个参数在fs/Kconfig:
config HUGETLBFS
bool "HugeTLB file system support"
depends on X86 || IA64 || SPARC64 || (S390 && 64BIT) || \
SYS_SUPPORTS_HUGETLBFS || BROKEN
help
hugetlbfs is a filesystem backing for HugeTLB pages, based on
ramfs. For architectures that support it, say Y here and read
<file:Documentation/admin-guide/mm/hugetlbpage.rst> for details.
If unsure, say N.
例如，在 Ubuntu 系统上，我们可以检查：
$ cat /boot/config-5.4.0-53-generic | grep HUGETLBFS
CONFIG_HUGETLBFS=y
N.B.: 在Raspberry Pi上可以配置/proc/config.gz 并用 zcat 做同样的事情来检查参数。要做到这一点，配置菜单是：“常规设置”-->“内核.config支持”+“通过/proc/config.gz
启用对.config的访问”
设置此参数后，hugetlbfs伪文件系统被添加到内核构建中（参见fs/Makefile） :
obj-$(CONFIG_HUGETLBFS) += hugetlbfs/
hugetlbfs的源代码位于fs/hugetlbfs/inode.c。在启动时，内核将挂载内部 hugetlbfs 文件系统以支持它 运行 正在使用的体系结构的所有可用大页面大小：
static int __init init_hugetlbfs_fs(void)
{
struct vfsmount *mnt;
struct hstate *h;
int error;
int i;
if (!hugepages_supported()) {
pr_info("disabling because there are no supported hugepage sizes\n");
return -ENOTSUPP;
}
error = -ENOMEM;
hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
sizeof(struct hugetlbfs_inode_info),
0, SLAB_ACCOUNT, init_once);
if (hugetlbfs_inode_cachep == NULL)
goto out;
error = register_filesystem(&hugetlbfs_fs_type);
if (error)
goto out_free;
/* default hstate mount is required */
mnt = mount_one_hugetlbfs(&hstates[default_hstate_idx]);
if (IS_ERR(mnt)) {
error = PTR_ERR(mnt);
goto out_unreg;
}
hugetlbfs_vfsmount[default_hstate_idx] = mnt;
/* other hstates are optional */
i = 0;
for_each_hstate(h) {
if (i == default_hstate_idx) {
i++;
continue;
}
mnt = mount_one_hugetlbfs(h);
if (IS_ERR(mnt))
hugetlbfs_vfsmount[i] = NULL;
else
hugetlbfs_vfsmount[i] = mnt;
i++;
}
return 0;
out_unreg:
(void)unregister_filesystem(&hugetlbfs_fs_type);
out_free:
kmem_cache_destroy(hugetlbfs_inode_cachep);
out:
return error;
}
hugetlbfs 文件系统是一种 RAM 文件系统，内核在其中创建文件以支持应用程序映射的内存区域。
将需要的大页数写入/sys/kernel/mm/hugepages/hugepages-hugepagesize/[=186=即可保留需要的大页数].
然后，mmap() 能够将应用程序地址 space 的某些部分映射到大页面上。这是一个显示如何操作的示例：
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#define HP_SIZE (2 * 1024 * 1024) // <-- Adjust with size of the supported HP size on your system
int main(void)
{
char *addr, *addr1;
// Map a Huge page
addr = mmap(NULL, HP_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED| MAP_HUGETLB, -1, 0);
if (addr == MAP_FAILED) {
perror("mmap()");
return 1;
}
printf("Mapping located at address: %p\n", addr);
pause();
return 0;
}
在上面的程序中，addr指向的内存是基于大页面的。使用示例：
$ gcc alloc_hp.c -o alloc_hp
$ ./alloc_hp
mmap(): Cannot allocate memory
$ cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
0
$ sudo sh -c "echo 1 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages"
$ cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
1
$ ./alloc_hp
Mapping located at address: 0x7f7ef6c00000
在另一个终端中，可以观察进程映射来验证内存页的大小（在pause()系统调用中被阻塞）：
$ pidof alloc_hp
13009
$ cat /proc/13009/smaps
[...]
7f7ef6c00000-7f7ef6e00000 rw-s 00000000 00:0f 331939 /anon_hugepage (deleted)
Size: 2048 kB
KernelPageSize: 2048 kB <----- The page size is 2MB
MMUPageSize: 2048 kB
[...]
在前面的映射中，大页面区域的文件名 /anon_hugepage 是由内核在内部创建的。它被标记为已删除，因为内核删除了相关的内存文件，这将使该文件在不再有引用时立即消失（例如，当调用进程结束时，基础文件在 exit() 时关闭，文件上的引用计数器降为 0，删除操作完成，使其消失。
其他大页面大小的分配
在 Raspberry Pi 4B 上，默认大页面大小为 2MB，但该卡支持其他几种大页面大小：
$ ls -l /sys/kernel/mm/hugepages
total 0
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-1048576kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-2048kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-32768kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-64kB
要使用它们，需要挂载一个hugetlbfs类型的文件系统，对应于所需大页面的大小。 kernel documentation 提供了可用挂载选项的详细信息。例如，要在 /mnt/huge 上挂载一个 hugetlbfs 文件系统，其中包含 8 个大小为 64KB 的大页面，命令为：
mount -t hugetlbfs -o pagesize=64K,size=512K,min_size=512K none /mnt/huge
那么就可以在用户程序中映射64KB的大页面了。以下程序创建 /tmp/hpfs 目录，并在该目录上安装一个 hugetlbfs 文件系统，大小为 4 个 64KB 的巨页。创建一个名为 /memfile_01 的文件并将其扩展为 2 个大页面的大小。由于 mmap() 系统调用，文件被映射到内存中。它没有传递 MAP_HUGETLB 标志，因为提供的文件描述符是针对在 hugetlbfs 文件系统上创建的文件。然后，程序调用 pause() 暂停执行，以便在另一个终端进行一些观察：
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <fcntl.h>
#define ERR(fmt, ...) do { \
fprintf(stderr, \
"ERROR@%s#%d: "fmt, \
__FUNCTION__, __LINE__, ## __VA_ARGS__); \
} while(0)
#define HP_SIZE (64 * 1024)
#define HPFS_DIR "/tmp/hpfs"
#define HPFS_SIZE (4 * HP_SIZE)
int main(void)
{
void *addr;
char cmd[256];
int status;
int rc;
char mount_opts[256];
int fd;
rc = mkdir(HPFS_DIR, 0777);
if (0 != rc && EEXIST != errno) {
ERR("mkdir(): %m (%d)\n", errno);
return 1;
}
snprintf(mount_opts, sizeof(mount_opts), "pagesize=%d,size=%d,min_size=%d", HP_SIZE, 2*HP_SIZE, HP_SIZE);
rc = mount("none", HPFS_DIR, "hugetlbfs", 0, mount_opts);
if (0 != rc) {
ERR("mount(): %m (%d)\n", errno);
return 1;
}
fd = open(HPFS_DIR"/memfile_01", O_RDWR|O_CREAT, 0777);
if (fd < 0) {
ERR("open(%s): %m (%d)\n", "memfile_01", errno);
return 1;
}
rc = ftruncate(fd, 2 * HP_SIZE);
if (0 != rc) {
ERR("ftruncate(): %m (%d)\n", errno);
return 1;
}
addr = mmap(NULL, 2 * HP_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (MAP_FAILED == addr) {
ERR("mmap(): %m (%d)\n", errno);
return 1;
}
// The file can be closed
rc = close(fd);
if (0 != rc) {
ERR("close(%d): %m (%d)\n", fd, errno);
return 1;
}
pause();
return 0;
} // main
前面的程序必须 运行 作为 root 调用 mount():
$ gcc mount_tlbfs.c -o mount_tlbfs
$ cat /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages
0
$ sudo sh -c "echo 8 > /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages"
$ cat /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages
8
$ sudo ./mount_tlbfs
在另一个终端中，可以显示/proc/[pid]/smaps文件来查看巨页分配。程序一写入大页，Lazy分配机制就会触发大页的有效分配。
比照。这article 用于将来的详细信息
提前预订
大页是由连续的物理内存页构成的。保留应该在系统启动的早期完成（尤其是在重负载系统上），因为物理内存可能非常碎片化，以至于有时无法在之后分配大页面。尽早保留，这可以在内核上完成 boot command line:
hugepages=
[HW] Number of HugeTLB pages to allocate at boot.
If this follows hugepagesz (below), it specifies
the number of pages of hugepagesz to be allocated.
If this is the first HugeTLB parameter on the command
line, it specifies the number of pages to allocate for
the default huge page size. See also
Documentation/admin-guide/mm/hugetlbpage.rst.
Format: <integer>
hugepagesz=
[HW] The size of the HugeTLB pages. This is used in
conjunction with hugepages (above) to allocate huge
pages of a specific size at boot. The pair
hugepagesz=X hugepages=Y can be specified once for
each supported huge page size. Huge page sizes are
architecture dependent. See also
Documentation/admin-guide/mm/hugetlbpage.rst.
Format: size[KMG]
transparent_hugepage=
[KNL]
Format: [always|madvise|never]
Can be used to control the default behavior of the system
with respect to transparent hugepages.
See Documentation/admin-guide/mm/transhuge.rst
for more details.
在 Raspberry Pi 上，通常可以在 /boot/cmdline.txt 和 [=202] 使用的当前引导命令行中更新引导命令行=]ning内核可见/proc/cmdline.
N.B.:
- 这个食谱有更详细的解释here and here
- 有一个名为 libhugetlbfs which offers a layer of abstraction on top of the kernel's hugetlbfs mechanism described here. It comes with library services like get_huge_pages() and accompanying tools like hugectl 的用户 space 库。这个用户 space 服务的目标是将 STATICALLY 链接的可执行文件的堆和文本+数据段映射到大页面（不支持动态链接程序的映射）。所有这些都依赖于此答案中描述的内核功能。
我需要有关在 raspberry pi 4 运行ning raspberry pi OS 64 位上管理大页面的帮助。
网上没找到多少靠谱的资料。
首先我重新编译内核源代码启用 Memory Management options --->Transparent Hugepage Support 选项。
当我 运行 命令时：
grep -i huge /proc/meminfo
输出为：
AnonHugePages: 319488 kB
ShmemHugePages: 0 kB
FileHugePages: 0 k
和运行命令：
cat /sys/kernel/mm/transparent_hugepage/enabled
输出是：
[always] madvise never
所以我认为应该设置透明大页面（AnonHugePages）。 我需要使用 HugePages 使用 mmap 函数映射最大的连续内存块，c 代码。
mem = mmap(NULL,buf_size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
查看 https://www.man7.org/linux/man-pages/man2/mmap.2.html 有两个标志来管理大页面：MAP_HUGETLB 标志和 MAP_HUGE_2MB、MAP_HUGE_1GB 标志。
我的问题是：要使用HugePages，我应该这样映射吗？
mem = mmap(NULL,buf_size,PROT_READ|PROT_WRITE,MAP_SHARED,MAP_HUGETLB,fd,0);
内核配置：
CONFIG_SYS_SUPPORTS_HUGETLBFS=y
CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y
CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y
CONFIG_HAVE_ARCH_HUGE_VMAP=y
CONFIG_TRANSPARENT_HUGEPAGE=y
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set
CONFIG_TRANSPARENT_HUGE_PAGECACHE=y
# CONFIG_HUGETLBFS is not set
大页面是一种通过减少 TLB 未命中次数来提高应用程序性能的方法。该机制将连续的标准物理页面（典型大小为 4 KB）合并为一个大页面（例如 2 MB）。 Linux 以两种方式实现此功能：透明大页面和显式大页面。
透明大页面
透明大页面 (THP) 由内核透明管理。用户 space 应用程序无法控制它们。内核尽可能地尽可能分配大页面，但不能保证。此外，THP 可能会引入开销，因为名为 khugepaged 的底层“垃圾收集器”内核守护进程负责合并物理页面以生成大页面。这可能会消耗 CPU 时间，并对 运行ning 应用程序的性能产生不良影响。在具有时间关键应用程序的系统中，通常建议停用 THP。
THP 可以在引导命令行上禁用（参见本答案的末尾）或从 sysfs:
中的 shell$ cat /sys/kernel/mm/transparent_hugepage/enabled
always [madvise] never
$ sudo sh -c "echo never > /sys/kernel/mm/transparent_hugepage/enabled"
$ cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]
N.B.：存在一些关于 THP evaluation/issues 性能的有趣论文：
- Transparent Hugepages: measuring the performance impact;
- Settling the Myth of Transparent HugePages for Databases.
显式大页面
如果在应用程序级别需要大页面（即来自用户 space）。 HUGETLBFS 内核配置必须设置为激活 hugetlbfs 伪文件系统（内核配置器中的菜单类似于：“文件系统”—— > “伪文件系统” --> “HugeTLB 文件系统支持”）。在内核源码树中这个参数在fs/Kconfig:
config HUGETLBFS
bool "HugeTLB file system support"
depends on X86 || IA64 || SPARC64 || (S390 && 64BIT) || \
SYS_SUPPORTS_HUGETLBFS || BROKEN
help
hugetlbfs is a filesystem backing for HugeTLB pages, based on
ramfs. For architectures that support it, say Y here and read
<file:Documentation/admin-guide/mm/hugetlbpage.rst> for details.
If unsure, say N.
例如，在 Ubuntu 系统上，我们可以检查：
$ cat /boot/config-5.4.0-53-generic | grep HUGETLBFS
CONFIG_HUGETLBFS=y
N.B.: 在Raspberry Pi上可以配置/proc/config.gz 并用 zcat 做同样的事情来检查参数。要做到这一点，配置菜单是：“常规设置”-->“内核.config支持”+“通过/proc/config.gz
启用对.config的访问”设置此参数后，hugetlbfs伪文件系统被添加到内核构建中（参见fs/Makefile） :
obj-$(CONFIG_HUGETLBFS) += hugetlbfs/
hugetlbfs的源代码位于fs/hugetlbfs/inode.c。在启动时，内核将挂载内部 hugetlbfs 文件系统以支持它 运行 正在使用的体系结构的所有可用大页面大小：
static int __init init_hugetlbfs_fs(void)
{
struct vfsmount *mnt;
struct hstate *h;
int error;
int i;
if (!hugepages_supported()) {
pr_info("disabling because there are no supported hugepage sizes\n");
return -ENOTSUPP;
}
error = -ENOMEM;
hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
sizeof(struct hugetlbfs_inode_info),
0, SLAB_ACCOUNT, init_once);
if (hugetlbfs_inode_cachep == NULL)
goto out;
error = register_filesystem(&hugetlbfs_fs_type);
if (error)
goto out_free;
/* default hstate mount is required */
mnt = mount_one_hugetlbfs(&hstates[default_hstate_idx]);
if (IS_ERR(mnt)) {
error = PTR_ERR(mnt);
goto out_unreg;
}
hugetlbfs_vfsmount[default_hstate_idx] = mnt;
/* other hstates are optional */
i = 0;
for_each_hstate(h) {
if (i == default_hstate_idx) {
i++;
continue;
}
mnt = mount_one_hugetlbfs(h);
if (IS_ERR(mnt))
hugetlbfs_vfsmount[i] = NULL;
else
hugetlbfs_vfsmount[i] = mnt;
i++;
}
return 0;
out_unreg:
(void)unregister_filesystem(&hugetlbfs_fs_type);
out_free:
kmem_cache_destroy(hugetlbfs_inode_cachep);
out:
return error;
}
hugetlbfs 文件系统是一种 RAM 文件系统，内核在其中创建文件以支持应用程序映射的内存区域。
将需要的大页数写入/sys/kernel/mm/hugepages/hugepages-hugepagesize/[=186=即可保留需要的大页数].
然后，mmap() 能够将应用程序地址 space 的某些部分映射到大页面上。这是一个显示如何操作的示例：
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#define HP_SIZE (2 * 1024 * 1024) // <-- Adjust with size of the supported HP size on your system
int main(void)
{
char *addr, *addr1;
// Map a Huge page
addr = mmap(NULL, HP_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED| MAP_HUGETLB, -1, 0);
if (addr == MAP_FAILED) {
perror("mmap()");
return 1;
}
printf("Mapping located at address: %p\n", addr);
pause();
return 0;
}
在上面的程序中，addr指向的内存是基于大页面的。使用示例：
$ gcc alloc_hp.c -o alloc_hp
$ ./alloc_hp
mmap(): Cannot allocate memory
$ cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
0
$ sudo sh -c "echo 1 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages"
$ cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
1
$ ./alloc_hp
Mapping located at address: 0x7f7ef6c00000
在另一个终端中，可以观察进程映射来验证内存页的大小（在pause()系统调用中被阻塞）：
$ pidof alloc_hp
13009
$ cat /proc/13009/smaps
[...]
7f7ef6c00000-7f7ef6e00000 rw-s 00000000 00:0f 331939 /anon_hugepage (deleted)
Size: 2048 kB
KernelPageSize: 2048 kB <----- The page size is 2MB
MMUPageSize: 2048 kB
[...]
在前面的映射中，大页面区域的文件名 /anon_hugepage 是由内核在内部创建的。它被标记为已删除，因为内核删除了相关的内存文件，这将使该文件在不再有引用时立即消失（例如，当调用进程结束时，基础文件在 exit() 时关闭，文件上的引用计数器降为 0，删除操作完成，使其消失。
其他大页面大小的分配
在 Raspberry Pi 4B 上，默认大页面大小为 2MB，但该卡支持其他几种大页面大小：
$ ls -l /sys/kernel/mm/hugepages
total 0
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-1048576kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-2048kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-32768kB
drwxr-xr-x 2 root root 0 Nov 23 14:58 hugepages-64kB
要使用它们，需要挂载一个hugetlbfs类型的文件系统，对应于所需大页面的大小。 kernel documentation 提供了可用挂载选项的详细信息。例如，要在 /mnt/huge 上挂载一个 hugetlbfs 文件系统，其中包含 8 个大小为 64KB 的大页面，命令为：
mount -t hugetlbfs -o pagesize=64K,size=512K,min_size=512K none /mnt/huge
那么就可以在用户程序中映射64KB的大页面了。以下程序创建 /tmp/hpfs 目录，并在该目录上安装一个 hugetlbfs 文件系统，大小为 4 个 64KB 的巨页。创建一个名为 /memfile_01 的文件并将其扩展为 2 个大页面的大小。由于 mmap() 系统调用，文件被映射到内存中。它没有传递 MAP_HUGETLB 标志，因为提供的文件描述符是针对在 hugetlbfs 文件系统上创建的文件。然后，程序调用 pause() 暂停执行，以便在另一个终端进行一些观察：
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <fcntl.h>
#define ERR(fmt, ...) do { \
fprintf(stderr, \
"ERROR@%s#%d: "fmt, \
__FUNCTION__, __LINE__, ## __VA_ARGS__); \
} while(0)
#define HP_SIZE (64 * 1024)
#define HPFS_DIR "/tmp/hpfs"
#define HPFS_SIZE (4 * HP_SIZE)
int main(void)
{
void *addr;
char cmd[256];
int status;
int rc;
char mount_opts[256];
int fd;
rc = mkdir(HPFS_DIR, 0777);
if (0 != rc && EEXIST != errno) {
ERR("mkdir(): %m (%d)\n", errno);
return 1;
}
snprintf(mount_opts, sizeof(mount_opts), "pagesize=%d,size=%d,min_size=%d", HP_SIZE, 2*HP_SIZE, HP_SIZE);
rc = mount("none", HPFS_DIR, "hugetlbfs", 0, mount_opts);
if (0 != rc) {
ERR("mount(): %m (%d)\n", errno);
return 1;
}
fd = open(HPFS_DIR"/memfile_01", O_RDWR|O_CREAT, 0777);
if (fd < 0) {
ERR("open(%s): %m (%d)\n", "memfile_01", errno);
return 1;
}
rc = ftruncate(fd, 2 * HP_SIZE);
if (0 != rc) {
ERR("ftruncate(): %m (%d)\n", errno);
return 1;
}
addr = mmap(NULL, 2 * HP_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (MAP_FAILED == addr) {
ERR("mmap(): %m (%d)\n", errno);
return 1;
}
// The file can be closed
rc = close(fd);
if (0 != rc) {
ERR("close(%d): %m (%d)\n", fd, errno);
return 1;
}
pause();
return 0;
} // main
前面的程序必须 运行 作为 root 调用 mount():
$ gcc mount_tlbfs.c -o mount_tlbfs
$ cat /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages
0
$ sudo sh -c "echo 8 > /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages"
$ cat /sys/kernel/mm/hugepages/hugepages-64kB/nr_hugepages
8
$ sudo ./mount_tlbfs
在另一个终端中，可以显示/proc/[pid]/smaps文件来查看巨页分配。程序一写入大页，Lazy分配机制就会触发大页的有效分配。
比照。这article 用于将来的详细信息
提前预订
大页是由连续的物理内存页构成的。保留应该在系统启动的早期完成（尤其是在重负载系统上），因为物理内存可能非常碎片化，以至于有时无法在之后分配大页面。尽早保留，这可以在内核上完成 boot command line:
hugepages=
[HW] Number of HugeTLB pages to allocate at boot.
If this follows hugepagesz (below), it specifies
the number of pages of hugepagesz to be allocated.
If this is the first HugeTLB parameter on the command
line, it specifies the number of pages to allocate for
the default huge page size. See also
Documentation/admin-guide/mm/hugetlbpage.rst.
Format: <integer>
hugepagesz=
[HW] The size of the HugeTLB pages. This is used in
conjunction with hugepages (above) to allocate huge
pages of a specific size at boot. The pair
hugepagesz=X hugepages=Y can be specified once for
each supported huge page size. Huge page sizes are
architecture dependent. See also
Documentation/admin-guide/mm/hugetlbpage.rst.
Format: size[KMG]
transparent_hugepage=
[KNL]
Format: [always|madvise|never]
Can be used to control the default behavior of the system
with respect to transparent hugepages.
See Documentation/admin-guide/mm/transhuge.rst
for more details.
在 Raspberry Pi 上，通常可以在 /boot/cmdline.txt 和 [=202] 使用的当前引导命令行中更新引导命令行=]ning内核可见/proc/cmdline.
N.B.:
- 这个食谱有更详细的解释here and here
- 有一个名为 libhugetlbfs which offers a layer of abstraction on top of the kernel's hugetlbfs mechanism described here. It comes with library services like get_huge_pages() and accompanying tools like hugectl 的用户 space 库。这个用户 space 服务的目标是将 STATICALLY 链接的可执行文件的堆和文本+数据段映射到大页面（不支持动态链接程序的映射）。所有这些都依赖于此答案中描述的内核功能。