changeset 12190:817bb013257f

Merge
author kzhaldyb
date Wed, 19 Oct 2016 12:10:43 +0200
parents efcbf5de754e b426373a34a3
children 5fd2019b77bd 7e0181d2ca46
files
diffstat 7 files changed, 244 insertions(+), 153 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/vm/memory/guardedMemory.cpp	Thu Oct 06 16:32:46 2016 +0200
+++ b/src/share/vm/memory/guardedMemory.cpp	Wed Oct 19 12:10:43 2016 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -79,87 +79,3 @@
     break;
   }
 }
-
-// test code...
-
-#ifndef PRODUCT
-
-static void guarded_memory_test_check(void* p, size_t sz, void* tag) {
-  assert(p != NULL, "NULL pointer given to check");
-  u_char* c = (u_char*) p;
-  GuardedMemory guarded(c);
-  assert(guarded.get_tag() == tag, "Tag is not the same as supplied");
-  assert(guarded.get_user_ptr() == c, "User pointer is not the same as supplied");
-  assert(guarded.get_user_size() == sz, "User size is not the same as supplied");
-  assert(guarded.verify_guards(), "Guard broken");
-}
-
-void GuardedMemory::test_guarded_memory() {
-  // Test the basic characteristics...
-  size_t total_sz = GuardedMemory::get_total_size(1);
-  assert(total_sz > 1 && total_sz >= (sizeof(GuardHeader) + 1 + sizeof(Guard)), "Unexpected size");
-  u_char* basep = (u_char*) os::malloc(total_sz, mtInternal);
-
-  GuardedMemory guarded(basep, 1, (void*)0xf000f000);
-
-  assert(*basep == badResourceValue, "Expected guard in the form of badResourceValue");
-  u_char* userp = guarded.get_user_ptr();
-  assert(*userp == uninitBlockPad, "Expected uninitialized data in the form of uninitBlockPad");
-  guarded_memory_test_check(userp, 1, (void*)0xf000f000);
-
-  void* freep = guarded.release_for_freeing();
-  assert((u_char*)freep == basep, "Expected the same pointer guard was ");
-  assert(*userp == freeBlockPad, "Expected user data to be free block padded");
-  assert(!guarded.verify_guards(), "Expected failed");
-  os::free(freep);
-
-  // Test a number of odd sizes...
-  size_t sz = 0;
-  do {
-    void* p = os::malloc(GuardedMemory::get_total_size(sz), mtInternal);
-    void* up = guarded.wrap_with_guards(p, sz, (void*)1);
-    memset(up, 0, sz);
-    guarded_memory_test_check(up, sz, (void*)1);
-    os::free(guarded.release_for_freeing());
-    sz = (sz << 4) + 1;
-  } while (sz < (256 * 1024));
-
-  // Test buffer overrun into head...
-  basep = (u_char*) os::malloc(GuardedMemory::get_total_size(1), mtInternal);
-  guarded.wrap_with_guards(basep, 1);
-  *basep = 0;
-  assert(!guarded.verify_guards(), "Expected failure");
-  os::free(basep);
-
-  // Test buffer overrun into tail with a number of odd sizes...
-  sz = 1;
-  do {
-    void* p = os::malloc(GuardedMemory::get_total_size(sz), mtInternal);
-    void* up = guarded.wrap_with_guards(p, sz, (void*)1);
-    memset(up, 0, sz + 1); // Buffer-overwrite (within guard)
-    assert(!guarded.verify_guards(), "Guard was not broken as expected");
-    os::free(guarded.release_for_freeing());
-    sz = (sz << 4) + 1;
-  } while (sz < (256 * 1024));
-
-  // Test wrap_copy/wrap_free...
-  assert(GuardedMemory::free_copy(NULL), "Expected free NULL to be OK");
-
-  const char* str = "Check my bounds out";
-  size_t str_sz = strlen(str) + 1;
-  char* str_copy = (char*) GuardedMemory::wrap_copy(str, str_sz);
-  guarded_memory_test_check(str_copy, str_sz, NULL);
-  assert(strcmp(str, str_copy) == 0, "Not identical copy");
-  assert(GuardedMemory::free_copy(str_copy), "Free copy failed to verify");
-
-  void* no_data = NULL;
-  void* no_data_copy = GuardedMemory::wrap_copy(no_data, 0);
-  assert(GuardedMemory::free_copy(no_data_copy), "Expected valid guards even for no data copy");
-}
-
-void GuardedMemory_test() {
-  GuardedMemory::test_guarded_memory();
-}
-
-#endif // !PRODUCT
-
--- a/src/share/vm/memory/guardedMemory.hpp	Thu Oct 06 16:32:46 2016 +0200
+++ b/src/share/vm/memory/guardedMemory.hpp	Wed Oct 19 12:10:43 2016 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -82,6 +82,7 @@
  */
 class GuardedMemory : StackObj { // Wrapper on stack
 
+  friend class GuardedMemoryTest;
   // Private inner classes for memory layout...
 
 protected:
@@ -317,10 +318,6 @@
    */
   static bool free_copy(void* p);
 
-  // Testing...
-#ifndef PRODUCT
-  static void test_guarded_memory(void);
-#endif
 }; // GuardedMemory
 
 #endif // SHARE_VM_MEMORY_GUARDEDMEMORY_HPP
--- a/src/share/vm/memory/metachunk.cpp	Thu Oct 06 16:32:46 2016 +0200
+++ b/src/share/vm/memory/metachunk.cpp	Wed Oct 19 12:10:43 2016 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -111,61 +111,3 @@
   return;
 }
 
-/////////////// Unit tests ///////////////
-
-#ifndef PRODUCT
-
-class TestMetachunk {
- public:
-  static void test() {
-    size_t size = 2 * 1024 * 1024;
-    void* memory = malloc(size);
-    assert(memory != NULL, "Failed to malloc 2MB");
-
-    Metachunk* metachunk = ::new (memory) Metachunk(size / BytesPerWord, NULL);
-
-    assert(metachunk->bottom() == (MetaWord*)metachunk, "assert");
-    assert(metachunk->end() == (uintptr_t*)metachunk + metachunk->size(), "assert");
-
-    // Check sizes
-    assert(metachunk->size() == metachunk->word_size(), "assert");
-    assert(metachunk->word_size() == pointer_delta(metachunk->end(), metachunk->bottom(),
-        sizeof(MetaWord*)), "assert");
-
-    // Check usage
-    assert(metachunk->used_word_size() == metachunk->overhead(), "assert");
-    assert(metachunk->free_word_size() == metachunk->word_size() - metachunk->used_word_size(), "assert");
-    assert(metachunk->top() == metachunk->initial_top(), "assert");
-    assert(metachunk->is_empty(), "assert");
-
-    // Allocate
-    size_t alloc_size = 64; // Words
-    assert(is_size_aligned(alloc_size, Metachunk::object_alignment()), "assert");
-
-    MetaWord* mem = metachunk->allocate(alloc_size);
-
-    // Check post alloc
-    assert(mem == metachunk->initial_top(), "assert");
-    assert(mem + alloc_size == metachunk->top(), "assert");
-    assert(metachunk->used_word_size() == metachunk->overhead() + alloc_size, "assert");
-    assert(metachunk->free_word_size() == metachunk->word_size() - metachunk->used_word_size(), "assert");
-    assert(!metachunk->is_empty(), "assert");
-
-    // Clear chunk
-    metachunk->reset_empty();
-
-    // Check post clear
-    assert(metachunk->used_word_size() == metachunk->overhead(), "assert");
-    assert(metachunk->free_word_size() == metachunk->word_size() - metachunk->used_word_size(), "assert");
-    assert(metachunk->top() == metachunk->initial_top(), "assert");
-    assert(metachunk->is_empty(), "assert");
-
-    free(memory);
-  }
-};
-
-void TestMetachunk_test() {
-  TestMetachunk::test();
-}
-
-#endif
--- a/src/share/vm/memory/metachunk.hpp	Thu Oct 06 16:32:46 2016 +0200
+++ b/src/share/vm/memory/metachunk.hpp	Wed Oct 19 12:10:43 2016 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -95,7 +95,7 @@
 //            +--------------+ <- bottom --+       --+
 
 class Metachunk : public Metabase<Metachunk> {
-  friend class TestMetachunk;
+  friend class MetachunkTest;
   // The VirtualSpaceNode containing this chunk.
   VirtualSpaceNode* _container;
 
--- a/src/share/vm/utilities/internalVMTests.cpp	Thu Oct 06 16:32:46 2016 +0200
+++ b/src/share/vm/utilities/internalVMTests.cpp	Wed Oct 19 12:10:43 2016 +0200
@@ -48,13 +48,11 @@
   run_unit_test(TestReserveMemorySpecial_test);
   run_unit_test(TestVirtualSpace_test);
   run_unit_test(TestMetaspaceAux_test);
-  run_unit_test(TestMetachunk_test);
   run_unit_test(TestVirtualSpaceNode_test);
   run_unit_test(TestGlobalDefinitions_test);
   run_unit_test(GCTimer_test);
   run_unit_test(CollectedHeap_test);
   run_unit_test(QuickSort_test);
-  run_unit_test(GuardedMemory_test);
   run_unit_test(TestNewSize_test);
   run_unit_test(TestOldSize_test);
   run_unit_test(TestBitMap_test);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/native/memory/test_guardedMemory.cpp	Wed Oct 19 12:10:43 2016 +0200
@@ -0,0 +1,148 @@
+/*
+ * 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/allocation.hpp"
+#include "memory/allocation.inline.hpp"
+#include "memory/guardedMemory.hpp"
+#include "runtime/os.hpp"
+#include "unittest.hpp"
+
+static void guarded_memory_test_check(void* p, size_t sz, void* tag) {
+  ASSERT_TRUE(p != NULL) << "NULL pointer given to check";
+  u_char* c = (u_char*) p;
+  GuardedMemory guarded(c);
+  EXPECT_EQ(guarded.get_tag(), tag) << "Tag is not the same as supplied";
+  EXPECT_EQ(guarded.get_user_ptr(), c) << "User pointer is not the same as supplied";
+  EXPECT_EQ(guarded.get_user_size(), sz) << "User size is not the same as supplied";
+  EXPECT_TRUE(guarded.verify_guards()) << "Guard broken";
+}
+
+class GuardedMemoryTest {
+ public:
+  static size_t get_guard_header_size() {
+    return sizeof (GuardedMemory::GuardHeader);
+  }
+  static size_t get_guard_size() {
+    return sizeof (GuardedMemory::Guard);
+  }
+};
+
+// Test GuardedMemory size
+TEST(GuardedMemory, size) {
+  size_t total_sz = GuardedMemory::get_total_size(1);
+  ASSERT_GT(total_sz, (size_t) 1) << "Unexpected size";
+  ASSERT_GE(total_sz, GuardedMemoryTest::get_guard_header_size() + 1
+          + GuardedMemoryTest::get_guard_size()) << "Unexpected size";
+}
+
+// Test the basic characteristics
+TEST(GuardedMemory, basic) {
+  u_char* basep =
+          (u_char*) os::malloc(GuardedMemory::get_total_size(1), mtInternal);
+  GuardedMemory guarded(basep, 1, (void*) 0xf000f000);
+
+  EXPECT_EQ(badResourceValue, *basep)
+          << "Expected guard in the form of badResourceValue";
+
+  u_char* userp = guarded.get_user_ptr();
+  EXPECT_EQ(uninitBlockPad, *userp)
+          << "Expected uninitialized data in the form of uninitBlockPad";
+  guarded_memory_test_check(userp, 1, (void*) 0xf000f000);
+
+  void* freep = guarded.release_for_freeing();
+  EXPECT_EQ((u_char*) freep, basep) << "Expected the same pointer guard was ";
+  EXPECT_EQ(freeBlockPad, *userp) << "Expected user data to be free block padded";
+  EXPECT_FALSE(guarded.verify_guards());
+  os::free(freep);
+}
+
+// Test a number of odd sizes
+TEST(GuardedMemory, odd_sizes) {
+  u_char* basep =
+          (u_char*) os::malloc(GuardedMemory::get_total_size(1), mtInternal);
+  GuardedMemory guarded(basep, 1, (void*) 0xf000f000);
+
+  size_t sz = 0;
+  do {
+    void* p = os::malloc(GuardedMemory::get_total_size(sz), mtInternal);
+    void* up = guarded.wrap_with_guards(p, sz, (void*) 1);
+    memset(up, 0, sz);
+    guarded_memory_test_check(up, sz, (void*) 1);
+    if (HasFatalFailure()) {
+      return;
+    }
+
+    os::free(guarded.release_for_freeing());
+    sz = (sz << 4) + 1;
+  } while (sz < (256 * 1024));
+}
+
+// Test buffer overrun into head...
+TEST(GuardedMemory, buffer_overrun_head) {
+  u_char* basep =
+          (u_char*) os::malloc(GuardedMemory::get_total_size(1), mtInternal);
+  GuardedMemory guarded(basep, 1, (void*) 0xf000f000);
+
+  guarded.wrap_with_guards(basep, 1);
+  *basep = 0;
+  EXPECT_FALSE(guarded.verify_guards());
+  os::free(basep);
+}
+
+// Test buffer overrun into tail with a number of odd sizes
+TEST(GuardedMemory, buffer_overrun_tail) {
+  u_char* basep =
+          (u_char*) os::malloc(GuardedMemory::get_total_size(1), mtInternal);
+  GuardedMemory guarded(basep, 1, (void*) 0xf000f000);
+
+  size_t sz = 1;
+  do {
+    void* p = os::malloc(GuardedMemory::get_total_size(sz), mtInternal);
+    void* up = guarded.wrap_with_guards(p, sz, (void*) 1);
+    memset(up, 0, sz + 1); // Buffer-overwrite (within guard)
+    EXPECT_FALSE(guarded.verify_guards()) << "Guard was not broken as expected";
+    os::free(guarded.release_for_freeing());
+    sz = (sz << 4) + 1;
+  } while (sz < (256 * 1024));
+}
+
+// Test wrap_copy/wrap_free
+TEST(GuardedMemory, wrap) {
+  EXPECT_TRUE(GuardedMemory::free_copy(NULL)) << "Expected free NULL to be OK";
+
+  const char* str = "Check my bounds out";
+  size_t str_sz = strlen(str) + 1;
+  char* str_copy = (char*) GuardedMemory::wrap_copy(str, str_sz);
+  guarded_memory_test_check(str_copy, str_sz, NULL);
+  if (HasFatalFailure()) {
+    return;
+  }
+  EXPECT_EQ(0, strcmp(str, str_copy)) << "Not identical copy";
+  EXPECT_TRUE(GuardedMemory::free_copy(str_copy)) << "Free copy failed to verify";
+
+  void* no_data = NULL;
+  void* no_data_copy = GuardedMemory::wrap_copy(no_data, 0);
+  EXPECT_TRUE(GuardedMemory::free_copy(no_data_copy))
+          << "Expected valid guards even for no data copy";
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/native/memory/test_metachunk.cpp	Wed Oct 19 12:10:43 2016 +0200
@@ -0,0 +1,90 @@
+/*
+ * 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/allocation.hpp"
+#include "memory/metachunk.hpp"
+#include "unittest.hpp"
+#include "utilities/copy.hpp"
+#include "utilities/debug.hpp"
+
+class MetachunkTest {
+ public:
+  static MetaWord* initial_top(Metachunk* metachunk) {
+    return metachunk->initial_top();
+  }
+  static MetaWord* top(Metachunk* metachunk) {
+    return metachunk->top();
+  }
+
+};
+
+TEST(Metachunk, basic) {
+  size_t size = 2 * 1024 * 1024;
+  void* memory = malloc(size);
+  ASSERT_TRUE(NULL != memory) << "Failed to malloc 2MB";
+
+  Metachunk* metachunk = ::new (memory) Metachunk(size / BytesPerWord, NULL);
+
+  EXPECT_EQ((MetaWord*) metachunk, metachunk->bottom());
+  EXPECT_EQ((uintptr_t*) metachunk + metachunk->size(), metachunk->end());
+
+  // Check sizes
+  EXPECT_EQ(metachunk->size(), metachunk->word_size());
+  EXPECT_EQ(pointer_delta(metachunk->end(), metachunk->bottom(),
+                sizeof (MetaWord*)),
+            metachunk->word_size());
+
+  // Check usage
+  EXPECT_EQ(metachunk->used_word_size(), metachunk->overhead());
+  EXPECT_EQ(metachunk->word_size() - metachunk->used_word_size(),
+            metachunk->free_word_size());
+  EXPECT_EQ(MetachunkTest::top(metachunk), MetachunkTest::initial_top(metachunk));
+  EXPECT_TRUE(metachunk->is_empty());
+
+  // Allocate
+  size_t alloc_size = 64; // Words
+  EXPECT_TRUE(is_size_aligned(alloc_size, Metachunk::object_alignment()));
+
+  MetaWord* mem = metachunk->allocate(alloc_size);
+
+  // Check post alloc
+  EXPECT_EQ(MetachunkTest::initial_top(metachunk), mem);
+  EXPECT_EQ(MetachunkTest::top(metachunk), mem + alloc_size);
+  EXPECT_EQ(metachunk->overhead() + alloc_size, metachunk->used_word_size());
+  EXPECT_EQ(metachunk->word_size() - metachunk->used_word_size(),
+            metachunk->free_word_size());
+  EXPECT_FALSE(metachunk->is_empty());
+
+  // Clear chunk
+  metachunk->reset_empty();
+
+  // Check post clear
+  EXPECT_EQ(metachunk->used_word_size(), metachunk->overhead());
+  EXPECT_EQ(metachunk->word_size() - metachunk->used_word_size(),
+            metachunk->free_word_size());
+  EXPECT_EQ(MetachunkTest::top(metachunk), MetachunkTest::initial_top(metachunk));
+  EXPECT_TRUE(metachunk->is_empty());
+
+  free(memory);
+}