Skip to content

Commit 2798b0d

Browse files
kstefanjkstefanj
committed
8266349: Pass down requested page size to reserve_memory_special
Reviewed-by: stuefe, mgkwill
1 parent e0c8688 commit 2798b0d

File tree

10 files changed

+38
-34
lines changed

10 files changed

+38
-34
lines changed

‎src/hotspot/os/aix/os_aix.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2141,7 +2141,7 @@ void os::large_page_init() {
21412141
return; // Nothing to do. See query_multipage_support and friends.
21422142
}
21432143

2144-
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
2144+
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, size_t page_size, char* req_addr, bool exec) {
21452145
fatal("os::reserve_memory_special should not be called on AIX.");
21462146
return NULL;
21472147
}

‎src/hotspot/os/bsd/os_bsd.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1776,7 +1776,7 @@ void os::large_page_init() {
17761776
}
17771777

17781778

1779-
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
1779+
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, size_t page_size, char* req_addr, bool exec) {
17801780
fatal("os::reserve_memory_special should not be called on BSD.");
17811781
return NULL;
17821782
}

‎src/hotspot/os/linux/os_linux.cpp

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3957,14 +3957,15 @@ bool os::Linux::commit_memory_special(size_t bytes,
39573957

39583958
char* os::Linux::reserve_memory_special_huge_tlbfs(size_t bytes,
39593959
size_t alignment,
3960+
size_t page_size,
39603961
char* req_addr,
39613962
bool exec) {
39623963
assert(UseLargePages && UseHugeTLBFS, "only for Huge TLBFS large pages");
39633964
assert(is_aligned(req_addr, alignment), "Must be");
3964-
assert(is_aligned(req_addr, os::large_page_size()), "Must be");
3965+
assert(is_aligned(req_addr, page_size), "Must be");
39653966
assert(is_aligned(alignment, os::vm_allocation_granularity()), "Must be");
3966-
assert(is_power_of_2(os::large_page_size()), "Must be");
3967-
assert(bytes >= os::large_page_size(), "Shouldn't allocate large pages for small sizes");
3967+
assert(_page_sizes.contains(page_size), "Must be a valid page size");
3968+
assert(bytes >= page_size, "Shouldn't allocate large pages for small sizes");
39683969

39693970
// We only end up here when at least 1 large page can be used.
39703971
// If the size is not a multiple of the large page size, we
@@ -3974,15 +3975,15 @@ char* os::Linux::reserve_memory_special_huge_tlbfs(size_t bytes,
39743975
// a requested address is given it will be used and it must be
39753976
// aligned to both the large page size and the given alignment.
39763977
// The larger of the two will be used.
3977-
size_t required_alignment = MAX(os::large_page_size(), alignment);
3978+
size_t required_alignment = MAX(page_size, alignment);
39783979
char* const aligned_start = anon_mmap_aligned(req_addr, bytes, required_alignment);
39793980
if (aligned_start == NULL) {
39803981
return NULL;
39813982
}
39823983

39833984
// First commit using large pages.
3984-
size_t large_bytes = align_down(bytes, os::large_page_size());
3985-
bool large_committed = commit_memory_special(large_bytes, os::large_page_size(), aligned_start, exec);
3985+
size_t large_bytes = align_down(bytes, page_size);
3986+
bool large_committed = commit_memory_special(large_bytes, page_size, aligned_start, exec);
39863987

39873988
if (large_committed && bytes == large_bytes) {
39883989
// The size was large page aligned so no additional work is
@@ -4011,16 +4012,17 @@ char* os::Linux::reserve_memory_special_huge_tlbfs(size_t bytes,
40114012
return aligned_start;
40124013
}
40134014

4014-
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment,
4015+
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, size_t page_size,
40154016
char* req_addr, bool exec) {
40164017
assert(UseLargePages, "only for large pages");
40174018

40184019
char* addr;
40194020
if (UseSHM) {
4021+
// No support for using specific page sizes with SHM.
40204022
addr = os::Linux::reserve_memory_special_shm(bytes, alignment, req_addr, exec);
40214023
} else {
40224024
assert(UseHugeTLBFS, "must be");
4023-
addr = os::Linux::reserve_memory_special_huge_tlbfs(bytes, alignment, req_addr, exec);
4025+
addr = os::Linux::reserve_memory_special_huge_tlbfs(bytes, alignment, page_size, req_addr, exec);
40244026
}
40254027

40264028
if (addr != NULL) {

‎src/hotspot/os/linux/os_linux.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ class Linux {
9090
static int hugetlbfs_page_size_flag(size_t page_size);
9191

9292
static char* reserve_memory_special_shm(size_t bytes, size_t alignment, char* req_addr, bool exec);
93-
static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, char* req_addr, bool exec);
93+
static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, size_t page_size, char* req_addr, bool exec);
9494
static bool commit_memory_special(size_t bytes, size_t page_size, char* req_addr, bool exec);
9595

9696
static bool release_memory_special_impl(char* base, size_t bytes);

‎src/hotspot/os/windows/os_windows.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3274,11 +3274,12 @@ bool os::can_execute_large_page_memory() {
32743274
return true;
32753275
}
32763276

3277-
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, char* addr,
3277+
char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, size_t page_size, char* addr,
32783278
bool exec) {
32793279
assert(UseLargePages, "only for large pages");
3280+
assert(page_size == os::large_page_size(), "Currently only support one large page size on Windows");
32803281

3281-
if (!is_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3282+
if (!is_aligned(bytes, page_size) || alignment > page_size) {
32823283
return NULL; // Fallback to small pages.
32833284
}
32843285

‎src/hotspot/share/memory/virtualspace.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -169,14 +169,14 @@ static char* reserve_memory(char* requested_address, const size_t size,
169169
}
170170

171171
static char* reserve_memory_special(char* requested_address, const size_t size,
172-
const size_t alignment, bool exec) {
172+
const size_t alignment, const size_t page_size, bool exec) {
173173

174174
log_trace(pagesize)("Attempt special mapping: size: " SIZE_FORMAT "%s, "
175175
"alignment: " SIZE_FORMAT "%s",
176176
byte_size_in_exact_unit(size), exact_unit_for_byte_size(size),
177177
byte_size_in_exact_unit(alignment), exact_unit_for_byte_size(alignment));
178178

179-
char* base = os::reserve_memory_special(size, alignment, requested_address, exec);
179+
char* base = os::reserve_memory_special(size, alignment, page_size, requested_address, exec);
180180
if (base != NULL) {
181181
// Check alignment constraints.
182182
assert(is_aligned(base, alignment),
@@ -236,7 +236,7 @@ void ReservedSpace::reserve(size_t size,
236236
// explicit large pages and these have to be committed up front to ensure
237237
// no reservations are lost.
238238

239-
char* base = reserve_memory_special(requested_address, size, alignment, executable);
239+
char* base = reserve_memory_special(requested_address, size, alignment, page_size, executable);
240240
if (base != NULL) {
241241
// Successful reservation using large pages.
242242
initialize_members(base, size, alignment, page_size, true, executable);

‎src/hotspot/share/runtime/os.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1890,12 +1890,12 @@ void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
18901890
pd_realign_memory(addr, bytes, alignment_hint);
18911891
}
18921892

1893-
char* os::reserve_memory_special(size_t size, size_t alignment,
1893+
char* os::reserve_memory_special(size_t size, size_t alignment, size_t page_size,
18941894
char* addr, bool executable) {
18951895

18961896
assert(is_aligned(addr, alignment), "Unaligned request address");
18971897

1898-
char* result = pd_reserve_memory_special(size, alignment, addr, executable);
1898+
char* result = pd_reserve_memory_special(size, alignment, page_size, addr, executable);
18991899
if (result != NULL) {
19001900
// The memory is committed
19011901
MemTracker::record_virtual_memory_reserve_and_commit((address)result, size, CALLER_PC);

‎src/hotspot/share/runtime/os.hpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -159,7 +159,8 @@ class os: AllStatic {
159159
static void pd_free_memory(char *addr, size_t bytes, size_t alignment_hint);
160160
static void pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint);
161161

162-
static char* pd_reserve_memory_special(size_t size, size_t alignment,
162+
static char* pd_reserve_memory_special(size_t size, size_t alignment, size_t page_size,
163+
163164
char* addr, bool executable);
164165
static bool pd_release_memory_special(char* addr, size_t bytes);
165166

@@ -428,7 +429,7 @@ class os: AllStatic {
428429

429430
static char* non_memory_address_word();
430431
// reserve, commit and pin the entire memory region
431-
static char* reserve_memory_special(size_t size, size_t alignment,
432+
static char* reserve_memory_special(size_t size, size_t alignment, size_t page_size,
432433
char* addr, bool executable);
433434
static bool release_memory_special(char* addr, size_t bytes);
434435
static void large_page_init();

‎test/hotspot/gtest/runtime/test_os_linux.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -47,8 +47,8 @@ namespace {
4747
char* const _ptr;
4848
const size_t _size;
4949
public:
50-
static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, char* req_addr, bool exec) {
51-
return os::Linux::reserve_memory_special_huge_tlbfs(bytes, alignment, req_addr, exec);
50+
static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, size_t page_size, char* req_addr, bool exec) {
51+
return os::Linux::reserve_memory_special_huge_tlbfs(bytes, alignment, page_size, req_addr, exec);
5252
}
5353
HugeTlbfsMemory(char* const ptr, size_t size) : _ptr(ptr), _size(size) { }
5454
~HugeTlbfsMemory() {
@@ -100,7 +100,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_aligned) {
100100
size_t lp = os::large_page_size();
101101

102102
for (size_t size = lp; size <= lp * 10; size += lp) {
103-
char* addr = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, lp, NULL, false);
103+
char* addr = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, lp, lp, NULL, false);
104104

105105
if (addr != NULL) {
106106
HugeTlbfsMemory mr(addr, size);
@@ -126,7 +126,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_without_add
126126
for (int i = 0; i < num_sizes; i++) {
127127
const size_t size = sizes[i];
128128
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
129-
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
129+
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, lp, NULL, false);
130130
if (p != NULL) {
131131
HugeTlbfsMemory mr(p, size);
132132
EXPECT_PRED2(is_ptr_aligned, p, alignment) << " size = " << size;
@@ -166,7 +166,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_with_good_r
166166
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
167167
// req_addr must be at least large page aligned.
168168
char* const req_addr = align_up(mapping, MAX2(alignment, lp));
169-
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
169+
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, lp, req_addr, false);
170170
if (p != NULL) {
171171
HugeTlbfsMemory mr(p, size);
172172
ASSERT_EQ(req_addr, p) << " size = " << size << ", alignment = " << alignment;
@@ -216,7 +216,7 @@ TEST_VM(os_linux, reserve_memory_special_huge_tlbfs_size_not_aligned_with_bad_re
216216
for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
217217
// req_addr must be at least large page aligned.
218218
char* const req_addr = align_up(mapping, MAX2(alignment, lp));
219-
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
219+
char* p = HugeTlbfsMemory::reserve_memory_special_huge_tlbfs(size, alignment, lp, req_addr, false);
220220
HugeTlbfsMemory mr(p, size);
221221
// as the area around req_addr contains already existing mappings, the API should always
222222
// return NULL (as per contract, it cannot return another address)
@@ -253,12 +253,12 @@ class TestReserveMemorySpecial : AllStatic {
253253
}
254254
}
255255

256-
static void test_reserve_memory_special_huge_tlbfs_size_aligned(size_t size, size_t alignment) {
256+
static void test_reserve_memory_special_huge_tlbfs_size_aligned(size_t size, size_t alignment, size_t page_size) {
257257
if (!UseHugeTLBFS) {
258258
return;
259259
}
260260

261-
char* addr = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
261+
char* addr = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, page_size, NULL, false);
262262

263263
if (addr != NULL) {
264264
small_page_write(addr, size);
@@ -275,7 +275,7 @@ class TestReserveMemorySpecial : AllStatic {
275275
size_t lp = os::large_page_size();
276276

277277
for (size_t size = lp; size <= lp * 10; size += lp) {
278-
test_reserve_memory_special_huge_tlbfs_size_aligned(size, lp);
278+
test_reserve_memory_special_huge_tlbfs_size_aligned(size, lp, lp);
279279
}
280280
}
281281

@@ -319,7 +319,7 @@ class TestReserveMemorySpecial : AllStatic {
319319
for (int i = 0; i < num_sizes; i++) {
320320
const size_t size = sizes[i];
321321
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
322-
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, NULL, false);
322+
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, lp, NULL, false);
323323
if (p != NULL) {
324324
EXPECT_TRUE(is_aligned(p, alignment));
325325
small_page_write(p, size);
@@ -334,7 +334,7 @@ class TestReserveMemorySpecial : AllStatic {
334334
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
335335
// req_addr must be at least large page aligned.
336336
char* const req_addr = align_up(mapping1, MAX2(alignment, lp));
337-
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
337+
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, lp, req_addr, false);
338338
if (p != NULL) {
339339
EXPECT_EQ(p, req_addr);
340340
small_page_write(p, size);
@@ -349,7 +349,7 @@ class TestReserveMemorySpecial : AllStatic {
349349
for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
350350
// req_addr must be at least large page aligned.
351351
char* const req_addr = align_up(mapping2, MAX2(alignment, lp));
352-
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, req_addr, false);
352+
char* p = os::Linux::reserve_memory_special_huge_tlbfs(size, alignment, lp, req_addr, false);
353353
// as the area around req_addr contains already existing mappings, the API should always
354354
// return NULL (as per contract, it cannot return another address)
355355
EXPECT_TRUE(p == NULL);

‎test/hotspot/gtest/runtime/test_os_windows.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ void TestReserveMemorySpecial_test() {
6464
FLAG_SET_CMDLINE(UseNUMAInterleaving, false);
6565

6666
const size_t large_allocation_size = os::large_page_size() * 4;
67-
char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
67+
char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), os::large_page_size(), NULL, false);
6868
if (result != NULL) {
6969
// failed to allocate memory, skipping the test
7070
return;
@@ -75,7 +75,7 @@ void TestReserveMemorySpecial_test() {
7575
// we managed to get it once.
7676
const size_t expected_allocation_size = os::large_page_size();
7777
char* expected_location = result + os::large_page_size();
78-
char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
78+
char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), os::large_page_size(), expected_location, false);
7979
if (actual_location != NULL) {
8080
// failed to allocate memory, skipping the test
8181
return;

0 commit comments

Comments
 (0)