หน้าเว็บขนาดใหญ่เป็นวิธีที่ช่วยเพิ่มประสิทธิภาพการทำงานของแอปพลิเคชันโดยการลดจำนวน TLB ที่พลาด กลไกจะรวมเพจฟิสิคัลมาตรฐานที่ต่อเนื่องกัน (ขนาดปกติคือ 4 KB) ให้เป็นเพจใหญ่ (เช่น 2 MB) Linux ใช้คุณลักษณะนี้ในสองรูปแบบ: หน้าขนาดใหญ่โปร่งใสและหน้าขนาดใหญ่ที่ชัดเจน
หน้าขนาดใหญ่ที่โปร่งใส
เพจขนาดใหญ่ที่โปร่งใส (THP) ได้รับการจัดการอย่างโปร่งใสโดยเคอร์เนล แอปพลิเคชันพื้นที่ผู้ใช้ไม่สามารถควบคุมได้ เคอร์เนลพยายามจัดสรรเพจขนาดใหญ่ทุกครั้งที่ทำได้ แต่ไม่รับประกัน นอกจากนี้ THP อาจแนะนำค่าใช้จ่ายในฐานะเคอร์เนล daemon "ตัวรวบรวมขยะ" ที่มีชื่อว่าkhugepagedซึ่งรับผิดชอบการรวมเพจทางกายภาพเพื่อสร้างเพจขนาดใหญ่ ซึ่งอาจใช้เวลา CPU โดยมีผลกระทบที่ไม่พึงปรารถนาต่อการทำงานของแอปพลิเคชันที่กำลังทำงานอยู่ ในระบบที่มีแอปพลิเคชันที่มีความสำคัญต่อเวลาโดยทั่วไปขอแนะนำให้ปิดใช้งาน THP
THP สามารถปิดใช้งานได้ในบรรทัดคำสั่ง boot (cf. the end of this answer) หรือจาก shell ในsysfs :
$ 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]
หมายเหตุ : มีเอกสารที่น่าสนใจเกี่ยวกับการประเมินประสิทธิภาพ / ประเด็นของ THP:
- Hugepages ใส: การวัดผลกระทบประสิทธิภาพการทำงาน ;
- ปักหลักตำนานของ HugePages ใสสำหรับฐานข้อมูล
หน้าเว็บขนาดใหญ่ที่ชัดเจน
หากต้องการเพจขนาดใหญ่ในระดับแอปพลิเคชัน (เช่นจากพื้นที่ผู้ใช้) ต้องตั้งค่าคอนฟิกเคอร์เนลHUGETLBFSเพื่อเปิดใช้งานระบบไฟล์หลอกhugetlbfs (เมนูในตัวกำหนดค่าเคอร์เนลมีลักษณะดังนี้: "File systems" -> "Pseudo filesystems" -> "HugeTLB file system support") ในแผนผังแหล่งเคอร์เนลพารามิเตอร์นี้อยู่ใน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
หมายเหตุ : ใน Raspberry Pi คุณสามารถกำหนดค่าการปรากฏของ/proc/config.gzและทำเช่นเดียวกันกับzcatเพื่อตรวจสอบพารามิเตอร์ เมนูการกำหนดค่าคือ: "การตั้งค่าทั่วไป" -> "การสนับสนุน Kernel .config" + "เปิดใช้งานการเข้าถึง. config ผ่าน /proc/config.gz"
เมื่อตั้งค่าพารามิเตอร์นี้hugetlbfs pseudo-filesystem จะถูกเพิ่มลงในเคอร์เนลบิลด์ (cf. 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 / nr_hugepages
จากนั้นmmap ()สามารถแมปบางส่วนของพื้นที่แอดเดรสของแอปพลิเคชันบนเพจขนาดใหญ่ได้ นี่คือตัวอย่างที่แสดงวิธีการทำ:
#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
ในเทอร์มินัลอื่นสามารถสังเกตแผนผังกระบวนการเพื่อตรวจสอบขนาดของเพจหน่วยความจำ (ถูกบล็อกในการหยุดชั่วคราว () การเรียกระบบ):
$ 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สำหรับขอบเขตเพจขนาดใหญ่ถูกสร้างขึ้นภายในโดยเคอร์เนล ถูกทำเครื่องหมายว่าถูกลบเนื่องจากเคอร์เนลลบไฟล์หน่วยความจำที่เกี่ยวข้องซึ่งจะทำให้ไฟล์หายไปทันทีที่ไม่มีการอ้างอิงอีกต่อไป (เช่นเมื่อกระบวนการเรียกสิ้นสุดลงไฟล์ที่อยู่ภายใต้จะถูกปิดเมื่อออก ()ตัวนับอ้างอิงบน ไฟล์จะลดลงเป็น 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 ที่สอดคล้องกับขนาดของเพจขนาดใหญ่ที่ต้องการ เอกสารคู่มือเคอร์เนลให้รายละเอียดเกี่ยวกับตัวเลือกการเมาท์ที่มี ตัวอย่างเช่นในการเมานต์ระบบไฟล์hugetlbfsบน/ mnt / hugeด้วย 8 Huge Pages ขนาด 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เนื่องจาก file descriptor ที่จัดเตรียมไว้สำหรับไฟล์ที่สร้างบนระบบไฟล์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
โปรแกรมก่อนหน้านี้ต้องรันในฐานะรูทตามที่เรียกว่า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 จะกระตุ้นการจัดสรรเพจขนาดใหญ่อย่างมีประสิทธิภาพ
Cf. นี้บทความสำหรับรายละเอียดในอนาคต
จองล่วงหน้า
เพจขนาดใหญ่สร้างขึ้นด้วยเพจหน่วยความจำฟิสิคัลที่ต่อเนื่องกัน การจองควรทำตั้งแต่เนิ่นๆในการเริ่มต้นระบบ (โดยเฉพาะอย่างยิ่งในระบบที่มีโหลดมาก) เนื่องจากหน่วยความจำฟิสิคัลอาจกระจัดกระจายมากจนบางครั้งไม่สามารถจัดสรรเพจขนาดใหญ่ได้ในภายหลัง หากต้องการจองให้เร็วที่สุดสามารถทำได้ในบรรทัดคำสั่งการบูตเคอร์เนล:
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.
เกี่ยวกับราสเบอร์รี่ Pi บรรทัดคำสั่งบูตปกติสามารถได้รับการปรับปรุงใน/boot/cmdline.txtและบรรทัดคำสั่งบูตที่ใช้ในปัจจุบันโดยเคอร์เนลทำงานสามารถเห็นได้ใน/ proc / cmdline
หมายเหตุ :
- สูตรนี้มีรายละเอียดเพิ่มเติมที่นี่และที่นี่
- มีไลบรารีพื้นที่ผู้ใช้ที่เรียกว่าlibhugetlbfsซึ่งมีชั้นของนามธรรมที่ด้านบนของกลไกhugetlbfsของเคอร์เนลที่อธิบายไว้ที่นี่ มันมาพร้อมกับบริการห้องสมุดเช่นget_huge_pages ()และเครื่องมือประกอบเช่นhugectl เป้าหมายของการบริการนี้พื้นที่ของผู้ใช้คือการ map กองและข้อความ + กลุ่มข้อมูลแบบคงที่เชื่อมโยง executables ลงในหน้าขนาดใหญ่ (ทำแผนที่ของโปรแกรมการเชื่อมโยงแบบไดนามิกที่ไม่ได้รับการสนับสนุน) ทั้งหมดนี้อาศัยคุณสมบัติของเคอร์เนลที่อธิบายไว้ในคำตอบนี้
