test/hotspot/gtest/metaspace/test_blocktree.cpp

@@ -24,20 +24,33 @@
   */
  
  #include "precompiled.hpp"
  #include "memory/metaspace/blockTree.hpp"
  #include "memory/metaspace/counters.hpp"
+ #include "memory/metaspace/metablock.hpp"
  #include "memory/resourceArea.hpp"
  // #define LOG_PLEASE
  #include "metaspaceGtestCommon.hpp"
  
  using metaspace::BlockTree;
  using metaspace::MemRangeCounter;
+ using metaspace::MetaBlock;
+ 
+ struct TestedBlockTree : public BlockTree {
+   void add_block(MetaWord* p, size_t word_size) {
+     BlockTree::add_block(MetaBlock(p, word_size));
+   }
+   MetaWord* remove_block(size_t requested_size, size_t* real_size) {
+     MetaBlock result = BlockTree::remove_block(requested_size);
+     (*real_size) = result.word_size();
+     return result.base();
+   }
+ };
  
  // Small helper. Given a 0-terminated array of sizes, a feeder buffer and a tree,
  //  add blocks of these sizes to the tree in the order they appear in the array.
- static void create_nodes(const size_t sizes[], FeederBuffer& fb, BlockTree& bt) {
+ static void create_nodes(const size_t sizes[], FeederBuffer& fb, TestedBlockTree& bt) {
    for (int i = 0; sizes[i] > 0; i ++) {
      size_t s = sizes[i];
      MetaWord* p = fb.get(s);
      bt.add_block(p, s);
    }

@@ -53,11 +66,11 @@
    } \
  }
  
  TEST_VM(metaspace, BlockTree_basic) {
  
-   BlockTree bt;
+   TestedBlockTree bt;
    CHECK_BT_CONTENT(bt, 0, 0);
  
    size_t real_size = 0;
    MetaWord* p = nullptr;
    MetaWord arr[10000];

@@ -110,11 +123,11 @@
  
  // Given a sequence of (0-terminated) sizes, add blocks of those sizes to the tree in the order given. Then, ask
  // for a request size and check that it is the expected result.
  static void test_find_nearest_fit_with_tree(const size_t sizes[], size_t request_size) {
  
-   BlockTree bt;
+   TestedBlockTree bt;
    FeederBuffer fb(4 * K);
  
    create_nodes(sizes, fb, bt);
  
    DEBUG_ONLY(bt.verify();)

@@ -153,11 +166,11 @@
      30, 17, 10, 28,
      50, 32, 51, 35,
      0 // stop
    };
  
-   BlockTree bt;
+   TestedBlockTree bt;
    FeederBuffer fb(4 * K);
  
    create_nodes(sizes, fb, bt);
  
    for (int i = BlockTree::MinWordSize; i <= 60; i ++) {

@@ -168,11 +181,11 @@
  
  // Test repeated adding and removing of blocks of the same size, which
  // should exercise the list-part of the tree.
  TEST_VM(metaspace, BlockTree_basic_siblings)
  {
-   BlockTree bt;
+   TestedBlockTree bt;
    FeederBuffer fb(4 * K);
  
    CHECK_BT_CONTENT(bt, 0, 0);
  
    const size_t test_size = BlockTree::MinWordSize;

@@ -202,11 +215,11 @@
      30, 17, 10, 28,
      50, 32, 51, 35,
      0 // stop
    };
  
-   BlockTree bt;
+   TestedBlockTree bt;
    FeederBuffer fb(4 * K);
  
    create_nodes(sizes, fb, bt);
  
    ResourceMark rm;

@@ -220,11 +233,11 @@
  // Test that an overwritten node would result in an assert and a printed tree
  TEST_VM_ASSERT_MSG(metaspace, BlockTree_overwriter_test, ".*failed: Invalid node") {
    static const size_t sizes1[] = { 30, 17, 0 };
    static const size_t sizes2[] = { 12, 12, 0 };
  
-   BlockTree bt;
+   TestedBlockTree bt;
    FeederBuffer fb(4 * K);
  
    // some nodes...
    create_nodes(sizes1, fb, bt);
  

@@ -247,11 +260,11 @@
  
  class BlockTreeTest {
  
    FeederBuffer _fb;
  
-   BlockTree _bt[2];
+   TestedBlockTree _bt[2];
    MemRangeCounter _cnt[2];
  
    RandSizeGenerator _rgen;
  
  #define CHECK_COUNTERS \

@@ -354,11 +367,11 @@
  
    // Drain the trees. While draining, observe the order of the drained items.
    void drain_all() {
  
      for (int which = 0; which < 2; which++) {
-       BlockTree* bt = _bt + which;
+       TestedBlockTree* bt = _bt + which;
        size_t last_size = 0;
        while (!bt->is_empty()) {
  
          // We only query for the minimal size. Actually returned size should be
          // monotonously growing since remove_block should always return the closest fit.