Skip to content

Commit

Permalink
removing some os version dependencies and variables
Browse files Browse the repository at this point in the history
  • Loading branch information
singhnitin authored and singhnitin committed Aug 16, 2024
1 parent 9e2adbc commit d61bc07
Show file tree
Hide file tree
Showing 3 changed files with 21 additions and 38 deletions.
2 changes: 1 addition & 1 deletion src/hotspot/os/windows/globals_windows.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@ product(bool, UseAllWindowsProcessorGroups, false, \
\
product(bool, EnableAllLargePageSizesForWindows, false, EXPERIMENTAL, \
"Enable support for multiple large page sizes on " \
"Windows 11/Windows Server 2022 and later") \
"Windows Server") \
\
product(bool, UseOSErrorReporting, false, \
"Let VM fatal error propagate to the OS (ie. WER on Windows)")
Expand Down
2 changes: 0 additions & 2 deletions src/hotspot/os/windows/os_windows.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3336,8 +3336,6 @@ size_t os::win32::large_page_init_decide_size() {
WARN("JVM cannot use large pages bigger than 4mb.");
return 0;
}
} else {
WARN("EnableAllLargePageSizesForWindows flag is ignored on Windows versions prior to Windows 11/Windows Server 2022 due to limited support.");
}
#endif
if (LargePageSizeInBytes > 0) {
Expand Down
55 changes: 20 additions & 35 deletions test/hotspot/gtest/runtime/test_os_windows.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -733,7 +733,6 @@ TEST_VM(os_windows, large_page_init_multiple_sizes) {
AutoSaveRestore<size_t> guardLargePageSizeInBytes(LargePageSizeInBytes);
FLAG_SET_CMDLINE(UseLargePages, true);
FLAG_SET_CMDLINE(EnableAllLargePageSizesForWindows, true);
bool is_supported_windows_version = true;

// Determine the minimum page size
const size_t min_size = GetLargePageMinimum();
Expand All @@ -751,35 +750,29 @@ TEST_VM(os_windows, large_page_init_multiple_sizes) {
os::large_page_init();

// Verify that large pages are enabled
if (is_supported_windows_version) {
EXPECT_TRUE(UseLargePages) << "UseLargePages should be true after initialization for LargePageSizeInBytes = 4 * min_size";
}
EXPECT_TRUE(UseLargePages) << "UseLargePages should be true after initialization for LargePageSizeInBytes = 4 * min_size";

// Verify that decided_large_page_size is greater than the default page size
const size_t default_page_size = os::vm_page_size();
size_t decided_large_page_size = os::win32::large_page_init_decide_size();
if (is_supported_windows_version) {
EXPECT_GT(decided_large_page_size, default_page_size) << "Large page size should be greater than the default page size for LargePageSizeInBytes = 4 * min_size";
}
EXPECT_GT(decided_large_page_size, default_page_size) << "Large page size should be greater than the default page size for LargePageSizeInBytes = 4 * min_size";

#if !defined(IA32)
if (is_supported_windows_version) {
size_t page_size_count = 0;
size_t page_size = os::page_sizes().largest();
size_t page_size_count = 0;
size_t page_size = os::page_sizes().largest();

do {
++page_size_count;
page_size = os::page_sizes().next_smaller(page_size);
} while (page_size >= os::page_sizes().smallest());
do {
++page_size_count;
page_size = os::page_sizes().next_smaller(page_size);
} while (page_size >= os::page_sizes().smallest());

EXPECT_GT(page_size_count, 1u) << "There should be multiple large page sizes available.";
EXPECT_GT(page_size_count, 1u) << "There should be multiple large page sizes available.";

size_t large_page_size = decided_large_page_size;
size_t large_page_size = decided_large_page_size;

for (size_t page_size = os::page_sizes().largest(); page_size >= min_size; page_size = os::page_sizes().next_smaller(page_size)) {
EXPECT_TRUE(page_size % min_size == 0) << "Each page size should be a multiple of the minimum large page size.";
EXPECT_LE(page_size, large_page_size) << "Page size should not exceed the determined large page size.";
}
for (size_t page_size = os::page_sizes().largest(); page_size >= min_size; page_size = os::page_sizes().next_smaller(page_size)) {
EXPECT_TRUE(page_size % min_size == 0) << "Each page size should be a multiple of the minimum large page size.";
EXPECT_LE(page_size, large_page_size) << "Page size should not exceed the determined large page size.";
}
#endif
}
Expand All @@ -793,16 +786,12 @@ TEST_VM(os_windows, large_page_init_decide_size) {
AutoSaveRestore<bool> guardUseLargePages(UseLargePages);
AutoSaveRestore<size_t> guardLargePageSizeInBytes(LargePageSizeInBytes);
FLAG_SET_CMDLINE(UseLargePages, true);
bool is_supported_windows_version = os::win32::is_windows_11_or_greater() ||
os::win32::is_windows_server_2022_or_greater();
FLAG_SET_CMDLINE(LargePageSizeInBytes, 0); // Reset to default

// Test for large page support
size_t decided_size = os::win32::large_page_init_decide_size();
size_t min_size = GetLargePageMinimum();
if (is_supported_windows_version && min_size == 0) {
EXPECT_EQ(decided_size, 0) << "Expected decided size to be 0 when large page is not supported by the processor";
}
EXPECT_EQ(decided_size, 0) << "Expected decided size to be 0 when large page is not supported by the processor";

// Scenario 1: Test with 2MB large page size
if (min_size == 2 * M) {
Expand All @@ -812,19 +801,17 @@ TEST_VM(os_windows, large_page_init_decide_size) {
}

// Scenario 2: Test with 1MB large page size
if (is_supported_windows_version && min_size == 2 * M) {
if (min_size == 2 * M) {
FLAG_SET_CMDLINE(LargePageSizeInBytes, 1 * M); // Set large page size to 1MB
decided_size = os::win32::large_page_init_decide_size(); // Recalculate decided size
EXPECT_EQ(decided_size, 2 * M) << "Expected decided size to be 2M when large page is 1M and OS reported size is 2M";
}

#if defined(IA32) || defined(AMD64)
if (!is_supported_windows_version) {
FLAG_SET_CMDLINE(LargePageSizeInBytes, 5 * M); // Set large page size to 5MB
if (!EnableAllLargePageSizesForWindows) {
decided_size = os::win32::large_page_init_decide_size(); // Recalculate decided size
EXPECT_EQ(decided_size, 0) << "Expected decided size to be 0 for large pages bigger than 4mb on IA32 or AMD64";
}
FLAG_SET_CMDLINE(LargePageSizeInBytes, 5 * M); // Set large page size to 5MB
if (!EnableAllLargePageSizesForWindows) {
decided_size = os::win32::large_page_init_decide_size(); // Recalculate decided size
EXPECT_EQ(decided_size, 0) << "Expected decided size to be 0 for large pages bigger than 4mb on IA32 or AMD64";
}
#endif

Expand All @@ -837,9 +824,7 @@ TEST_VM(os_windows, large_page_init_decide_size) {

// Assert that the decided size defaults to minimum page size when LargePageSizeInBytes
// is not a multiple of the minimum size, assuming conditions are always met
if(is_supported_windows_version) {
EXPECT_EQ(decided_size, min_size) << "Expected decided size to default to minimum large page size when LargePageSizeInBytes is not a multiple of minimum size";
}
EXPECT_EQ(decided_size, min_size) << "Expected decided size to default to minimum large page size when LargePageSizeInBytes is not a multiple of minimum size";
}

class ReserveMemorySpecialRunnable : public TestRunnable {
Expand Down

0 comments on commit d61bc07

Please sign in to comment.