graal-jvmci-8: src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp comparison

comparison src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp @ 20520:4001310db3f5

8026303: CMS: JVM intermittently crashes with "FreeList of size 258 violates Conservation Principle" assert Reviewed-by: tschatzl, brutisso

author	jmasa
date	Thu, 21 Nov 2013 09:57:00 -0800
parents	6c523f5d5440
children	a28b7832203a c2844108a708

comparison

equal deleted inserted replaced

-:b29261b17343
+:4001310db3f5
 _num_blocks[i]         = 0;
 }
 }
 }
-void CompactibleFreeListSpace:: par_get_chunk_of_blocks(size_t word_sz, size_t n, AdaptiveFreeList<FreeChunk>* fl) {
+// Used by par_get_chunk_of_blocks() for the chunks from the
-assert(fl->count() == 0, "Precondition.");
+// indexed_free_lists.  Looks for a chunk with size that is a multiple
-assert(word_sz < CompactibleFreeListSpace::IndexSetSize,
+// of "word_sz" and if found, splits it into "word_sz" chunks and add
-"Precondition");
+// to the free list "fl".  "n" is the maximum number of chunks to
+// be added to "fl".
+bool CompactibleFreeListSpace:: par_get_chunk_of_blocks_IFL(size_t word_sz, size_t n, AdaptiveFreeList<FreeChunk>* fl) {
 // We'll try all multiples of word_sz in the indexed set, starting with
 // word_sz itself and, if CMSSplitIndexedFreeListBlocks, try larger multiples,
 // then try getting a big chunk and splitting it.
 {
 size_t num = fl->count();
 MutexLockerEx x(_indexedFreeListParLocks[word_sz],
 Mutex::_no_safepoint_check_flag);
 ssize_t births = _indexedFreeList[word_sz].split_births() + num;
 _indexedFreeList[word_sz].set_split_births(births);
-return;
+return true;
 }
 }
-}
+return found;
-// Otherwise, we'll split a block from the dictionary.
+}
+}
+FreeChunk* CompactibleFreeListSpace::get_n_way_chunk_to_split(size_t word_sz, size_t n) {
 FreeChunk* fc = NULL;
 FreeChunk* rem_fc = NULL;
 size_t rem;
 {
 MutexLockerEx x(parDictionaryAllocLock(),
 Mutex::_no_safepoint_check_flag);
 while (n > 0) {
 fc = dictionary()->get_chunk(MAX2(n * word_sz, _dictionary->min_size()),
 FreeBlockDictionary<FreeChunk>::atLeast);
 if (fc != NULL) {
-_bt.allocated((HeapWord*)fc, fc->size(), true /* reducing */);  // update _unallocated_blk
-dictionary()->dict_census_update(fc->size(),
-true /*split*/,
-false /*birth*/);
 break;
 } else {
 n--;
 }
 }
-if (fc == NULL) return;
+if (fc == NULL) return NULL;
 // Otherwise, split up that block.
 assert((ssize_t)n >= 1, "Control point invariant");
 assert(fc->is_free(), "Error: should be a free block");
 _bt.verify_single_block((HeapWord*)fc, fc->size());
 const size_t nn = fc->size() / word_sz;
 // enough to leave a viable remainder.  We are unable to
 // allocate even one block.  Return fc to the
 // dictionary and return, leaving "fl" empty.
 if (n == 0) {
 returnChunkToDictionary(fc);
-assert(fl->count() == 0, "We never allocated any blocks");
+return NULL;
-return;
+}
-}
+_bt.allocated((HeapWord*)fc, fc->size(), true /* reducing */);  // update _unallocated_blk
+dictionary()->dict_census_update(fc->size(),
+true /*split*/,
+false /*birth*/);
 // First return the remainder, if any.
 // Note that we hold the lock until we decide if we're going to give
 // back the remainder to the dictionary, since a concurrent allocation
 // may otherwise see the heap as empty.  (We're willing to take that
 Mutex::_no_safepoint_check_flag);
 _bt.verify_not_unallocated((HeapWord*)rem_fc, rem_fc->size());
 _indexedFreeList[rem].return_chunk_at_head(rem_fc);
 smallSplitBirth(rem);
 }
-assert((ssize_t)n > 0 && fc != NULL, "Consistency");
+assert(n * word_sz == fc->size(),
+err_msg("Chunk size " SIZE_FORMAT " is not exactly splittable by "
+SIZE_FORMAT " sized chunks of size " SIZE_FORMAT,
+fc->size(), n, word_sz));
+return fc;
+}
+void CompactibleFreeListSpace:: par_get_chunk_of_blocks_dictionary(size_t word_sz, size_t targetted_number_of_chunks, AdaptiveFreeList<FreeChunk>* fl) {
+FreeChunk* fc = get_n_way_chunk_to_split(word_sz, targetted_number_of_chunks);
+if (fc == NULL) {
+return;
+}
+size_t n = fc->size() / word_sz;
+assert((ssize_t)n > 0, "Consistency");
 // Now do the splitting up.
 // Must do this in reverse order, so that anybody attempting to
 // access the main chunk sees it as a single free block until we
 // change it.
 size_t fc_size = n * word_sz;
 // _indexedFreeList[word_sz].set_surplus(new_surplus);
 }
 // TRAP
 assert(fl->tail()->next() == NULL, "List invariant.");
+}
+void CompactibleFreeListSpace:: par_get_chunk_of_blocks(size_t word_sz, size_t n, AdaptiveFreeList<FreeChunk>* fl) {
+assert(fl->count() == 0, "Precondition.");
+assert(word_sz < CompactibleFreeListSpace::IndexSetSize,
+"Precondition");
+if (par_get_chunk_of_blocks_IFL(word_sz, n, fl)) {
+// Got it
+return;
+}
+// Otherwise, we'll split a block from the dictionary.
+par_get_chunk_of_blocks_dictionary(word_sz, n, fl);
 }
 // Set up the space's par_seq_tasks structure for work claiming
 // for parallel rescan. See CMSParRemarkTask where this is currently used.
 // XXX Need to suitably abstract and generalize this and the next

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp @ 20520:4001310db3f5