test/hotspot/gtest/memory/test_virtualspace.cpp

rev 52125 : 8171097: Convert TestReservedSpace_test to Gtest
Reviewed-by: duke
rev 52126 : 8177709: Convert TestVirtualSpace_test to GTest
Reviewed-by: duke
rev 52127 : [mq]: 8177709-2
rev 52128 : [mq]: 8171097-2

@@ -27,27 +27,32 @@
 #include "oops/oop.hpp"
 #include "utilities/align.hpp"
 #include "unittest.hpp"
 
 namespace {
+  class MemoryReleaser {
+    ReservedSpace* const _rs;
+   public:
+    MemoryReleaser(ReservedSpace* rs) : _rs(rs) { }
+    ~MemoryReleaser() {
+      if (_rs->special()) {
+        EXPECT_TRUE(os::release_memory_special(_rs->base(), _rs->size()));
+      } else {
+        EXPECT_TRUE(os::release_memory(_rs->base(), _rs->size()));
+      }
+    }
+  };
+
   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()));
-    }
-  }
-
   // have to use these functions, as gtest's _PRED macros don't like is_aligned
   // nor (is_aligned<size_t, size_t>)
   static bool is_size_alignment(size_t size, size_t alignment) {
     return is_aligned(size, alignment);
   }

@@ -57,25 +62,25 @@
 
   static void test_reserved_size(size_t size) {
     ASSERT_PRED2(is_size_alignment, size, os::vm_allocation_granularity());
 
     ReservedSpace rs(size);
+    MemoryReleaser releaser(&rs);
 
     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(size_t size, size_t alignment) {
     ASSERT_PRED2(is_size_alignment, size, alignment) << "Incorrect input parameters";
 
     ReservedSpace rs(size, alignment, UseLargePages, (char *) NULL);
+    MemoryReleaser releaser(&rs);
 
     ASSERT_TRUE(rs.base() != NULL) << "rs.special = " << rs.special();
     ASSERT_EQ(size, rs.size()) << "rs.special = " << rs.special();
 
     EXPECT_PRED2(is_ptr_alignment, rs.base(), alignment)

@@ -84,12 +89,10 @@
             << "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_alignment_page_type(size_t size, size_t alignment, bool maybe_large) {
     if (size < alignment) {
       // Tests might set -XX:LargePageSizeInBytes=<small pages> and cause unexpected input arguments for this test.

@@ -101,19 +104,18 @@
     ASSERT_PRED2(is_size_alignment, size, alignment) << "Must be at least AG aligned";
 
     bool large = maybe_large && UseLargePages && size >= os::large_page_size();
 
     ReservedSpace rs(size, alignment, large, false);
+    MemoryReleaser releaser(&rs);
 
     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_VM(ReservedSpace, size_alignment) {
   size_t size = 2 * 1024 * 1024;

@@ -155,12 +157,18 @@
   EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 4,  ag * 2, false));
   EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 8,  ag * 2, false));
   EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 4,  ag * 4, false));
   EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 8,  ag * 4, false));
   EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 16, ag * 4, false));
+}
 
-  if (UseLargePages) {
+TEST_VM(ReservedSpace, size_alignment_page_type_large_page) {
+  if (!UseLargePages) {
+    return;
+  }
+
+  size_t ag = os::vm_allocation_granularity();
     size_t lp = os::large_page_size();
 
     // Without large pages
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp,     ag * 4, false));
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, ag * 4, false));

@@ -180,11 +188,10 @@
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp    , true));
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 3, lp    , true));
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp * 2, true));
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 4, lp * 2, true));
     EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 8, lp * 2, true));
-  }
 }
 
 namespace {
   enum TestLargePages {
     Default,