graal-jvmci-8: src/share/vm/memory/metaspace.cpp comparison

comparison src/share/vm/memory/metaspace.cpp @ 10175:c23dbf0e8ab7

8011268: NPG: Free unused VirtualSpaceNodes Reviewed-by: mgerdin, coleenp, johnc

author	jmasa
date	Fri, 01 Mar 2013 10:19:29 -0800
parents	df254344edf1
children	868d87ed63c8

comparison

equal deleted inserted replaced

-:07a4efc5ed14
+:c23dbf0e8ab7
 // count that includes all three
 class ChunkManager VALUE_OBJ_CLASS_SPEC {
 // Free list of chunks of different sizes.
+//   SpecializedChunk
 //   SmallChunk
 //   MediumChunk
 //   HumongousChunk
 ChunkList _free_chunks[NumberOfFreeLists];
 // Map a size to a list index assuming that there are lists
 // for special, small, medium, and humongous chunks.
 static ChunkIndex list_index(size_t size);
+// Remove the chunk from its freelist.  It is
+// expected to be on one of the _free_chunks[] lists.
+void remove_chunk(Metachunk* chunk);
 // Add the simple linked list of chunks to the freelist of chunks
 // of type index.
 void return_chunks(ChunkIndex index, Metachunk* chunks);
 // Total of the space in the free chunks list
 // total in the VirtualSpace
 MemRegion _reserved;
 ReservedSpace _rs;
 VirtualSpace _virtual_space;
 MetaWord* _top;
+// count of chunks contained in this VirtualSpace
+uintx _container_count;
 // Convenience functions for logical bottom and end
 MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
 MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
 // Convenience functions to access the _virtual_space
 char* low()  const { return virtual_space()->low(); }
 char* high() const { return virtual_space()->high(); }
+// The first Metachunk will be allocated at the bottom of the
+// VirtualSpace
+Metachunk* first_chunk() { return (Metachunk*) bottom(); }
+void inc_container_count();
+#ifdef ASSERT
+uint container_count_slow();
+#endif
 public:
 VirtualSpaceNode(size_t byte_size);
-VirtualSpaceNode(ReservedSpace rs) : _top(NULL), _next(NULL), _rs(rs) {}
+VirtualSpaceNode(ReservedSpace rs) : _top(NULL), _next(NULL), _rs(rs), _container_count(0) {}
 ~VirtualSpaceNode();
 // address of next available space in _virtual_space;
 // Accessors
 VirtualSpaceNode* next() { return _next; }
 bool is_available(size_t word_size) { return _top + word_size <= end(); }
 MetaWord* top() const { return _top; }
 void inc_top(size_t word_size) { _top += word_size; }
+uintx container_count() { return _container_count; }
+void dec_container_count();
+#ifdef ASSERT
+void verify_container_count();
+#endif
 // 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();
 // Expands/shrinks the committed space in a virtual space.  Delegates
 // to Virtualspace
 bool expand_by(size_t words, bool pre_touch = false);
 bool shrink_by(size_t words);
+// In preparation for deleting this node, remove all the chunks
+// in the node from any freelist.
+void purge(ChunkManager* chunk_manager);
 #ifdef ASSERT
 // Debug support
 static void verify_virtual_space_total();
 static void verify_virtual_space_count();
 void print_on(outputStream* st) const;
 };
 // byte_size is the size of the associated virtualspace.
-VirtualSpaceNode::VirtualSpaceNode(size_t byte_size) : _top(NULL), _next(NULL), _rs(0) {
+VirtualSpaceNode::VirtualSpaceNode(size_t byte_size) : _top(NULL), _next(NULL), _rs(0), _container_count(0) {
 // align up to vm allocation granularity
 byte_size = align_size_up(byte_size, os::vm_allocation_granularity());
 // This allocates memory with mmap.  For DumpSharedspaces, try to reserve
 // configurable address, generally at the top of the Java heap so other
 }
 MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
 }
+void VirtualSpaceNode::purge(ChunkManager* chunk_manager) {
+Metachunk* chunk = first_chunk();
+Metachunk* invalid_chunk = (Metachunk*) top();
+while (chunk < invalid_chunk ) {
+assert(chunk->is_free(), "Should be marked free");
+MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
+chunk_manager->remove_chunk(chunk);
+assert(chunk->next() == NULL &&
+chunk->prev() == NULL,
+"Was not removed from its list");
+chunk = (Metachunk*) next;
+}
+}
+#ifdef ASSERT
+uint VirtualSpaceNode::container_count_slow() {
+uint count = 0;
+Metachunk* chunk = first_chunk();
+Metachunk* invalid_chunk = (Metachunk*) top();
+while (chunk < invalid_chunk ) {
+MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
+// Don't count the chunks on the free lists.  Those are
+// still part of the VirtualSpaceNode but not currently
+// counted.
+if (!chunk->is_free()) {
+count++;
+}
+chunk = (Metachunk*) next;
+}
+return count;
+}
+#endif
 // List of VirtualSpaces for metadata allocation.
 // It has a  _next link for singly linked list and a MemRegion
 // for total space in the VirtualSpace.
 class VirtualSpaceList : public CHeapObj<mtClass> {
 friend class VirtualSpaceNode;
 // Allocate the first virtualspace.
 void initialize(size_t word_size);
 size_t virtual_space_total() { return _virtual_space_total; }
-void inc_virtual_space_total(size_t v) {
-Atomic::add_ptr(v, &_virtual_space_total);
+void inc_virtual_space_total(size_t v);
-}
+void dec_virtual_space_total(size_t v);
+void inc_virtual_space_count();
-size_t virtual_space_count() { return _virtual_space_count; }
+void dec_virtual_space_count();
-void inc_virtual_space_count() {
-Atomic::inc_ptr(&_virtual_space_count);
+// Unlink empty VirtualSpaceNodes and free it.
-}
+void purge();
 // Used and capacity in the entire list of virtual spaces.
 // These are global values shared by all Metaspaces
 size_t capacity_words_sum();
 size_t capacity_bytes_sum() { return capacity_words_sum() * BytesPerWord; }
 Mutex* const SpaceManager::_expand_lock =
 new Mutex(SpaceManager::_expand_lock_rank,
 SpaceManager::_expand_lock_name,
 Mutex::_allow_vm_block_flag);
+void VirtualSpaceNode::inc_container_count() {
+assert_lock_strong(SpaceManager::expand_lock());
+_container_count++;
+assert(_container_count == container_count_slow(),
+err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
+"container_count_slow() " SIZE_FORMAT,
+_container_count, container_count_slow()));
+}
+void VirtualSpaceNode::dec_container_count() {
+assert_lock_strong(SpaceManager::expand_lock());
+_container_count--;
+}
+#ifdef ASSERT
+void VirtualSpaceNode::verify_container_count() {
+assert(_container_count == container_count_slow(),
+err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
+"container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
+}
+#endif
 // BlockFreelist methods
 BlockFreelist::BlockFreelist() : _dictionary(NULL) {}
 BlockFreelist::~BlockFreelist() {
 // VirtualSpaceNode methods
 VirtualSpaceNode::~VirtualSpaceNode() {
 _rs.release();
+#ifdef ASSERT
+size_t word_size = sizeof(*this) / BytesPerWord;
+Copy::fill_to_words((HeapWord*) this, word_size, 0xf1f1f1f1);
+#endif
 }
 size_t VirtualSpaceNode::used_words_in_vs() const {
 return pointer_delta(top(), bottom(), sizeof(MetaWord));
 }
 }
 // Take the space  (bump top on the current virtual space).
 inc_top(chunk_word_size);
-// Point the chunk at the space
+// Initialize the chunk
-Metachunk* result = Metachunk::initialize(chunk_limit, chunk_word_size);
+Metachunk* result = ::new (chunk_limit) Metachunk(chunk_word_size, this);
 return result;
 }
 // Expand the virtual space (commit more of the reserved space)
 // Add another chunk to the chunk list.
 Metachunk* VirtualSpaceNode::get_chunk_vs(size_t chunk_word_size) {
 assert_lock_strong(SpaceManager::expand_lock());
-Metachunk* result = NULL;
+Metachunk* result = take_from_committed(chunk_word_size);
+if (result != NULL) {
-return take_from_committed(chunk_word_size);
+inc_container_count();
+}
+return result;
 }
 Metachunk* VirtualSpaceNode::get_chunk_vs_with_expand(size_t chunk_word_size) {
 assert_lock_strong(SpaceManager::expand_lock());
 VirtualSpaceListIterator iter(virtual_space_list());
 while (iter.repeat()) {
 VirtualSpaceNode* vsl = iter.get_next();
 delete vsl;
 }
+}
+void VirtualSpaceList::inc_virtual_space_total(size_t v) {
+assert_lock_strong(SpaceManager::expand_lock());
+_virtual_space_total = _virtual_space_total + v;
+}
+void VirtualSpaceList::dec_virtual_space_total(size_t v) {
+assert_lock_strong(SpaceManager::expand_lock());
+_virtual_space_total = _virtual_space_total - v;
+}
+void VirtualSpaceList::inc_virtual_space_count() {
+assert_lock_strong(SpaceManager::expand_lock());
+_virtual_space_count++;
+}
+void VirtualSpaceList::dec_virtual_space_count() {
+assert_lock_strong(SpaceManager::expand_lock());
+_virtual_space_count--;
+}
+void ChunkManager::remove_chunk(Metachunk* chunk) {
+size_t word_size = chunk->word_size();
+ChunkIndex index = list_index(word_size);
+if (index != HumongousIndex) {
+free_chunks(index)->remove_chunk(chunk);
+} else {
+humongous_dictionary()->remove_chunk(chunk);
+}
+// Chunk is being removed from the chunks free list.
+dec_free_chunks_total(chunk->capacity_word_size());
+}
+// Walk the list of VirtualSpaceNodes and delete
+// nodes with a 0 container_count.  Remove Metachunks in
+// the node from their respective freelists.
+void VirtualSpaceList::purge() {
+assert_lock_strong(SpaceManager::expand_lock());
+// Don't use a VirtualSpaceListIterator because this
+// list is being changed and a straightforward use of an iterator is not safe.
+VirtualSpaceNode* purged_vsl = NULL;
+VirtualSpaceNode* prev_vsl = virtual_space_list();
+VirtualSpaceNode* next_vsl = prev_vsl;
+while (next_vsl != NULL) {
+VirtualSpaceNode* vsl = next_vsl;
+next_vsl = vsl->next();
+// Don't free the current virtual space since it will likely
+// be needed soon.
+if (vsl->container_count() == 0 && vsl != current_virtual_space()) {
+// Unlink it from the list
+if (prev_vsl == vsl) {
+// This is the case of the current note being the first note.
+assert(vsl == virtual_space_list(), "Expected to be the first note");
+set_virtual_space_list(vsl->next());
+} else {
+prev_vsl->set_next(vsl->next());
+}
+vsl->purge(chunk_manager());
+dec_virtual_space_total(vsl->reserved()->word_size());
+dec_virtual_space_count();
+purged_vsl = vsl;
+delete vsl;
+} else {
+prev_vsl = vsl;
+}
+}
+#ifdef ASSERT
+if (purged_vsl != NULL) {
+// List should be stable enough to use an iterator here.
+VirtualSpaceListIterator iter(virtual_space_list());
+while (iter.repeat()) {
+VirtualSpaceNode* vsl = iter.get_next();
+assert(vsl != purged_vsl, "Purge of vsl failed");
+}
+}
+#endif
 }
 size_t VirtualSpaceList::used_words_sum() {
 size_t allocated_by_vs = 0;
 VirtualSpaceListIterator iter(virtual_space_list());
 size_t medium_chunk_bunch) {
 // Get a chunk from the chunk freelist
 Metachunk* next = chunk_manager()->chunk_freelist_allocate(grow_chunks_by_words);
-// Allocate a chunk out of the current virtual space.
+if (next != NULL) {
-if (next == NULL) {
+next->container()->inc_container_count();
+} else {
+// Allocate a chunk out of the current virtual space.
 next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
 }
 if (next == NULL) {
 // Not enough room in current virtual space.  Try to commit
 " waste " SIZE_FORMAT,
 chunk->word_size(), word_size, waste);
 }
 // Chunk is being removed from the chunks free list.
 dec_free_chunks_total(chunk->capacity_word_size());
-#ifdef ASSERT
-chunk->set_is_free(false);
-#endif
 } else {
 return NULL;
 }
 }
 // Remove it from the links to this freelist
 chunk->set_next(NULL);
 chunk->set_prev(NULL);
+#ifdef ASSERT
+// Chunk is no longer on any freelist. Setting to false make container_count_slow()
+// work.
+chunk->set_is_free(false);
+#endif
 slow_locked_verify();
 return chunk;
 }
 Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
 ChunkList* list = free_chunks(index);
 assert(list->size() == chunks->word_size(), "Mismatch in chunk sizes");
 assert_lock_strong(SpaceManager::expand_lock());
 Metachunk* cur = chunks;
-// This return chunks one at a time.  If a new
+// This returns chunks one at a time.  If a new
 // class List can be created that is a base class
 // of FreeList then something like FreeList::prepend()
 // can be used in place of this loop
 while (cur != NULL) {
+assert(cur->container() != NULL, "Container should have been set");
+cur->container()->dec_container_count();
 // Capture the next link before it is changed
 // by the call to return_chunk_at_head();
 Metachunk* next = cur->next();
 cur->set_is_free(true);
 list->return_chunk_at_head(cur);
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
 locked_print_chunks_in_use_on(gclog_or_tty);
 }
-// Mangle freed memory.
+// Do not mangle freed Metachunks.  The chunk size inside Metachunks
-NOT_PRODUCT(mangle_freed_chunks();)
+// is during the freeing of a VirtualSpaceNodes.
 // Have to update before the chunks_in_use lists are emptied
 // below.
 chunk_manager->inc_free_chunks_total(in_use_before,
 sum_count_in_chunks_in_use());
 HumongousChunkGranularity),
 err_msg("Humongous chunk size is wrong: word size " SIZE_FORMAT
 " granularity %d",
 humongous_chunks->word_size(), HumongousChunkGranularity));
 Metachunk* next_humongous_chunks = humongous_chunks->next();
+humongous_chunks->container()->dec_container_count();
 chunk_manager->humongous_dictionary()->return_chunk(humongous_chunks);
 humongous_chunks = next_humongous_chunks;
 }
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("");
 }
 }
 return Metablock::initialize(result, word_size);
 }
+void Metaspace::purge() {
+MutexLockerEx cl(SpaceManager::expand_lock(),
+Mutex::_no_safepoint_check_flag);
+space_list()->purge();
+class_space_list()->purge();
+}
 void Metaspace::print_on(outputStream* out) const {
 // Print both class virtual space counts and metaspace.
 if (Verbose) {
 vsm()->print_on(out);
 class_vsm()->print_on(out);
 // This is checked while unlocked.  As long as the virtualspaces are added
 // at the end, the pointer will be in one of them.  The virtual spaces
 // aren't deleted presently.  When they are, some sort of locking might
 // be needed.  Note, locking this can cause inversion problems with the
 // caller in MetaspaceObj::is_metadata() function.
-return space_list()->contains(ptr) || class_space_list()->contains(ptr);
+return space_list()->contains(ptr) ||
+class_space_list()->contains(ptr);
 }
 void Metaspace::verify() {
 vsm()->verify();
 class_vsm()->verify();

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/metaspace.cpp @ 10175:c23dbf0e8ab7