hugepage_note_大页内存笔记

最新推荐文章于 2024-05-20 11:28:34 发布
最新推荐文章于 2024-05-20 11:28:34 发布
阅读量3.6k 收藏 13
点赞数 4
分类专栏： c linux kernel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk_wing4/article/details/88080442
版权
linux 同时被 3 个专栏收录
83 篇文章 4 订阅
订阅专栏
c
41 篇文章 2 订阅
订阅专栏
kernel
12 篇文章 0 订阅
订阅专栏

1. HugePages内核支持

内核需要打开以下编译开关。重新编译。

    CONFIG_HUGETLBFS = y
    CONFIG_HUGETLB_PAGE = y

2. HugePages内核启动参数

HugePages内存页是不会被系统交换出去（swapped out）的。
由于HugePages需要更大的连续物理内存，所以在系统启动时更容易获得更多的HugePages内存，并且还能尽量保证这些HugePages内存页连续。

可以通过添加对应的内核启动参数来实现:

项目描述
hugepagesHugePages个数
hugepagesz单个HugePages字节大小
default_hugepagesz默认HugePages字节大小

例子：

	hugepages=10 hugepagesz=2M default_hugepagesz=4M

注意：

  • 如果系统不支持设置的默认HugePages内存页大小，实际的HugePages内存页大小会保持2M。

3. 总的HugePages

3.1. 总的HugePages的查看

/proc/meminfo有总的内存信息，可以通过查找Huge关键字。得出HugePages的信息。

例子：

	cat /proc/meminfo | grep Huge
	>	AnonHugePages:     28672 kB
	>	HugePages_Total:       0
	>	HugePages_Free:        0
	>	HugePages_Rsvd:        0
	>	HugePages_Surp:        0
	>	Hugepagesize:       2048 kB

其中HugePages内存信息的解释如下：

项目描述
HugePages_Total系统当前总共拥有的HugePages个数。
HugePages_Free系统当前总共拥有的空闲HugePages个数。
HugePages_Rsvd(reserved)系统当前总共保留的HugePages个数(备注1)
HugePages_Surp(surplus)实际使用的超发HugePages个数。(备注2)
Hugepagesize每一页HugePages的字节大小。

备注1：

  • 指程序已经向系统申请，但是由于程序还没有对HugePages实质的读写操作，系统尚未实际分配给程序的HugePages个数。

备注2：

  • 可以通过/proc/sys/vm/nr_overcommit_hugepages来控制最大超发的HugePages个数。

3.2. HugePages的在/proc/sys/vm的接口

HugePages的在/proc/sys/vm，有/proc系统接口用于调节HugePages参数。

项目描述权限
nr_hugepages写入常驻或读取实际的HugePages个数读写
nr_hugepages_mempolicyNUMA node的HugePages个数读写
nr_overcommit_hugepages超发的HugePages个数读写
	ll  . /proc/sys/vm/*huge*                                                                               
	>	-rw-r--r-- 1 root root 0 Mar  2 12:03 /proc/sys/vm/hugepages_treat_as_movable
	>	-rw-r--r-- 1 root root 0 Mar  2 12:03 /proc/sys/vm/hugetlb_shm_group
	>	-rw-r--r-- 1 root root 0 Mar  2 12:03 /proc/sys/vm/nr_hugepages
	>	-rw-r--r-- 1 root root 0 Mar  2 12:03 /proc/sys/vm/nr_hugepages_mempolicy
	>	-rw-r--r-- 1 root root 0 Mar  2 12:03 /proc/sys/vm/nr_overcommit_hugepages

	grep .  /proc/sys/vm/*huge*                                                                            
	>	/proc/sys/vm/hugepages_treat_as_movable:0
	>	/proc/sys/vm/hugetlb_shm_group:0
	>	/proc/sys/vm/nr_hugepages:0
	>	/proc/sys/vm/nr_hugepages_mempolicy:0
	>	/proc/sys/vm/nr_overcommit_hugepages:0

3.3. 总的HugePages的分配

/proc/sys/vm/nr_hugepages用于设定常驻的HugePages个数，可读可写。

注意：

  • 设定的之前先清零，重新生成HugePages页面。
  • 设定的时候，系统会根据当前可用物理内存计算出可以组成的HugePages个数。
  • 读取，就可以得到实际分配的HugePages个数。
	# 清零
	echo 0 > /proc/sys/vm/nr_hugepages
	
	# 设置 100个 `HugePages`
	echo 100 > /proc/sys/vm/nr_hugepages
	
	# 查询实际`HugePages`的个数
	cat /proc/sys/vm/nr_hugepages
	>	100

3.4. HugePages分配策略

注意：
这个接口相对落后，请使用单个NUMA node的HugePages的分配代替。

/proc/sys/vm/nr_hugepages_mempolicy用于设定多个NUMA node的HugePages个数，可读可写。

注意：

  • 默认情况下系统所有NUMA node平均分配所有HugePages。
  • 除非NUMA node本身没有足够的内存来生成HugePages，那么将由另外一个生成。
  • 指定NUMA node分配HugePages，需要配合numactl -m一起使用。

使用方法：

	# 所有`NUMA node`平均分配所有`HugePages`
	echo ${huge_page_count} > /proc/sys/vm/nr_hugepages_mempolicy
	# 指定`${node-list}`分配`HugePages`
	numactl -m ${node-list} echo ${huge_page_count} > /proc/sys/vm/nr_hugepages_mempolicy

例子：

	# 清零
	echo 0 > /proc/sys/vm/nr_hugepages
	
	# 从`NUMA node0`分配。总数40 个`HugePages` 
	numactl -m 0 echo 40 > /proc/sys/vm/nr_hugepages_mempolicy
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`分配 新增40 个`HugePages` 
	>   Node 0 HugePages_Total:    40
	>   Node 0 HugePages_Free:     40
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`保持 `HugePages` 不变
	>   Node 1 HugePages_Total:     0
	>   Node 1 HugePages_Free:      0
	>   Node 1 HugePages_Surp:      0
	
	# 从`NUMA node1`分配。总数60 个`HugePages` 
	numactl -m 1 echo 60 > /proc/sys/vm/nr_hugepages_mempolicy
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`保持 `HugePages` 不变
	>   Node 0 HugePages_Total:    40
	>   Node 0 HugePages_Free:     40
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`分配 新增20 个`HugePages` 
	>   Node 1 HugePages_Total:    20
	>   Node 1 HugePages_Free:     20
	>   Node 1 HugePages_Surp:      0
	
	# 所有`NUMA node`平均分配。总数80 个`HugePages`
	echo 80 >/proc/sys/vm/nr_hugepages_mempolicy
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`分配 新增10 个`HugePages` 
	>   Node 0 HugePages_Total:    50
	>   Node 0 HugePages_Free:     50
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`分配 新增10 个`HugePages` 
	>   Node 1 HugePages_Total:    30
	>   Node 1 HugePages_Free:     30
	>   Node 1 HugePages_Surp:      0
	
	# 所有`NUMA node`平均分配。总数100 个`HugePages`
	# 注意`/proc/sys/vm/nr_hugepages`无法配合`numactl`使用
	numactl -m 1 echo 100 > /proc/sys/vm/nr_hugepages
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`分配 新增10 个`HugePages` 
	>   Node 0 HugePages_Total:    60
	>   Node 0 HugePages_Free:     60
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`分配 新增10 个`HugePages` 
	>   Node 1 HugePages_Total:    40
	>   Node 1 HugePages_Free:     40
	>   Node 1 HugePages_Surp:      0
	
	# 所有`NUMA node`平均分配。总数80 个`HugePages`
	# 注意`/proc/sys/vm/nr_hugepages`无法配合`numactl`使用
	numactl -m 1 echo 80 > /proc/sys/vm/nr_hugepages
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`分配 减少10 个`HugePages` 
	>   Node 0 HugePages_Total:    50
	>   Node 0 HugePages_Free:     50
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`分配 减少10 个`HugePages` 
	>   Node 1 HugePages_Total:    30
	>   Node 1 HugePages_Free:     30
	>   Node 1 HugePages_Surp:      0
	    
	# 从`NUMA node1`分配。总数60 个`HugePages` 
	numactl -m 1 echo 60 > /proc/sys/vm/nr_hugepages_mempolicy
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`保持 `HugePages` 不变
	>   Node 0 HugePages_Total:    50
	>   Node 0 HugePages_Free:     50
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`分配 减少20 个`HugePages` 
	>   Node 1 HugePages_Total:    10
	>   Node 1 HugePages_Free:     10
	>   Node 1 HugePages_Surp:      0
	
	# 从`NUMA node0`分配。总数30 个`HugePages` 
	numactl -m 0 echo 30 > /proc/sys/vm/nr_hugepages_mempolicy
	# 查看所有分配
	cat /sys/devices/system/node/node*/meminfo | grep Huge
	>	# `NUMA node0`分配 减少20 个`HugePages` 
	>   Node 0 HugePages_Total:    20
	>   Node 0 HugePages_Free:     20
	>   Node 0 HugePages_Surp:      0
	>	# `NUMA node1`保持 `HugePages` 不变
	>   Node 1 HugePages_Total:    10
	>   Node 1 HugePages_Free:     10
	>   Node 1 HugePages_Surp:      0

3.5. HugePages超发

/proc/sys/vm/nr_overcommit_hugepages，表示最大超发的HugePages个数，可读可写。

例子：

	# 清零
	echo 0 > /proc/sys/vm/nr_hugepages
	echo 0 > /proc/sys/vm/nr_overcommit_hugepages
	
	# 设置常驻`HugePages`个数是4
	echo 4 > /proc/sys/vm/nr_hugepages
	# 设置超发`HugePages`个数是4
	echo 4 > /proc/sys/vm/nr_overcommit_hugepages

	# [没有使用`HugePages`]
	cat /proc/meminfo | grep HugePages_
	>	HugePages_Total:       4
	>	HugePages_Free:        4
	>	HugePages_Rsvd:        0
	>	HugePages_Surp:        0

在这里插入图片描述

	# [合计使用了3个`HugePages`。但是没有读写]
	cat /proc/meminfo | grep HugePages_
	>	HugePages_Total:       4	# 总共分配了4个`HugePages`
	>	HugePages_Free:        4	# 由于没有读写。所以空闲4个`HugePages`
	>	HugePages_Rsvd:        3	# 由于没有读写。所以保留3个`HugePages`
	>	HugePages_Surp:        0	# 实际超发了0个`HugePages`

在这里插入图片描述

	# [合计用了3个`HugePages`。并且已经读写]
	cat /proc/meminfo | grep HugePages_
	>	HugePages_Total:       4	# 总共分配了4个`HugePages`
	>	HugePages_Free:        1	# 由于已经读写。所以空闲1个`HugePages`
	>	HugePages_Rsvd:        0	# 由于已经读写。所以没有保留`HugePages`
	>	HugePages_Surp:        0	# 实际超发了0个`HugePages`

在这里插入图片描述

	# [合计用了6个`HugePages`。但是没有读写]
	cat /proc/meminfo | grep HugePages_
	>	HugePages_Total:       6	# 总共分配了6个`HugePages`
	>	HugePages_Free:        6	# 由于没有读写。所以空闲6个`HugePages`
	>	HugePages_Rsvd:        6	# 由于没有读写。所以保留6个`HugePages`
	>	HugePages_Surp:        2	# 实际超发了2个`HugePages`

在这里插入图片描述

	# [合计用了6个`HugePages`。并且已经读写]
	cat /proc/meminfo | grep HugePages_
	>	HugePages_Total:       6	# 总共分配了6个`HugePages`
	>	HugePages_Free:        0	# 由于已经读写。所以没有空闲`HugePages`
	>	HugePages_Rsvd:        0	# 由于已经读写。所以没有保留`HugePages`
	>	HugePages_Surp:        2	# 实际超发了2个`HugePages`

在这里插入图片描述

3.6. 参数之间的关系式

以下是一般情况下，参数之间的关系式：

	nr_hugepages <= HugePages_Total <= (nr_hugepages + nr_overcommit_hugepages)
	HugePages_Rsvd <= HugePages_Free <= HugePages_Total
	HugePages_Surp == (HugePages_Total - nr_hugepages) <= nr_overcommit_hugepages

3.7. HugePages在/sys/kernel/mm/hugepages/的接口

如果系统支持多种大小的HugePages，就会有多个/sys/kernel/mm/hugepages/hugepages-${huge_page_size}目录。
${huge_page_size}为HugePages的字节数。默认是2048kB。

每一个目录下存在相同的的一些HugePages系统文件。可用于设置或者查看系统信息。

项目描述权限
nr_hugepages写入常驻或读取实际的HugePages个数读写
nr_hugepages_mempolicyNUMA node的HugePages个数读写
nr_overcommit_hugepages最大容许超发HugePages个数读写
free_hugepages空闲HugePages个数只读
resv_hugepages保留的HugePages个数只读
surplus_hugepages实际使用的超发HugePages个数只读

以下例子的系统只有一种大小的HugePages，所以只有一个/sys/kernel/mm/hugepages/hugepages-2048kB目录。

	# 打印`HugePages`系统文件
	ll /sys/kernel/mm/hugepages/ -R
	>	/sys/kernel/mm/hugepages/:
	>	total 0
	>	drwxr-xr-x 2 root root 0 Mar  2 09:57 hugepages-2048kB
	>	
	>	/sys/kernel/mm/hugepages/hugepages-2048kB:
	>	total 0
	>	-r--r--r-- 1 root root 4096 Mar  2 09:58 free_hugepages
	>	-rw-r--r-- 1 root root 4096 Mar  2 09:58 nr_hugepages
	>	-rw-r--r-- 1 root root 4096 Mar  2 09:58 nr_hugepages_mempolicy
	>	-rw-r--r-- 1 root root 4096 Mar  2 09:58 nr_overcommit_hugepages
	>	-r--r--r-- 1 root root 4096 Mar  2 09:58 resv_hugepages
	>	-r--r--r-- 1 root root 4096 Mar  2 09:58 surplus_hugepages
	
	# 打印`HugePages`系统文件的数值
	grep . -r /sys/kernel/mm/hugepages/
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:0

4. NUMA node的HugePages

单个NUMA node的HugePages的/sys接口，可以提供更加准确的配置和查看功能。

注意：

  • 无法配置nr_overcommit_hugepages。
  • 无法查看resv_hugepages

4.1. 单个NUMA node的HugePages的/sys接口

如果系统支持多种大小的HugePages，每个NUMA node就会有多个/sys/devices/system/node/node${numa_node_id}/hugepages/hugepages-${huge_page_size}目录。

  • ${numa_node_id}的数值范围为整数，计数从零开始。
  • ${huge_page_size}为HugePages的字节数。默认是2048kB。

每一个目录下存在相同的的一些HugePages系统文件。可用于设置或者查看系统信息。

项目描述权限
nr_hugepages写入常驻或读取实际的HugePages个数读写
free_hugepages空闲HugePages个数只读
surplus_hugepages实际使用的超发HugePages个数只读

例子：


	l -R /sys/devices/system/node/node*/hugepages/  
	>	# noed0
	>	/sys/devices/system/node/node0/hugepages/:
	>	total 0
	>	drwxr-xr-x 2 root root 0 Mar  2 09:44 hugepages-2048kB
	>	
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB:
	>	total 0
	>	-r--r--r-- 1 root root 4096 Mar  2 09:44 free_hugepages
	>	-rw-r--r-- 1 root root 4096 Mar  2 09:44 nr_hugepages
	>	-r--r--r-- 1 root root 4096 Mar  2 09:44 surplus_hugepages
	>	
	>	# node1
	>	/sys/devices/system/node/node1/hugepages/:
	>	total 0
	>	drwxr-xr-x 2 root root 0 Mar  2 09:44 hugepages-2048kB
	>	
	>	/sys/devices/system/node/node1/hugepages/hugepages-2048kB:
	>	total 0
	>	-r--r--r-- 1 root root 4096 Mar  2 09:44 free_hugepages
	>	-rw-r--r-- 1 root root 4096 Mar  2 09:44 nr_hugepages
	>	-r--r--r-- 1 root root 4096 Mar  2 09:44 surplus_hugepages

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	# node0
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:0
	>	# node1
	>	/sys/devices/system/node/node1/hugepages/hugepages-2048kB/free_hugepages:0
	>	/sys/devices/system/node/node1/hugepages/hugepages-2048kB/nr_hugepages:0
	>	/sys/devices/system/node/node1/hugepages/hugepages-2048kB/surplus_hugepages:0

4.2. 单个NUMA node的HugePages的查看

/sys/devices/system/node/node${numa_node_id}/meminfo，可以查看${numa_node_id}的HugePages内存信息。

  • ${numa_node_id}的数值范围为整数，计数从零开始。

例子：

	grep Huge /sys/devices/system/node/node*/meminfo 
	# node0
	>	Node 0 HugePages_Total:     4
	>	Node 0 HugePages_Free:      4
	>	Node 0 HugePages_Surp:      0
	# node1
	>	Node 1 HugePages_Total:     0
	>	Node 1 HugePages_Free:      0
	>	Node 1 HugePages_Surp:      0

以下的free_hugepages和surplus_hugepages也可以用于查看单个NUMA node的HugePages内存信息。

	/sys/devices/system/node/node${numa_node_id}/hugepages/hugepages-${huge_page_size}/free_hugepages
	/sys/devices/system/node/node${numa_node_id}/hugepages/hugepages-${huge_page_size}/surplus_hugepages
  • ${numa_node_id}的数值范围为整数，计数从零开始。
  • ${huge_page_size}为HugePages的字节数。默认是2048kB。

4.3. 单个NUMA node的HugePages的分配

/sys/devices/system/node/node${numa_node_id}/hugepages/hugepages-${huge_page_size}/nr_hugepages用于设置单个NUMA node的HugePages内存信息。可读可写。

  • ${numa_node_id}的数值范围为整数，计数从零开始。
  • ${huge_page_size}为HugePages的字节数。默认是2048kB。

例子：

	# 清零
	echo 0 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages

	# `NUMA node0`分配 4 个 `HugePages`
	echo 4 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages

	# 超发`HugePages`为 4
	echo 4 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages

	# [没有使用`HugePages`]
	grep . -r /sys/kernel/mm/hugepages/
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:4

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:0

在这里插入图片描述

	# [合计使用了3个`HugePages`。但是没有读写]
	grep . -r /sys/kernel/mm/hugepages/
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:3
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:4

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:0

在这里插入图片描述

	# [合计用了3个`HugePages`。并且已经读写]
	grep . -r /sys/kernel/mm/hugepages/                                                                     
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:1
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:4

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:4
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:1
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:0

在这里插入图片描述

	# [合计用了6个`HugePages`。但是没有读写]
	grep . -r /sys/kernel/mm/hugepages/
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:6
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:6
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:6
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:2
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:6

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:6
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:6
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:2

在这里插入图片描述

	# [合计用了6个`HugePages`。并且已经读写]
	grep . -r /sys/kernel/mm/hugepages/
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages:6
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_overcommit_hugepages:4
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages:0
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/surplus_hugepages:2
	>	/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages_mempolicy:6

	grep . -r /sys/devices/system/node/node*/hugepages/
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages:6
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages:0
	>	/sys/devices/system/node/node0/hugepages/hugepages-2048kB/surplus_hugepages:2

在这里插入图片描述

5. 例程

以下的例程可以用于打开和读写HugePages。

使用方法：

	# 输入`HugePages`的个数。每一个`HugePages`为2048KB。	
	hugepage <hugepage_count_in_2048KB>

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>

#include <sys/ipc.h>
#include <sys/shm.h>

/* ---------------------------------- */
/*         hugepage defination        */
/* ---------------------------------- */
#define HUGEPAGE_SIZE(count)	((count)*2UL*1024UL*1024UL)

struct hugepage {
	key_t key;
	int id;
	size_t size;
	void *address;
};

int hugepage_open(struct hugepage *hugepage, key_t key, size_t size);
void hugepage_close(struct hugepage *hugepage);
void hugepage_dump(struct hugepage *hugepage);

/* ---------------------------------- */
/*             main                   */
/* ---------------------------------- */
#define DEFAULT_KEY		(0x11111)
#define DEFAULT_COUNT	(1)

int main(int argc, char *argv[])
{
	struct hugepage hugepage;
	int error_code;
	int count;
	size_t hugepage_count = DEFAULT_COUNT;

	if (argc > 1) {
		count = atoi(argv[1]);
		if (count <= 0) {
			printf("usage: %s <hugepage_count>\n", argv[0]);
			goto fail_user_input;
		}
		hugepage_count = (size_t)count;
	}

	error_code = hugepage_open(&hugepage
		, DEFAULT_KEY
		, HUGEPAGE_SIZE(hugepage_count));

	if (0 != error_code) {
		goto fail_open;
	}

	printf("hugepage allocated: \n");
	hugepage_dump(&hugepage);

	printf("Press any key to access hugepage!\n");
	getchar();
	memset(hugepage.address, 0, hugepage.size);

	printf("Press any key to free hugepage and exit!\n");
	getchar();
	hugepage_close(&hugepage);

	return 0;

fail_open:
	perror("hugepage open fail");
fail_user_input:
	return -1;
}

/* ---------------------------------- */
/*         hugepage implement         */
/* ---------------------------------- */

int hugepage_open(struct hugepage *hugepage, key_t key, size_t size)
{
	int id;
	void *address;

	if (NULL == hugepage) {
		return -EINVAL;
	}

	/* create */
	id = shmget(key
			, size
			, SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W
			);

	if (id < 0) {
		goto fail_create;
	}

	/* get address */
	address = shmat(id, NULL, 0);
	if ((void *)-1 == address) {
		goto fail_get_address;
	}

	hugepage->key = key;
	hugepage->id = id;
	hugepage->size = size;
	hugepage->address = address;

	return 0;

	/* error handle */
fail_get_address:
	shmctl(id, IPC_RMID, NULL);
fail_create:
	return -EAGAIN;
}


void hugepage_close(struct hugepage *hugepage)
{
	if (NULL == hugepage
	||  0 == hugepage->id) {
		return ;
	}

	shmctl(hugepage->id, IPC_RMID, NULL);
}


void hugepage_dump(struct hugepage *hugepage)
{

	if (NULL == hugepage) {
		return ;
	}

	printf(
		"hugepage(%p) = {\n"
		"  key = 0x%x\n"
		"  id = %u\n"
		"  size = %llu\n"
		"  address = %p\n"
		"}\n"
		, hugepage
		, hugepage->key
		, hugepage->id
		, hugepage->size
		, hugepage->address
		);
}

6. 参考资料

hugepages

Andrew Yang
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统下快速配置HugePages的完整步骤
09-15
主要给大家介绍了关于如何在Linux系统下快速配置HugePages的完整步骤，文中通过图文介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
大页
華麗の海泙緬‘Site
04-04 1053
大页 一、什么是大页 系统进程是通过虚拟地址访问内存，但是CPU必须把它转换程物理内存地址才能真正访问内存。为了提高这个转换效率，CPU会缓存最近的虚拟内存地址和物理内存地址的映射关系，并保存在一个由CPU维护的映射表中。为了尽量提高内存的访问速度，需要在映射表中保存尽量多的映射关系。 而在Redhat Linux中，内存都是以页的形式划分的，默认情况下每页是4K，这就意味着如果物理内存
DPDK内存管理分析
最新发布
weixin_48329334的博客
05-20 808
DPDK的内存管理框架，从底层往上依次为：大页系统。获取系统的大页信息。包括各种大页类型，及其可用大页的数目。获取大页文件系统mount的目录(可以参数指定，--huge-dir )，将要创建的大页文件的前缀（可以参数指定，--file-prefix）每个大页文件系统指定的页的大小是固定的，因此不同页大小的大页，mount的目录是不一样的。
Linux基础—常用配置文件（七）
亓荼的博客
04-17 4259
Linux基础—常用配置文件案例
Linux 内核中大页的实现与分析
duxingxia356的专栏
11-17 1155
介绍 本文介绍了 Linux 操作系统中大页的实现。分别从 memory 层、文件系统层、libhugetlbfs，以及用户如何使用大页等这几个方面进行了分析和介绍。让您更好的了解 大页在内核的实现机制以及用户使用方法。 大页主要是为了用户使用大量的内存时提供优化的方法。它通过硬件平台提供的支持，操作系统对内存操作进行优化，提高了系统的效率。本篇文章首先介绍了硬件平台对大页的支持，然后
关于hugetlbfs如何均匀的在各个numa节点上预留内存的探索
kaka__55的博客
03-12 1058
本文分析基于linux内核4.19.195. 在linux的实际使用中，使用hugetlbfs进行大页内存分配是一种常用的优化方法，而且我们知道，hugetlbfs能够根据需要，将不同numa节点上的内存分配给用户态程序。hugetlbfs常见的用法是，在内核启动完成后，通过写/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages接口预留适当数量的大页，然后通过hugetlbfs获得大页。那么，为了实现“将不同numa节点上的内存分配给用户态程序”，在写
关于PG与Linux的HUGEPAGE/HUGETLBFS
肉啃肉 - 摇滚的IT灵魂
03-15 744
1. PostgreSQL与HUGEPAGE/HUGETLBFS： 当PostgreSQL使用大量连续的内存块时，使用大页面会减少开销，特别是在使用较大的shared_buffers时。要在PostgreSQL中使用此特性，你的内核必须下面两个参数： CONFIG_HUGETLBFS=y CONFIG_HUGETLB_PAGE=y 你还必须调整内核来设置vm.nr_hugepages参数。要估计所需的巨大页面的数量，请启动PostgreSQL，但不启用巨大页面，并使用/proc文件系统来检查postmas
dpdk 对 numa 的使用与多 numa 架构下性能调优的基础
龙瑜的博客
10-30 5397
numa 是什么？ 在 SMP 架构中，内存统一寻址（Uniform Memory Architecture)，处理器和内存之间通过一条总线连接起来。由于所有处理器都是通过一条总线连接起来的，随着处理器的增加，系统总线成为了系统瓶颈，另外，处理器和内存之间的通信延迟也较大。为了克服以上缺点，NUMA 架构应运而生。 numa 架构全称为非一致性内存架构 (Non Uniform Memory Architecture)，与 SMP 中的 UMA 统一寻址内存架构相对。在 numa 系统中有本地内存与远端内存
linux 大叶内存,hugepages大叶内存
weixin_33896830的博客
05-03 2094
就Linux应用程序而言，使用的都是虚拟地址，当应用程序读写一个指定的虚拟地址时，内存管理单元会自动进行虚拟地址到物理地址的转换。一个虚拟地址可以映射到多个物理地址，但当前映射到哪一个物理地址取决于当前的页表(PageTable，一个虚拟地址到物理地址的映射转换表)内容，页表存储在主存储器中，查询速度相对比较慢。为了提高地址转换性能，大多数体系架构都提供一个快速查找缓冲要使用HugeTLB特性，当...
Ubuntu 使用HugePage 加速应用
未选之路
12-22 8657
本文主要讲解的是如何在Ubuntu中配置HugePage 并且使用HugePage来为程序加速。HugePage概念Hugepage的概念是相对Linux中的分页机制中的默认页（4KB）大小而言的。在linux系统中除了使用4KB的默认页大小外还支持2M、1G等其他页大小配置，而超过4KB页大小的页称为Hugepage。通常当进程产生一个Virtual Address进行访存时，系统需要将Virtu
内存设置+hugepage 学习
太阳以西?的博客
05-28 1701
内存设置 例1：不加内存参数，模拟一个默认大小内存的客户机系统。 root@ubuntu:/home/img# qemu-system-x86_64 ubuntu14.04.img 在客户机中常用的两种查看内存信息的方式 1、使用free -m查看内存信息 free命令通常用来查看内存的使用情况，“-m”参数是指内存大小以MB为单位来显示。 在上面示例中，我们使用了默认大小的内存，值为128M，而根据上面输出可知总的内存为113MB，这个值比128MB小，这是因为free命令显示的内存是实际能够使
如何在Ubuntu中开启大页
weixin_44260459的博客
01-22 3710
为了对内存进行管理，操作系统对内存实施分页管理。内存页面的默认大小被设置为4096字节（4KB），原则上内存页面大小可以配置，但是大多数的操作系统视线中还是采用的默认的4KB页面。现在4KB大小的页面在某些情况下不适用了，可能需要手动去更改，接下来介绍一下更改ubuntu中的页面为大页面的方式。 查看页面大小： getconf PAGESIZE 看透明大页面是否打开： cat /sys/kernel/mm/transparent_hugepage/enabled 显示为 mad..
ubuntu 禁用透明大页_如何在Docker容器中使用巨页(大页)
weixin_35881620的博客
12-29 586
在linux环境下常规页面大小是4K，常规巨页大小有两种一种是2MB，一种是1GB。巨页的好处是：减少硬件tlb miss，如此在连续内存访问场景下可以得到较大的性能提升。一般在数据库如：postgreSQL，mySql等数据库都有使用巨页时的优化措施。本文将详细介绍如何在容器环境下使用巨页，以及如何对容器使用的巨页进行限制。当前centos 7.5为止，透明巨页不支持1GB，只支持4k—>...
Linux下HugePage内存功能配置
Scofy_Pei的专栏
01-29 1177
在Linux环境性能优化实践中，HugePage是一个经常提到的方法。简单的说，HugePage就是Linux内核上一种是用内存块的方法。作为传统4K Page的替代，HugePage在大部分场景下可以提升Oracle实例的运行性能效率。   本篇介绍如何进行HugePage配置和Oracle环境使用。   1、HugePage介绍   HugePage广泛启用开始于Kernal 2.
Linux 下配置 HugePages
jolly10的专栏
04-03 1812
HugePage，就是指的大页内存管理方式。与传统的4kb的普通页管理方式相比，HugePage为管理大内存(8GB以上)更为高效。对于8GB以上的内存以及较大的Oracle SGA size，建议配值并使用HugePage特性。 linux的内存管理采取的是分页存取机制，为了保证物理内存能得到充分的利用，内核会按照LRU算法在适当的时候将物理内存中不经常使用的内存页自动交换...
Linux中设置HugePages
lwei_998的专栏
12-30 6934
Linux中使用HugePages可以减少操作系统对page的维护，增加TLB(translation Lookaside Buffer)的命中率. 由于HugePages和Oracle 的AMM不兼容，所以在Oracle 11g中使用HugePages需要禁用AMM. The AMM and HugePages are not compatible. One needs to disable
大页内存的使用：HugePages（大内存页）的原理与使用
RToax
04-24 8370
《DPDK | 如何在用户空间使用大页内存hugepage》 《DPDK内存篇（三）: 标准大页、NUMA、DMA、IOMMU、IOVA、内存池》 《大页内存的使用：大页内存分配与释放》 《大页内存的使用：HugePages（大内存页）的原理与使用》 《清理/释放大页内存》 《CentOS7在/etc/grub2.conf引导中配置1G大页内存》 《DPDK如何释放大页内存（巨页内存hugepage）》 《HugeTLB Pages大页内存》 《Linux之hugepage大页内存理论》
DPDK内存大页在NUMA架构重分配的问题
weixin_30413739的博客
09-10 470
一. 问题介绍 ​ 在DPDK中往往是在内核启动参数中设置要启动的大页的总数量，比如设置大页个数为16个，每个大页是1G，这样系统启动后，就能在/sys/devices/system/node/node0/hugepages/hugepages-1048576KB/nr_hugepages上看到node0上分配的大页，同样可以查看到node1上的大页。默认的情况是内核会平均分配到 不同的socke...
【性能】大页内存 (HugePages)在通用程序优化中的应用
小鱼菜鸟的博客
07-22 820
目录 1.背景 2. 基于指纹的音乐检索简介 3. 原理 4. 小页的困境 5. 大页内存的配置和使用 6. 大页内存的优化效果 7. 大页内存的使用场景 8. 总结 LD_PRELOAD用法 原文：大页内存(HugePages)在通用程序优化中的应用_姚光超的专栏-CSDN博客_大页内存 今天给大家介绍一种比较新奇的程序性能优...
如何修改大页内存HugePages_Free的值大于8192
06-06
要修改大页内存 HugePages_Free 的值大于 8192，可以按照以下步骤进行： 1. 确认当前系统是否支持大页内存，可以执行以下命令查看： ``` cat /proc/meminfo | grep Huge ``` 如果输出中包含 HugePages_XXX 相关的字段，则表示系统支持大页内存。 2. 确认当前系统已经分配的大页内存数量，可以执行以下命令查看： ``` cat /proc/meminfo | grep HugePages ``` 输出中的 HugePages_Free 表示当前系统中尚未被分配的大页内存数量。 3. 修改大页内存的数量，可以通过修改 /etc/sysctl.conf 文件来实现。在该文件中添加以下内容： ``` vm.nr_hugepages=XXXXX ``` 其中，XXXXX 表示要设置的大页内存数量。注意，这个值需要根据实际情况进行调整，不能超过系统支持的最大值。 4. 执行以下命令使修改生效： ``` sudo sysctl -p ``` 这个命令会重新加载 /etc/sysctl.conf 文件中的配置。 5. 确认修改是否生效，可以再次执行以下命令查看： ``` cat /proc/meminfo | grep HugePages ``` 输出中的 HugePages_Free 应该会增加，表示大页内存的数量已经增加成功。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值