< prev index next >

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

Print this page
rev 57380 : [mq]: metaspace-improvement


  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
  26 #define SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "memory/metaspace/virtualSpaceNode.hpp"
  30 #include "utilities/globalDefinitions.hpp"
  31 
  32 
  33 namespace metaspace {
  34 
  35 class Metachunk;
  36 class ChunkManager;
  37 
  38 // List of VirtualSpaces for metadata allocation.
  39 class VirtualSpaceList : public CHeapObj<mtClass> {
  40   friend class VirtualSpaceNode;
  41 
  42   enum VirtualSpaceSizes {
  43     VirtualSpaceSize = 256 * K
  44   };
  45 
  46   // Head of the list
  47   VirtualSpaceNode* _virtual_space_list;
  48   // virtual space currently being used for allocations
  49   VirtualSpaceNode* _current_virtual_space;
  50 
  51   // Is this VirtualSpaceList used for the compressed class space
  52   bool _is_class;
  53 
  54   // Sum of reserved and committed memory in the virtual spaces





  55   size_t _reserved_words;
  56   size_t _committed_words;
  57 
  58   // Number of virtual spaces
  59   size_t _virtual_space_count;
  60 
  61   // Optimization: we keep an address range to quickly exclude pointers
  62   // which are clearly not pointing into metaspace. This is an optimization for
  63   // VirtualSpaceList::contains().
  64   address _envelope_lo;
  65   address _envelope_hi;
  66 
  67   bool is_within_envelope(address p) const {
  68     return p >= _envelope_lo && p < _envelope_hi;
  69   }
  70 
  71   // Given a node, expand range such that it includes the node.
  72   void expand_envelope_to_include_node(const VirtualSpaceNode* node);
  73 
  74   ~VirtualSpaceList();
  75 
  76   VirtualSpaceNode* virtual_space_list() const { return _virtual_space_list; }
  77 
  78   void set_virtual_space_list(VirtualSpaceNode* v) {
  79     _virtual_space_list = v;
  80   }
  81   void set_current_virtual_space(VirtualSpaceNode* v) {
  82     _current_virtual_space = v;
  83   }
  84 
  85   void link_vs(VirtualSpaceNode* new_entry);
  86 
  87   // Get another virtual space and add it to the list.  This
  88   // is typically prompted by a failed attempt to allocate a chunk
  89   // and is typically followed by the allocation of a chunk.
  90   bool create_new_virtual_space(size_t vs_word_size);
  91 
  92   // Chunk up the unused committed space in the current
  93   // virtual space and add the chunks to the free list.
  94   void retire_current_virtual_space();
  95 
  96   DEBUG_ONLY(bool contains_node(const VirtualSpaceNode* node) const;)
  97 
  98  public:
  99   VirtualSpaceList(size_t word_size);
 100   VirtualSpaceList(ReservedSpace rs);
 101 
 102   size_t free_bytes();


 103 
 104   Metachunk* get_new_chunk(size_t chunk_word_size,
 105                            size_t suggested_commit_granularity);
 106 
 107   bool expand_node_by(VirtualSpaceNode* node,
 108                       size_t min_words,
 109                       size_t preferred_words);
 110 
 111   bool expand_by(size_t min_words,
 112                  size_t preferred_words);
 113 
 114   VirtualSpaceNode* current_virtual_space() {
 115     return _current_virtual_space;
 116   }
 117 
 118   bool is_class() const { return _is_class; }
 119 
 120   bool initialization_succeeded() { return _virtual_space_list != NULL; }
 121 
 122   size_t reserved_words()  { return _reserved_words; }
 123   size_t reserved_bytes()  { return reserved_words() * BytesPerWord; }
 124   size_t committed_words() { return _committed_words; }
 125   size_t committed_bytes() { return committed_words() * BytesPerWord; }
 126 
 127   void inc_reserved_words(size_t v);
 128   void dec_reserved_words(size_t v);
 129   void inc_committed_words(size_t v);
 130   void dec_committed_words(size_t v);
 131   void inc_virtual_space_count();
 132   void dec_virtual_space_count();
 133 
 134   VirtualSpaceNode* find_enclosing_space(const void* ptr);
 135   bool contains(const void* ptr) { return find_enclosing_space(ptr) != NULL; }
 136 
 137   // Unlink empty VirtualSpaceNodes and free it.
 138   void purge(ChunkManager* chunk_manager);
 139 
 140   void print_on(outputStream* st) const                 { print_on(st, K); }
 141   void print_on(outputStream* st, size_t scale) const;
 142   void print_map(outputStream* st) const;






 143 
 144   DEBUG_ONLY(void verify(bool slow);)
 145 
 146   class VirtualSpaceListIterator : public StackObj {
 147     VirtualSpaceNode* _virtual_spaces;
 148    public:
 149     VirtualSpaceListIterator(VirtualSpaceNode* virtual_spaces) :
 150       _virtual_spaces(virtual_spaces) {}
 151 
 152     bool repeat() {
 153       return _virtual_spaces != NULL;
 154     }
 155 
 156     VirtualSpaceNode* get_next() {
 157       VirtualSpaceNode* result = _virtual_spaces;
 158       if (_virtual_spaces != NULL) {
 159         _virtual_spaces = _virtual_spaces->next();
 160       }
 161       return result;
 162     }
 163   };
 164 };
 165 
 166 } // namespace metaspace
 167 
 168 #endif // SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP


  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
  26 #define SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "memory/metaspace/virtualSpaceNode.hpp"
  30 #include "utilities/globalDefinitions.hpp"
  31 
  32 
  33 namespace metaspace {
  34 
  35 class Metachunk;

  36 
  37 class VirtualSpaceList : public public CHeapObj<mtClass> {


  38 
  39   // Name
  40   const char* const _name;

  41 
  42   // Head of the list.
  43   VirtualSpaceNode* _nodes;


  44 
  45   // Node currently being used for allocations.
  46   VirtualSpaceNode* _current_node;
  47 
  48   // Whether this list can expand by allocating new nodes.
  49   const bool _can_expand;
  50 
  51   // Statistics:
  52 
  53   // Sum of reserved and committed words in all nodes
  54   size_t _reserved_words;
  55   size_t _committed_words;
  56 
  57   // Number of virtual spaces
  58   int _count;



































  59 
  60 public:
  61 
  62   // Create a new, empty, expandable list.
  63   VirtualSpaceList(const char* name);

  64 
  65   // Create a new list. The list will contain one node, which uses the given ReservedSpace.
  66   // It will be not expandable beyond that first node.
  67   VirtualSpaceList(const char* name, ReservedSpace* rs);
  68 
  69   ~VirtualSpaceList();


































  70 
  71   // Allocate a root chunk from the current node in this list.
  72   // - If the node is full and the list is expandable, a new node may be created.
  73   // - This may fail if we either hit the GC threshold or the metaspace limits.
  74   // Returns NULL if it failed.
  75   Metachunk* allocate_root_chunk();
  76 
  77   // Remove all nodes which only contain empty chunks from the list,
  78   // remove the chunks from the ChunkManager, and unmap those nodes.
  79   void purge();
  80 
  81   DEBUG_ONLY(void verify(bool slow);)
  82 


















  83 };
  84 
  85 } // namespace metaspace
  86 
  87 #endif // SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
< prev index next >