archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-19 10:34:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8262291: Refactor reserve_memory_special_huge_tlbfs

Browse source 
Reviewed-by: iwalulya, stuefe
This commit is contained in:
Stefan Johansson 2021-04-13 08:59:09 +00:00
parent 008fc75a29
commit f2f7aa3bec
3 changed files with 103 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

55
test/hotspot/gtest/runtime/test_os_linux.cpp
View file

@ -47,11 +47,8 @@ namespace {
char* const _ptr;
const size_t _size;
public:
static char* reserve_memory_special_huge_tlbfs_only(size_t bytes, char* req_addr, bool exec) {
return os::Linux::reserve_memory_special_huge_tlbfs_only(bytes, req_addr, exec);
}
static char* reserve_memory_special_huge_tlbfs_mixed(size_t bytes, size_t alignment, char* req_addr, bool exec) {
return os::Linux::reserve_memory_special_huge_tlbfs_mixed(bytes, alignment, req_addr, exec);
static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, char* req_addr, bool exec) {
return os::Linux::reserve_memory_special_huge_tlbfs(bytes, alignment, req_addr, exec);
}
HugeTlbfsMemory(char* const ptr, size_t size) : _ptr(ptr), _size(size) { }
~HugeTlbfsMemory() {
@ -96,14 +93,14 @@ namespace {
}
}
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_only) {
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_aligned) {
if (!UseHugeTLBFS) {
return;
}
size_t lp = os::large_page_size();
for (size_t size = lp; size <= lp * 10; size += lp) {
char* addr = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs_only(size, NULL, false);
char* addr = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, lp, NULL, false);
if (addr != NULL) {
HugeTlbfsMemory mr(addr, size);
@ -112,7 +109,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_only) {
}
}
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_without_addr) {
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_without_addr) {
if (!UseHugeTLBFS) {
return;
}
@ -129,7 +126,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_without_addr) {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs_mixed(size, alignment, NULL, false);
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
if (p != NULL) {
HugeTlbfsMemory mr(p, size);
EXPECT_PRED2(is_ptr_aligned, p, alignment) << " size = " << size;
@ -139,7 +136,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_without_addr) {
}
}
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_with_good_req_addr) {
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_with_good_req_addr) {
if (!UseHugeTLBFS) {
return;
}
@ -167,8 +164,9 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_with_good_req_addr) {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
char* const req_addr = align_up(mapping, alignment);
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
// req_addr must be at least large page aligned.
char* const req_addr = align_up(mapping, MAX2(alignment, lp));
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
if (p != NULL) {
HugeTlbfsMemory mr(p, size);
ASSERT_EQ(req_addr, p) << " size = " << size << ", alignment = " << alignment;
@ -179,7 +177,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_with_good_req_addr) {
}
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_with_bad_req_addr) {
TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_with_bad_req_addr) {
if (!UseHugeTLBFS) {
return;
}
@ -216,8 +214,9 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_mixed_with_bad_req_addr) {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
char* const req_addr = align_up(mapping, alignment);
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
// req_addr must be at least large page aligned.
char* const req_addr = align_up(mapping, MAX2(alignment, lp));
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
HugeTlbfsMemory mr(p, size);
// as the area around req_addr contains already existing mappings, the API should always
// return NULL (as per contract, it cannot return another address)
@ -254,12 +253,12 @@ class TestReserveMemorySpecial : AllStatic {
}
}
static void test_reserve_memory_special_huge_tlbfs_only(size_t size) {
static void test_reserve_memory_special_huge_tlbfs_size_aligned(size_t size, size_t alignment) {
if (!UseHugeTLBFS) {
return;
}
char* addr = os::Linux::reserve_memory_special_huge_tlbfs_only(size, NULL, false);
char* addr = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
if (addr != NULL) {
small_page_write(addr, size);
@ -268,7 +267,7 @@ class TestReserveMemorySpecial : AllStatic {
}
}
static void test_reserve_memory_special_huge_tlbfs_only() {
static void test_reserve_memory_special_huge_tlbfs_size_aligned() {
if (!UseHugeTLBFS) {
return;
}
@ -276,11 +275,11 @@ class TestReserveMemorySpecial : AllStatic {
size_t lp = os::large_page_size();
for (size_t size = lp; size <= lp * 10; size += lp) {
test_reserve_memory_special_huge_tlbfs_only(size);
test_reserve_memory_special_huge_tlbfs_size_aligned(size, lp);
}
}
static void test_reserve_memory_special_huge_tlbfs_mixed() {
static void test_reserve_memory_special_huge_tlbfs_size_not_aligned() {
size_t lp = os::large_page_size();
size_t ag = os::vm_allocation_granularity();
@ -320,7 +319,7 @@ class TestReserveMemorySpecial : AllStatic {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, NULL, false);
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
if (p != NULL) {
EXPECT_TRUE(is_aligned(p, alignment));
small_page_write(p, size);
@ -333,8 +332,9 @@ class TestReserveMemorySpecial : AllStatic {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
char* const req_addr = align_up(mapping1, alignment);
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
// req_addr must be at least large page aligned.
char* const req_addr = align_up(mapping1, MAX2(alignment, lp));
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
if (p != NULL) {
EXPECT_EQ(p, req_addr);
small_page_write(p, size);
@ -347,8 +347,9 @@ class TestReserveMemorySpecial : AllStatic {
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
char* const req_addr = align_up(mapping2, alignment);
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
// req_addr must be at least large page aligned.
char* const req_addr = align_up(mapping2, MAX2(alignment, lp));
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
// as the area around req_addr contains already existing mappings, the API should always
// return NULL (as per contract, it cannot return another address)
EXPECT_TRUE(p == NULL);
@ -364,8 +365,8 @@ class TestReserveMemorySpecial : AllStatic {
return;
}
test_reserve_memory_special_huge_tlbfs_only();
test_reserve_memory_special_huge_tlbfs_mixed();
test_reserve_memory_special_huge_tlbfs_size_aligned();
test_reserve_memory_special_huge_tlbfs_size_not_aligned();
}
static void test_reserve_memory_special_shm(size_t size, size_t alignment) {