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

@@ -27,17 +27,18 @@
  #define SHARE_MEMORY_METASPACE_BLOCKTREE_HPP
  
  #include "memory/allocation.hpp"
  #include "memory/metaspace/chunklevel.hpp"
  #include "memory/metaspace/counters.hpp"
+ #include "memory/metaspace/metablock.hpp"
  #include "utilities/debug.hpp"
  #include "utilities/globalDefinitions.hpp"
  
  namespace metaspace {
  
  // BlockTree is a rather simple binary search tree. It is used to
- //  manage small to medium free memory blocks (see class FreeBlocks).
+ //  manage medium to large free memory blocks.
  //
  // There is no separation between payload (managed blocks) and nodes: the
  //  memory blocks themselves are the nodes, with the block size being the key.
  //
  // We store node pointer information in these blocks when storing them. That

@@ -78,12 +79,11 @@
  
      static const intptr_t _canary_value =
          NOT_LP64(0x4e4f4445) LP64_ONLY(0x4e4f44454e4f4445ULL); // "NODE" resp "NODENODE"
  
      // Note: we afford us the luxury of an always-there canary value.
-     //  The space for that is there (these nodes are only used to manage larger blocks,
-     //  see FreeBlocks::MaxSmallBlocksWordSize).
+     //  The space for that is there (these nodes are only used to manage larger blocks).
      //  It is initialized in debug and release, but only automatically tested
      //  in debug.
      const intptr_t _canary;
  
      // Normal tree node stuff...

@@ -333,38 +333,39 @@
        }
      }
    }
  
  #ifdef ASSERT
-   void zap_range(MetaWord* p, size_t word_size);
+   void zap_block(MetaBlock block);
    // Helper for verify()
    void verify_node_pointer(const Node* n) const;
  #endif // ASSERT
  
  public:
  
    BlockTree() : _root(nullptr) {}
  
    // Add a memory block to the tree. Its content will be overwritten.
-   void add_block(MetaWord* p, size_t word_size) {
-     DEBUG_ONLY(zap_range(p, word_size));
+   void add_block(MetaBlock block) {
+     DEBUG_ONLY(zap_block(block);)
+     const size_t word_size = block.word_size();
      assert(word_size >= MinWordSize, "invalid block size " SIZE_FORMAT, word_size);
-     Node* n = new(p) Node(word_size);
+     Node* n = new(block.base()) Node(word_size);
      if (_root == nullptr) {
        _root = n;
      } else {
        insert(_root, n);
      }
      _counter.add(word_size);
    }
  
    // Given a word_size, search and return the smallest block that is equal or
-   //  larger than that size. Upon return, *p_real_word_size contains the actual
-   //  block size.
-   MetaWord* remove_block(size_t word_size, size_t* p_real_word_size) {
+   //  larger than that size.
+   MetaBlock remove_block(size_t word_size) {
      assert(word_size >= MinWordSize, "invalid block size " SIZE_FORMAT, word_size);
  
+     MetaBlock result;
      Node* n = find_closest_fit(word_size);
  
      if (n != nullptr) {
        DEBUG_ONLY(check_node(n);)
        assert(n->_word_size >= word_size, "sanity");

@@ -377,19 +378,17 @@
          n = remove_from_list(n);
        } else {
          remove_node_from_tree(n);
        }
  
-       MetaWord* p = (MetaWord*)n;
-       *p_real_word_size = n->_word_size;
+       result = MetaBlock((MetaWord*)n, n->_word_size);
  
        _counter.sub(n->_word_size);
  
-       DEBUG_ONLY(zap_range(p, n->_word_size));
-       return p;
+       DEBUG_ONLY(zap_block(result);)
      }
-     return nullptr;
+     return result;
    }
  
    // Returns number of blocks in this structure
    unsigned count() const { return _counter.count(); }