archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-23 04:24:49 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8066875: VirtualSpace does not use large pages

Browse source 
Reviewed-by: stefank, tschatzl, anoll, thartmann
This commit is contained in:
Erik Helin 2015-01-16 10:29:12 +01:00
parent 71d4cfb1ad
commit 86f95c464f
8 changed files with 71 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

60
hotspot/src/share/vm/runtime/os.cpp
View file

@ -1399,15 +1399,17 @@ bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) {
return (sp > (stack_limit + reserved_area));
}
size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
size_t os::page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned) {
assert(min_pages > 0, "sanity");
if (UseLargePages) {
const size_t max_page_size = region_size / min_pages;
for (size_t i = 0; _page_sizes[i] != 0; ++i) {
const size_t page_size = _page_sizes[i];
if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) {
return page_size;
if (page_size <= max_page_size) {
if (!must_be_aligned || is_size_aligned(region_size, page_size)) {
return page_size;
}
}
}
}
@ -1415,6 +1417,14 @@ size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
return vm_page_size();
}
size_t os::page_size_for_region_aligned(size_t region_size, size_t min_pages) {
return page_size_for_region(region_size, min_pages, true);
}
size_t os::page_size_for_region_unaligned(size_t region_size, size_t min_pages) {
return page_size_for_region(region_size, min_pages, false);
}
#ifndef PRODUCT
void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
{
@ -1663,17 +1673,17 @@ class TestOS : AllStatic {
static size_t large_page_size() {
const size_t large_page_size_example = 4 * M;
return os::page_size_for_region(large_page_size_example, 1);
return os::page_size_for_region_aligned(large_page_size_example, 1);
}
static void test_page_size_for_region() {
static void test_page_size_for_region_aligned() {
if (UseLargePages) {
const size_t small_page = small_page_size();
const size_t large_page = large_page_size();
if (large_page > small_page) {
size_t num_small_pages_in_large = large_page / small_page;
size_t page = os::page_size_for_region(large_page, num_small_pages_in_large);
size_t page = os::page_size_for_region_aligned(large_page, num_small_pages_in_large);
assert_eq(page, small_page);
}
@ -1686,21 +1696,53 @@ class TestOS : AllStatic {
const size_t large_page = large_page_size();
if (large_page > small_page) {
const size_t unaligned_region = large_page + 17;
size_t page = os::page_size_for_region(unaligned_region, 1);
size_t page = os::page_size_for_region_aligned(unaligned_region, 1);
assert_eq(page, small_page);
const size_t num_pages = 5;
const size_t aligned_region = large_page * num_pages;
page = os::page_size_for_region(aligned_region, num_pages);
page = os::page_size_for_region_aligned(aligned_region, num_pages);
assert_eq(page, large_page);
}
}
}
static void test_page_size_for_region_unaligned() {
if (UseLargePages) {
// Given exact page size, should return that page size.
for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
size_t expected = os::_page_sizes[i];
size_t actual = os::page_size_for_region_unaligned(expected, 1);
assert_eq(expected, actual);
}
// Given slightly larger size than a page size, return the page size.
for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
size_t expected = os::_page_sizes[i];
size_t actual = os::page_size_for_region_unaligned(expected + 17, 1);
assert_eq(expected, actual);
}
// Given a slightly smaller size than a page size,
// return the next smaller page size.
if (os::_page_sizes[1] > os::_page_sizes[0]) {
size_t expected = os::_page_sizes[0];
size_t actual = os::page_size_for_region_unaligned(os::_page_sizes[1] - 17, 1);
assert_eq(actual, expected);
}
// Return small page size for values less than a small page.
size_t small_page = small_page_size();
size_t actual = os::page_size_for_region_unaligned(small_page - 17, 1);
assert_eq(small_page, actual);
}
}
public:
static void run_tests() {
test_page_size_for_region();
test_page_size_for_region_aligned();
test_page_size_for_region_alignment();
test_page_size_for_region_unaligned();
}
};