< prev index next >
src/hotspot/share/memory/metaspace/virtualSpaceList.hpp
Print this page
rev 57380 : [mq]: metaspace-improvement
@@ -31,138 +31,57 @@
namespace metaspace {
class Metachunk;
-class ChunkManager;
-// List of VirtualSpaces for metadata allocation.
-class VirtualSpaceList : public CHeapObj<mtClass> {
- friend class VirtualSpaceNode;
+class VirtualSpaceList : public public CHeapObj<mtClass> {
- enum VirtualSpaceSizes {
- VirtualSpaceSize = 256 * K
- };
+ // Name
+ const char* const _name;
- // Head of the list
- VirtualSpaceNode* _virtual_space_list;
- // virtual space currently being used for allocations
- VirtualSpaceNode* _current_virtual_space;
+ // Head of the list.
+ VirtualSpaceNode* _nodes;
- // Is this VirtualSpaceList used for the compressed class space
- bool _is_class;
+ // Node currently being used for allocations.
+ VirtualSpaceNode* _current_node;
- // Sum of reserved and committed memory in the virtual spaces
+ // 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
- 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();
+ int _count;
- DEBUG_ONLY(bool contains_node(const VirtualSpaceNode* node) const;)
+public:
- public:
- VirtualSpaceList(size_t word_size);
- VirtualSpaceList(ReservedSpace rs);
+ // Create a new, empty, expandable list.
+ VirtualSpaceList(const char* name);
- size_t free_bytes();
+ // 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);
- 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);
+ ~VirtualSpaceList();
- 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;
+ // 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);)
- 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
< prev index next >