< 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 >