--- old/src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp 2019-07-25 15:29:53.145287853 +0200 +++ new/src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp 2019-07-25 15:29:52.925284737 +0200 @@ -25,139 +25,214 @@ #ifndef SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP #define SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP +#include "memory/metaspace/constants.hpp" +#include "memory/metaspace/counter.hpp" +#include "memory/metaspace/chunkTree.hpp" +#include "memory/metaspace/commitMask.hpp" #include "memory/virtualspace.hpp" #include "memory/memRegion.hpp" #include "utilities/debug.hpp" +#include "utilities/bitMap.hpp" #include "utilities/globalDefinitions.hpp" + class outputStream; namespace metaspace { -class Metachunk; -class ChunkManager; -class OccupancyMap; +class CommitLimiter; -// A VirtualSpaceList node. +// VirtualSpaceNode manage a single address range of the Metaspace. +// +// That address range may contain interleaved committed and uncommitted +// regions. It keeps track of which regions have committed and offers +// functions to commit and uncommit regions. +// +// It allocates and hands out memory ranges, starting at the bottom. +// +// Address range must be aligned to root chunk size. +// class VirtualSpaceNode : public CHeapObj { - friend class VirtualSpaceList; // Link to next VirtualSpaceNode VirtualSpaceNode* _next; - // Whether this node is contained in class or metaspace. - const bool _is_class; - - // total in the VirtualSpace ReservedSpace _rs; - VirtualSpace _virtual_space; - MetaWord* _top; - // count of chunks contained in this VirtualSpace - uintx _container_count; - - OccupancyMap* _occupancy_map; - - // Convenience functions to access the _virtual_space - char* low() const { return virtual_space()->low(); } - char* high() const { return virtual_space()->high(); } - char* low_boundary() const { return virtual_space()->low_boundary(); } - char* high_boundary() const { return virtual_space()->high_boundary(); } - - // The first Metachunk will be allocated at the bottom of the - // VirtualSpace - Metachunk* first_chunk() { return (Metachunk*) bottom(); } - - // Committed but unused space in the virtual space - size_t free_words_in_vs() const; - - // True if this node belongs to class metaspace. - bool is_class() const { return _is_class; } - - // Helper function for take_from_committed: allocate padding chunks - // until top is at the given address. - void allocate_padding_chunks_until_top_is_at(MetaWord* target_top); - - public: - - VirtualSpaceNode(bool is_class, size_t byte_size); - VirtualSpaceNode(bool is_class, ReservedSpace rs) : - _next(NULL), _is_class(is_class), _rs(rs), _top(NULL), _container_count(0), _occupancy_map(NULL) {} - ~VirtualSpaceNode(); - - // Convenience functions for logical bottom and end - MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); } - MetaWord* end() const { return (MetaWord*) _virtual_space.high(); } - - const OccupancyMap* occupancy_map() const { return _occupancy_map; } - OccupancyMap* occupancy_map() { return _occupancy_map; } - - bool contains(const void* ptr) { return ptr >= low() && ptr < high(); } - - size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; } - size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; } - - bool is_pre_committed() const { return _virtual_space.special(); } - // address of next available space in _virtual_space; - // Accessors - VirtualSpaceNode* next() { return _next; } - void set_next(VirtualSpaceNode* v) { _next = v; } + // Start pointer of the area. + MetaWord* const _base; - void set_top(MetaWord* v) { _top = v; } + // Size, in words, of the whole node + const size_t _word_size; - // Accessors - VirtualSpace* virtual_space() const { return (VirtualSpace*) &_virtual_space; } + // Size, in words, of the range of this node which has been handed out in + // the form of chunks. + size_t _used_words; + + // The bitmap describing the commit state of the region: + // Each bit covers a region of 64K (see constants::commit_granule_size). + CommitMask _commit_mask; + + // An array of chunk trees. Each one describes fragmentation inside the associated root chunk. + ChunkTreeArray _chunk_tree_array; + + // Limiter object to ask before expanding the committed size of this node. + CommitLimiter* const _commit_limiter; + + // Points to outside size counters which we are to increase/decrease when we commit/uncommit + // space from this node. + SizeCounter* const _total_reserved_words_counter; + SizeCounter* const _total_committed_words_counter; + + /// committing, uncommitting /// + + // Given a pointer into this node, calculate the start of the commit granule + // the pointer points into. + MetaWord* calc_start_of_granule(MetaWord* p) const { + DEBUG_ONLY(check_pointer(p)); + return align_down(p, constants::commit_granule_bytes); + } + + // Given an address range, ensure it is committed. + // + // The range has to be aligned to granule size. + // + // Function will: + // - check how many granules in that region are uncommitted; If all are committed, it + // returns true immediately. + // - check if committing those uncommitted granules would bring us over the commit limit + // (GC threshold, MaxMetaspaceSize). If true, it returns false. + // - commit the memory. + // - mark the range as committed in the commit mask + // + // Returns true if success, false if it did hit a commit limit. + bool commit_range(MetaWord* p, size_t word_size); + + //// creation //// + + // Create a new empty node spanning the given reserved space. + VirtualSpaceNode(ReservedSpace rs, + CommitLimiter* limiter, + SizeCounter* reserve_counter, + SizeCounter* commit_counter); + + MetaWord* base() const { return _base; } + + // Reserved size of the whole node. + size_t word_size() const { return _word_size; } + +public: + + // Create a node of a given size + static VirtualSpaceNode* create_node(size_t word_size, + CommitLimiter* limiter, + SizeCounter* reserve_counter, + SizeCounter* commit_counter); + + // Create a node over an existing space + static VirtualSpaceNode* create_node(ReservedSpace rs, + CommitLimiter* limiter, + SizeCounter* reserve_counter, + SizeCounter* commit_counter); - // Returns true if "word_size" is available in the VirtualSpace - bool is_available(size_t word_size) { return word_size <= pointer_delta(end(), _top, sizeof(MetaWord)); } - - MetaWord* top() const { return _top; } - void inc_top(size_t word_size) { _top += word_size; } - - uintx container_count() { return _container_count; } - void inc_container_count(); - void dec_container_count(); - - // used and capacity in this single entry in the list - size_t used_words_in_vs() const; - size_t capacity_words_in_vs() const; - - bool initialize(); - - // get space from the virtual space - Metachunk* take_from_committed(size_t chunk_word_size); + ~VirtualSpaceNode(); - // Allocate a chunk from the virtual space and return it. - Metachunk* get_chunk_vs(size_t chunk_word_size); + //// Chunk allocation, splitting, merging ///// - // Expands the committed space by at least min_words words. - bool expand_by(size_t min_words, size_t preferred_words); + // Allocate a root chunk from this node. Will fail and return NULL + // if the node is full. + // Note: this just returns a chunk whose memory is reserved; no memory is committed yet. + // Hence, before using this chunk, it must be committed. + // Also, no limits are checked, since no committing takes place. + Metachunk* allocate_root_chunk(); + + // Given a chunk c, split it recursively until you get a chunk of the given target_level. + // + // The original chunk must not be part of a freelist. + // + // Returns pointer to the result chunk; returns split off chunks in splinters array. + // + // Returns NULL if chunk cannot be split at least once. + Metachunk* split(chklvl_t target_level, Metachunk* c, Metachunk* splinters[chklvl::NUM_CHUNK_LEVELS]); + + // Given a chunk, attempt to merge it recursively with its neighboring chunks. + // + // If successful (merged at least once), returns address of + // the merged chunk; NULL otherwise. + // + // The merged chunks are removed from their freelist; the number of merged chunks is + // returned, split by level, in num_merged array. Note that these numbers does not + // include the original chunk. + // + // !!! Please note that if this method returns a non-NULL value, the + // original chunk will be invalid and should not be accessed anymore! !!! + Metachunk* merge(Metachunk* c, int num_merged[chklvl::NUM_CHUNK_LEVELS]); + + + /// misc ///// + + // Returns size, in words, of the used space in this node alone. + // (Notes: + // - This is the space handed out to the ChunkManager, so it is "used" from the viewpoint of this node, + // but not necessarily used for Metadata. + // - This may or may not be committed memory. + size_t used_words() const { return _used_words; } + + // Returns size, in words, of how much space is left in this node alone. + size_t free_words() const { return _word_size - _used_words; } + + // Returns size, in words, of committed space in this node alone. + size_t committed_words() const; + + //// Committing/uncommitting memory ///// + + // Given an address range, ensure it is committed. + // + // The range does not have to be aligned to granule size. However, the function will always commit + // whole granules. + // + // Function will: + // - check how many granules in that region are uncommitted; If all are committed, it + // returns true immediately. + // - check if committing those uncommitted granules would bring us over the commit limit + // (GC threshold, MaxMetaspaceSize). If true, it returns false. + // - commit the memory. + // - mark the range as committed in the commit mask + // + // Returns true if success, false if it did hit a commit limit. + bool ensure_range_is_committed(MetaWord* p, size_t word_size); + + // Given an address range (which has to be aligned to commit granule size): + // - uncommit it + // - mark it as uncommitted in the commit mask + bool uncommit_range(MetaWord* p, size_t word_size); + + //// List stuff //// + VirtualSpaceNode* next() const { return _next; } + void set_next(VirtualSpaceNode* vsn) { _next = vsn; } - // In preparation for deleting this node, remove all the chunks - // in the node from any freelist. - void purge(ChunkManager* chunk_manager); - // If an allocation doesn't fit in the current node a new node is created. - // Allocate chunks out of the remaining committed space in this node - // to avoid wasting that memory. - // This always adds up because all the chunk sizes are multiples of - // the smallest chunk size. - void retire(ChunkManager* chunk_manager); + /// Debug stuff //// - void print_on(outputStream* st) const { print_on(st, K); } + // Print a description about this node. + void print_on(outputStream* st) const { print_on(st, K); } void print_on(outputStream* st, size_t scale) const; - void print_map(outputStream* st, bool is_class) const; - // Debug support - DEBUG_ONLY(void mangle();) - // Verify counters and basic structure. Slow mode: verify all chunks in depth and occupancy map. - DEBUG_ONLY(void verify(bool slow);) - // Verify that all free chunks in this node are ideally merged - // (there should not be multiple small chunks where a large chunk could exist.) - DEBUG_ONLY(void verify_free_chunks_are_ideally_merged();) + // Verify counters and basic structure. Slow mode: verify all chunks in depth + bool contains(const MetaWord* p) const { + return p >= _base && p < _base + _used_words; + } + +#ifdef ASSERT + void check_pointer(const MetaWord* p) const { + assert(contains(p), "invalid pointer"); + } + void verify(bool slow) const; +#endif }; + } // namespace metaspace #endif // SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP