wip

Author: tstuefe

src/hotspot/share/memory/metaspace/binList.hpp

@@ -96,6 +96,9 @@ class BinListImpl {
   // Maximal (incl) word size a block can have to be manageable by this structure.
   const static size_t MaxWordSize = num_lists;
 
+  // for tests
+  static constexpr size_t header_wordsize = sizeof(Block) / BytesPerWord;
+
 private:
 
   Block* _blocks[num_lists];
@@ -132,9 +135,9 @@ class BinListImpl {
     }
   }
   static bool check_block_zap(const Block* b, size_t word_size) {
-    return word_size == 1 || // 1-word-sized blocks have no space for a canary
-           ( Zapper::is_zapped_location(b->base() + 1) &&
-             Zapper::is_zapped_location(b->base() + word_size - 1) );
+    return word_size <= header_wordsize || // 1-word-sized blocks have no space for a canary
+           ( Zapper::is_zapped_location(b->base() + header_wordsize) &&
+             Zapper::is_zapped_location(b->base() + word_size - header_wordsize) );
   }
 #endif
 

src/hotspot/share/memory/metaspace/blockTree.hpp

@@ -128,7 +128,6 @@ class BlockTree: public CHeapObj<mtMetaspace> {
   };
 
   STATIC_ASSERT(is_aligned(sizeof(Node), sizeof(MetaWord)));
-  static constexpr size_t node_header_wordsize = sizeof(Node) / sizeof(MetaWord);
 
   // Needed for verify() and print_tree()
   struct walkinfo;
@@ -140,9 +139,12 @@ class BlockTree: public CHeapObj<mtMetaspace> {
 
 public:
 
+  // Public only for tests
+  static constexpr size_t header_wordsize = sizeof(Node) / sizeof(MetaWord);
+
   // Minimum word size a block has to be to be added to this structure
   // (Node size + at least one word; smaller blocks -> BinList)
-  constexpr static size_t MinWordSize = node_header_wordsize + 1;
+  constexpr static size_t MinWordSize = header_wordsize + 1;
 
 private:
 

test/hotspot/gtest/metaspace/metaspaceGtestCommon.cpp

@@ -25,6 +25,7 @@
 
 #include "metaspaceGtestCommon.hpp"
 #include "metaspaceGtestRangeHelpers.hpp"
+#include "memory/metaspace/metaspaceZapper.hpp"
 #include "runtime/os.hpp"
 
 void zap_range(MetaWord* p, size_t word_size) {
@@ -95,3 +96,14 @@ void check_marked_range(const MetaWord* p, size_t word_size) {
   check_marked_range(p, word_size, pattern);
 }
 
+// using metaspace zapper
+
+#ifdef ASSERT
+// Helper function checks if region x is zapped
+void check_metaspace_zap(const MetaWord* start, size_t size) {
+  size_t interval = MAX(1, size / 256);
+  for (const MetaWord* p = start; p < start + size; p += interval) {
+    ASSERT_TRUE(metaspace::Zapper::is_zapped_location(p));
+  }
+}
+#endif

test/hotspot/gtest/metaspace/metaspaceGtestCommon.hpp

@@ -216,4 +216,7 @@ class FeederBuffer {
 
 };
 
+// Check an area for being zapped with the metaspace zap pattern
+DEBUG_ONLY(void check_metaspace_zap(const MetaWord* start, size_t size);)
+
 #endif // GTEST_METASPACE_METASPACEGTESTCOMMON_HPP

test/hotspot/gtest/metaspace/test_binlist.cpp

@@ -57,6 +57,13 @@ struct TestedBinList : public BinListImpl<num_lists> {
   }
 };
 
+#ifdef ASSERT
+template <class BINLISTTYPE>
+void check_block_zap(const MetaWord* p, size_t size) {
+  check_metaspace_zap(p + BINLISTTYPE::header_wordsize, size - BINLISTTYPE::header_wordsize);
+}
+#endif
+
 template <class BINLISTTYPE>
 struct BinListBasicTest {
 
@@ -89,6 +96,7 @@ struct BinListBasicTest {
     EXPECT_EQ(p, arr);
     EXPECT_EQ((size_t)innocous_size, real_size);
     CHECK_BL_CONTENT(bl, 0, 0);
+    DEBUG_ONLY(check_block_zap<BINLISTTYPE>(p, real_size);)
     DEBUG_ONLY(bl.verify();)
 
   }
@@ -114,6 +122,7 @@ struct BinListBasicTest {
           EXPECT_EQ(p, arr);
           EXPECT_EQ((size_t)s1, real_size);
           CHECK_BL_CONTENT(bl, 0, 0);
+          DEBUG_ONLY(check_block_zap<BINLISTTYPE>(p, real_size);)
           DEBUG_ONLY(bl.verify();)
         } else {
           EXPECT_EQ(p, (MetaWord*)nullptr);
@@ -125,6 +134,7 @@ struct BinListBasicTest {
           EXPECT_EQ(p, arr);
           EXPECT_EQ((size_t)s1, real_size);
           CHECK_BL_CONTENT(bl, 0, 0);
+          DEBUG_ONLY(check_block_zap<BINLISTTYPE>(p, real_size);)
         }
       }
     }

test/hotspot/gtest/metaspace/test_blocktree.cpp

@@ -33,6 +33,7 @@
 using metaspace::BlockTree;
 using metaspace::MemRangeCounter;
 using metaspace::MetaBlock;
+using metaspace::Zapper;
 
 struct TestedBlockTree : public BlockTree {
   void add_block(MetaWord* p, size_t word_size) {
@@ -65,6 +66,12 @@ static void create_nodes(const size_t sizes[], FeederBuffer& fb, TestedBlockTree
   } \
 }
 
+#ifdef ASSERT
+void check_node_zap(const MetaWord* p, size_t size) {
+  check_metaspace_zap(p + BlockTree::header_wordsize, size - BlockTree::header_wordsize);
+}
+#endif
+
 TEST_VM(metaspace, BlockTree_basic) {
 
   TestedBlockTree bt;
@@ -94,14 +101,17 @@ TEST_VM(metaspace, BlockTree_basic) {
   };
 
   for (int i = 0; sizes[i] > 0; i++) {
+    DEBUG_ONLY(memset(arr, 0, sizes[i]);)
     bt.add_block(arr, sizes[i]);
     CHECK_BT_CONTENT(bt, 1, sizes[i]);
+    DEBUG_ONLY(check_node_zap(arr, sizes[i]);)
 
     DEBUG_ONLY(bt.verify();)
 
     MetaWord* p = bt.remove_block(sizes[i], &real_size);
     EXPECT_EQ(p, arr);
     EXPECT_EQ(real_size, (size_t)sizes[i]);
+    DEBUG_ONLY(check_node_zap(p, sizes[i]);)
     CHECK_BT_CONTENT(bt, 0, 0);
   }
 
@@ -138,6 +148,7 @@ static void test_find_nearest_fit_with_tree(const size_t sizes[], size_t request
   if (expected_size != SIZE_MAX) {
     EXPECT_NOT_NULL(p);
     EXPECT_EQ(real_size, expected_size);
+    DEBUG_ONLY(check_node_zap(p, real_size);)
   } else {
     EXPECT_NULL(p);
     EXPECT_0(real_size);

test/hotspot/gtest/metaspace/test_metachunk.cpp

@@ -427,3 +427,20 @@ TEST_VM(metaspace, chunk_enlarge_in_place) {
 
 }
 
+#ifdef ASSERT
+// Test ChunkManager::get_chunk
+TEST_VM(metaspace, chunk_zap) {
+  ChunkGtestContext context;
+  Metachunk* c = nullptr;
+  RandSizeGenerator rand(1, K);
+  for (chunklevel_t l = LOWEST_CHUNK_LEVEL; l < HIGHEST_CHUNK_LEVEL; l++) {
+    context.alloc_chunk_expect_success(&c, HIGHEST_CHUNK_LEVEL);
+    for (size_t s = 0; s < c->word_size(); s += rand.get()) {
+      c->ensure_committed(s);
+      c->zap();
+      check_metaspace_zap(c->base(), c->committed_words());
+    }
+    context.return_chunk(c);
+  }
+}
+#endif