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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 9fa3bf3043a2
children

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "gc_implementation/shared/spaceDecorator.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/blockOffsetTable.inline.hpp"
 #include "memory/resourceArea.hpp"
+#include "memory/space.inline.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/init.hpp"
 #include "runtime/java.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/vmThread.hpp"
 #include "utilities/copy.hpp"
 /////////////////////////////////////////////////////////////////////////
 //// CompactibleFreeListSpace
 oop(cur)->oop_iterate(cl);
 }
 }
 }
-// Apply the given closure to each oop in the space \intersect memory region.
-void CompactibleFreeListSpace::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) {
-assert_lock_strong(freelistLock());
-if (is_empty()) {
-return;
-}
-MemRegion cur = MemRegion(bottom(), end());
-mr = mr.intersection(cur);
-if (mr.is_empty()) {
-return;
-}
-if (mr.equals(cur)) {
-oop_iterate(cl);
-return;
-}
-assert(mr.end() <= end(), "just took an intersection above");
-HeapWord* obj_addr = block_start(mr.start());
-HeapWord* t = mr.end();
-SpaceMemRegionOopsIterClosure smr_blk(cl, mr);
-if (block_is_obj(obj_addr)) {
-// Handle first object specially.
-oop obj = oop(obj_addr);
-obj_addr += adjustObjectSize(obj->oop_iterate(&smr_blk));
-} else {
-FreeChunk* fc = (FreeChunk*)obj_addr;
-obj_addr += fc->size();
-}
-while (obj_addr < t) {
-HeapWord* obj = obj_addr;
-obj_addr += block_size(obj_addr);
-// If "obj_addr" is not greater than top, then the
-// entire object "obj" is within the region.
-if (obj_addr <= t) {
-if (block_is_obj(obj)) {
-oop(obj)->oop_iterate(cl);
-}
-} else {
-// "obj" extends beyond end of region
-if (block_is_obj(obj)) {
-oop(obj)->oop_iterate(&smr_blk);
-}
-break;
-}
-}
-}
 // NOTE: In the following methods, in order to safely be able to
 // apply the closure to an object, we need to be sure that the
 // object has been initialized. We are guaranteed that an object
 // is initialized if we are holding the Heap_lock with the
 // world stopped.
 void CompactibleFreeListSpace::object_iterate_mem(MemRegion mr,
 UpwardsObjectClosure* cl) {
 assert_locked(freelistLock());
 NOT_PRODUCT(verify_objects_initialized());
-Space::object_iterate_mem(mr, cl);
+assert(!mr.is_empty(), "Should be non-empty");
-}
+// We use MemRegion(bottom(), end()) rather than used_region() below
+// because the two are not necessarily equal for some kinds of
-// Callers of this iterator beware: The closure application should
+// spaces, in particular, certain kinds of free list spaces.
-// be robust in the face of uninitialized objects and should (always)
+// We could use the more complicated but more precise:
-// return a correct size so that the next addr + size below gives us a
+// MemRegion(used_region().start(), round_to(used_region().end(), CardSize))
-// valid block boundary. [See for instance,
+// but the slight imprecision seems acceptable in the assertion check.
-// ScanMarkedObjectsAgainCarefullyClosure::do_object_careful()
+assert(MemRegion(bottom(), end()).contains(mr),
-// in ConcurrentMarkSweepGeneration.cpp.]
+"Should be within used space");
-HeapWord*
+HeapWord* prev = cl->previous();   // max address from last time
-CompactibleFreeListSpace::object_iterate_careful(ObjectClosureCareful* cl) {
+if (prev >= mr.end()) { // nothing to do
-assert_lock_strong(freelistLock());
+return;
-HeapWord *addr, *last;
+}
-size_t size;
+// This assert will not work when we go from cms space to perm
-for (addr = bottom(), last  = end();
+// space, and use same closure. Easy fix deferred for later. XXX YSR
-addr < last; addr += size) {
+// assert(prev == NULL || contains(prev), "Should be within space");
-FreeChunk* fc = (FreeChunk*)addr;
-if (fc->is_free()) {
+bool last_was_obj_array = false;
-// Since we hold the free list lock, which protects direct
+HeapWord *blk_start_addr, *region_start_addr;
-// allocation in this generation by mutators, a free object
+if (prev > mr.start()) {
-// will remain free throughout this iteration code.
+region_start_addr = prev;
-size = fc->size();
+blk_start_addr    = prev;
+// The previous invocation may have pushed "prev" beyond the
+// last allocated block yet there may be still be blocks
+// in this region due to a particular coalescing policy.
+// Relax the assertion so that the case where the unallocated
+// block is maintained and "prev" is beyond the unallocated
+// block does not cause the assertion to fire.
+assert((BlockOffsetArrayUseUnallocatedBlock &&
+(!is_in(prev))) ||
+(blk_start_addr == block_start(region_start_addr)), "invariant");
+} else {
+region_start_addr = mr.start();
+blk_start_addr    = block_start(region_start_addr);
+}
+HeapWord* region_end_addr = mr.end();
+MemRegion derived_mr(region_start_addr, region_end_addr);
+while (blk_start_addr < region_end_addr) {
+const size_t size = block_size(blk_start_addr);
+if (block_is_obj(blk_start_addr)) {
+last_was_obj_array = cl->do_object_bm(oop(blk_start_addr), derived_mr);
 } else {
-// Note that the object need not necessarily be initialized,
+last_was_obj_array = false;
-// because (for instance) the free list lock does NOT protect
+}
-// object initialization. The closure application below must
+blk_start_addr += size;
-// therefore be correct in the face of uninitialized objects.
+}
-size = cl->do_object_careful(oop(addr));
+if (!last_was_obj_array) {
-if (size == 0) {
+assert((bottom() <= blk_start_addr) && (blk_start_addr <= end()),
-// An unparsable object found. Signal early termination.
+"Should be within (closed) used space");
-return addr;
+assert(blk_start_addr > prev, "Invariant");
-}
+cl->set_previous(blk_start_addr); // min address for next time
 }
 }
-return NULL;
-}
 // Callers of this iterator beware: The closure application should
 // be robust in the face of uninitialized objects and should (always)
 // return a correct size so that the next addr + size below gives us a
 // valid block boundary. [See for instance,
 // book-keeping stats
 void CFLS_LAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList<FreeChunk>* fl) {
 // Get the #blocks we want to claim
 size_t n_blks = (size_t)_blocks_to_claim[word_sz].average();
 assert(n_blks > 0, "Error");
-assert(ResizePLAB || n_blks == OldPLABSize, "Error");
+assert(ResizeOldPLAB || n_blks == OldPLABSize, "Error");
 // In some cases, when the application has a phase change,
 // there may be a sudden and sharp shift in the object survival
 // profile, and updating the counts at the end of a scavenge
 // may not be quick enough, giving rise to large scavenge pauses
 // during these phase changes. It is beneficial to detect such
 _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 @ 20804:7848fc12602b