< prev index next >

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

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

*** 31,168 **** namespace metaspace { class Metachunk; - class ChunkManager; ! // List of VirtualSpaces for metadata allocation. ! class VirtualSpaceList : public CHeapObj<mtClass> { ! friend class VirtualSpaceNode; ! enum VirtualSpaceSizes { ! VirtualSpaceSize = 256 * K ! }; ! // Head of the list ! VirtualSpaceNode* _virtual_space_list; ! // virtual space currently being used for allocations ! VirtualSpaceNode* _current_virtual_space; ! // Is this VirtualSpaceList used for the compressed class space ! bool _is_class; ! // Sum of reserved and committed memory in the virtual spaces size_t _reserved_words; size_t _committed_words; // Number of virtual spaces ! size_t _virtual_space_count; ! ! // Optimization: we keep an address range to quickly exclude pointers ! // which are clearly not pointing into metaspace. This is an optimization for ! // VirtualSpaceList::contains(). ! address _envelope_lo; ! address _envelope_hi; ! ! bool is_within_envelope(address p) const { ! return p >= _envelope_lo && p < _envelope_hi; ! } ! ! // Given a node, expand range such that it includes the node. ! void expand_envelope_to_include_node(const VirtualSpaceNode* node); ! ! ~VirtualSpaceList(); ! ! VirtualSpaceNode* virtual_space_list() const { return _virtual_space_list; } ! ! void set_virtual_space_list(VirtualSpaceNode* v) { ! _virtual_space_list = v; ! } ! void set_current_virtual_space(VirtualSpaceNode* v) { ! _current_virtual_space = v; ! } ! ! void link_vs(VirtualSpaceNode* new_entry); ! ! // Get another virtual space and add it to the list. This ! // is typically prompted by a failed attempt to allocate a chunk ! // and is typically followed by the allocation of a chunk. ! bool create_new_virtual_space(size_t vs_word_size); ! ! // Chunk up the unused committed space in the current ! // virtual space and add the chunks to the free list. ! void retire_current_virtual_space(); ! DEBUG_ONLY(bool contains_node(const VirtualSpaceNode* node) const;) ! public: ! VirtualSpaceList(size_t word_size); ! VirtualSpaceList(ReservedSpace rs); ! size_t free_bytes(); ! Metachunk* get_new_chunk(size_t chunk_word_size, ! size_t suggested_commit_granularity); ! ! bool expand_node_by(VirtualSpaceNode* node, ! size_t min_words, ! size_t preferred_words); ! ! bool expand_by(size_t min_words, ! size_t preferred_words); ! ! VirtualSpaceNode* current_virtual_space() { ! return _current_virtual_space; ! } ! ! bool is_class() const { return _is_class; } ! ! bool initialization_succeeded() { return _virtual_space_list != NULL; } ! ! size_t reserved_words() { return _reserved_words; } ! size_t reserved_bytes() { return reserved_words() * BytesPerWord; } ! size_t committed_words() { return _committed_words; } ! size_t committed_bytes() { return committed_words() * BytesPerWord; } ! ! void inc_reserved_words(size_t v); ! void dec_reserved_words(size_t v); ! void inc_committed_words(size_t v); ! void dec_committed_words(size_t v); ! void inc_virtual_space_count(); ! void dec_virtual_space_count(); ! ! VirtualSpaceNode* find_enclosing_space(const void* ptr); ! bool contains(const void* ptr) { return find_enclosing_space(ptr) != NULL; } ! ! // Unlink empty VirtualSpaceNodes and free it. ! void purge(ChunkManager* chunk_manager); ! void print_on(outputStream* st) const { print_on(st, K); } ! void print_on(outputStream* st, size_t scale) const; ! void print_map(outputStream* st) const; DEBUG_ONLY(void verify(bool slow);) - class VirtualSpaceListIterator : public StackObj { - VirtualSpaceNode* _virtual_spaces; - public: - VirtualSpaceListIterator(VirtualSpaceNode* virtual_spaces) : - _virtual_spaces(virtual_spaces) {} - - bool repeat() { - return _virtual_spaces != NULL; - } - - VirtualSpaceNode* get_next() { - VirtualSpaceNode* result = _virtual_spaces; - if (_virtual_spaces != NULL) { - _virtual_spaces = _virtual_spaces->next(); - } - return result; - } - }; }; } // namespace metaspace #endif // SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP --- 31,87 ---- namespace metaspace { class Metachunk; ! class VirtualSpaceList : public public CHeapObj<mtClass> { ! // Name ! const char* const _name; ! // Head of the list. ! VirtualSpaceNode* _nodes; ! // Node currently being used for allocations. ! VirtualSpaceNode* _current_node; ! // Whether this list can expand by allocating new nodes. ! const bool _can_expand; ! ! // Statistics: ! ! // Sum of reserved and committed words in all nodes size_t _reserved_words; size_t _committed_words; // Number of virtual spaces ! int _count; ! public: ! // Create a new, empty, expandable list. ! VirtualSpaceList(const char* name); ! // Create a new list. The list will contain one node, which uses the given ReservedSpace. ! // It will be not expandable beyond that first node. ! VirtualSpaceList(const char* name, ReservedSpace* rs); ! ~VirtualSpaceList(); ! // Allocate a root chunk from the current node in this list. ! // - If the node is full and the list is expandable, a new node may be created. ! // - This may fail if we either hit the GC threshold or the metaspace limits. ! // Returns NULL if it failed. ! Metachunk* allocate_root_chunk(); ! ! // Remove all nodes which only contain empty chunks from the list, ! // remove the chunks from the ChunkManager, and unmap those nodes. ! void purge(); DEBUG_ONLY(void verify(bool slow);) }; } // namespace metaspace #endif // SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
< prev index next >