# HG changeset patch # User kzhaldyb # Date 1481558992 -10800 # Mon Dec 12 19:09:52 2016 +0300 # Node ID 27ee6df77fb90716f706a9610884c6827b802a5e # Parent 777aaa19c4b11eda46e06b72c0a05fcb0145f5d6 8171097: Convert TestReserveMemorySpecial_test to Gtest Reviewed-by: duke diff --git a/src/share/vm/utilities/internalVMTests.cpp b/src/share/vm/utilities/internalVMTests.cpp --- a/src/share/vm/utilities/internalVMTests.cpp +++ b/src/share/vm/utilities/internalVMTests.cpp @@ -41,7 +41,6 @@ void InternalVMTests::run() { tty->print_cr("Running internal VM tests"); - run_unit_test(TestReservedSpace_test); run_unit_test(TestReserveMemorySpecial_test); run_unit_test(TestVirtualSpace_test); run_unit_test(TestMetaspaceAux_test); diff --git a/test/native/memory/test_virtualspace.cpp b/test/native/memory/test_virtualspace.cpp new file mode 100644 --- /dev/null +++ b/test/native/memory/test_virtualspace.cpp @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#include "precompiled.hpp" +#include "memory/virtualspace.hpp" +#include "oops/oop.inline.hpp" +#include "unittest.hpp" + +class ReservedSpaceTest { + public: + + static void small_page_write(void* addr, size_t size) { + size_t page_size = os::vm_page_size(); + + char* end = (char*) addr + size; + for (char* p = (char*) addr; p < end; p += page_size) { + *p = 1; + } + } + + static void release_memory_for_test(ReservedSpace rs) { + if (rs.special()) { + ASSERT_TRUE(os::release_memory_special(rs.base(), rs.size())); + } else { + ASSERT_TRUE(os::release_memory(rs.base(), rs.size())); + } + } + + static void test_reserved_size_alignment(size_t size, size_t alignment) { + ASSERT_TRUE(is_size_aligned(size, alignment)) + << "Incorrect input parameters: size " << size + << ", alignment " << alignment; + + ReservedSpace rs(size, alignment, UseLargePages, (char *) NULL); + + ASSERT_TRUE(rs.base() != NULL) << "rs.special = " << rs.special(); + ASSERT_EQ(size, rs.size()) << "rs.special = " << rs.special(); + + EXPECT_PRED2(is_ptr_aligned, rs.base(), alignment) + << "aligned sizes should always give aligned addresses"; + EXPECT_PRED2(is_ptr_aligned, (void*) rs.size(), alignment) + << "aligned sizes should always give aligned addresses"; + + if (rs.special()) { + small_page_write(rs.base(), size); + } + + release_memory_for_test(rs); + } + + static void test_reserved_size(size_t size) { + ASSERT_PRED2(is_size_aligned, size, os::vm_allocation_granularity()) + << "Must be at least AG aligned"; + + ReservedSpace rs(size); + + EXPECT_TRUE(rs.base() != NULL) << "rs.special: " << rs.special(); + EXPECT_EQ(size, rs.size()) << "rs.special: " << rs.special(); + + if (rs.special()) { + small_page_write(rs.base(), size); + } + + release_memory_for_test(rs); + } + + static void test_reserved_size_alignment_page_type(size_t size, size_t alignment, bool maybe_large) { + if (size < alignment) { + // Tests might set -XX:LargePageSizeInBytes= and cause unexpected input arguments for this test. + ASSERT_EQ((size_t) os::vm_page_size(), os::large_page_size()) << "Test needs further refinement"; + return; + } + + ASSERT_PRED2(is_size_aligned, size, os::vm_allocation_granularity()) << "Must be at least AG aligned"; + ASSERT_PRED2(is_size_aligned, size, alignment) << "Must be at least AG aligned"; + + bool large = maybe_large && UseLargePages && size >= os::large_page_size(); + + ReservedSpace rs(size, alignment, large, false); + + EXPECT_TRUE(rs.base() != NULL) << "rs.special: " << rs.special(); + EXPECT_EQ(size, rs.size()) << "rs.special: " << rs.special(); + + if (rs.special()) { + small_page_write(rs.base(), size); + } + + release_memory_for_test(rs); + } +}; + +TEST(ReservedSpace, size_alignment) { + size_t size = 2 * 1024 * 1024; + size_t ag = os::vm_allocation_granularity(); + + ReservedSpaceTest::test_reserved_size_alignment(size, ag); + ReservedSpaceTest::test_reserved_size_alignment(size * 2, ag); + ReservedSpaceTest::test_reserved_size_alignment(size * 10, ag); +} + +TEST(ReservedSpace, size) { + + size_t size = 2 * 1024 * 1024; + size_t ag = os::vm_allocation_granularity(); + + ReservedSpaceTest::test_reserved_size(size * 1); + ReservedSpaceTest::test_reserved_size(size * 2); + ReservedSpaceTest::test_reserved_size(size * 10); + ReservedSpaceTest::test_reserved_size(ag); + ReservedSpaceTest::test_reserved_size(size - ag); + ReservedSpaceTest::test_reserved_size(size); + ReservedSpaceTest::test_reserved_size(size + ag); + ReservedSpaceTest::test_reserved_size(size * 2); + ReservedSpaceTest::test_reserved_size(size * 2 - ag); + ReservedSpaceTest::test_reserved_size(size * 2 + ag); + ReservedSpaceTest::test_reserved_size(size * 3); + ReservedSpaceTest::test_reserved_size(size * 3 - ag); + ReservedSpaceTest::test_reserved_size(size * 3 + ag); + ReservedSpaceTest::test_reserved_size(size * 10); + ReservedSpaceTest::test_reserved_size(size * 10 + size / 2); + } + + +TEST(ReservedSpace, size_alignment_page_type) { + size_t ag = os::vm_allocation_granularity(); + + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag, ag , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 2, ag , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 3, ag , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 2, ag * 2, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 4, ag * 2, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 8, ag * 2, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 4, ag * 4, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 8, ag * 4, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(ag * 16, ag * 4, false); + + if (UseLargePages) { + size_t lp = os::large_page_size(); + + // Without large pages + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp, ag * 4, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, ag * 4, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 4, ag * 4, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp, lp , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, lp , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 3, lp , false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, lp * 2, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 4, lp * 2, false); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 8, lp * 2, false); + + // With large pages + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp, ag * 4 , true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, ag * 4, true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 4, ag * 4, true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp, lp , true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, lp , true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 3, lp , true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 2, lp * 2, true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 4, lp * 2, true); + ReservedSpaceTest::test_reserved_size_alignment_page_type(lp * 8, lp * 2, true); + } +}