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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 2137:ffd725ff6943

Merge

author	johnc
date	Thu, 13 Jan 2011 17:19:21 -0800
parents	7246a374a9f2 c91cc404ca46
children	9afee0b9fc1d

comparison

equal deleted inserted replaced

-:856ecff79cf7
+:ffd725ff6943
 gclog_or_tty->print("\n====================\nStarting new sweep\n");
 }
 }
 // We need this destructor to reclaim any space at the end
-// of the space, which do_blk below may not have added back to
+// of the space, which do_blk below may not yet have added back to
-// the free lists. [basically dealing with the "fringe effect"]
+// the free lists.
 SweepClosure::~SweepClosure() {
 assert_lock_strong(_freelistLock);
-// this should be treated as the end of a free run if any
+assert(_limit >= _sp->bottom() && _limit <= _sp->end(),
-// The current free range should be returned to the free lists
+"sweep _limit out of bounds");
-// as one coalesced chunk.
+// Flush any remaining coterminal free run as a single
+// coalesced chunk to the appropriate free list.
 if (inFreeRange()) {
-flushCurFreeChunk(freeFinger(),
+assert(freeFinger() < _limit, "freeFinger points too high");
-pointer_delta(_limit, freeFinger()));
+flush_cur_free_chunk(freeFinger(), pointer_delta(_limit, freeFinger()));
-assert(freeFinger() < _limit, "the finger pointeth off base");
 if (CMSTraceSweeper) {
-gclog_or_tty->print("destructor:");
+gclog_or_tty->print("Sweep: last chunk: ");
-gclog_or_tty->print("Sweep:put_free_blk 0x%x ("SIZE_FORMAT") "
+gclog_or_tty->print("put_free_blk 0x%x ("SIZE_FORMAT") [coalesced:"SIZE_FORMAT"]\n",
-"[coalesced:"SIZE_FORMAT"]\n",
+freeFinger(), pointer_delta(_limit, freeFinger()), lastFreeRangeCoalesced());
-freeFinger(), pointer_delta(_limit, freeFinger()),
+}
-lastFreeRangeCoalesced());
+} // else nothing to flush
-}
-}
 NOT_PRODUCT(
 if (Verbose && PrintGC) {
 gclog_or_tty->print("Collected "SIZE_FORMAT" objects, "
 SIZE_FORMAT " bytes",
 _numObjectsFreed, _numWordsFreed*sizeof(HeapWord));
 }
 void SweepClosure::initialize_free_range(HeapWord* freeFinger,
 bool freeRangeInFreeLists) {
 if (CMSTraceSweeper) {
-gclog_or_tty->print("---- Start free range 0x%x with free block [%d] (%d)\n",
+gclog_or_tty->print("---- Start free range at 0x%x with free block (%d)\n",
-freeFinger, _sp->block_size(freeFinger),
+freeFinger, freeRangeInFreeLists);
-freeRangeInFreeLists);
 }
 assert(!inFreeRange(), "Trampling existing free range");
 set_inFreeRange(true);
 set_lastFreeRangeCoalesced(false);
 // than "addr == _limit" because although _limit was a block boundary when
 // we started the sweep, it may no longer be one because heap expansion
 // may have caused us to coalesce the block ending at the address _limit
 // with a newly expanded chunk (this happens when _limit was set to the
 // previous _end of the space), so we may have stepped past _limit; see CR 6977970.
-if (addr >= _limit) { // we have swept up to or past the limit, do nothing more
+if (addr >= _limit) { // we have swept up to or past the limit: finish up
 assert(_limit >= _sp->bottom() && _limit <= _sp->end(),
 "sweep _limit out of bounds");
 assert(addr < _sp->end(), "addr out of bounds");
-// help the closure application finish
+// Flush any remaining coterminal free run as a single
+// coalesced chunk to the appropriate free list.
+if (inFreeRange()) {
+assert(freeFinger() < _limit, "finger points too high");
+flush_cur_free_chunk(freeFinger(),
+pointer_delta(addr, freeFinger()));
+if (CMSTraceSweeper) {
+gclog_or_tty->print("Sweep: last chunk: ");
+gclog_or_tty->print("put_free_blk 0x%x ("SIZE_FORMAT") "
+"[coalesced:"SIZE_FORMAT"]\n",
+freeFinger(), pointer_delta(addr, freeFinger()),
+lastFreeRangeCoalesced());
+}
+}
+// help the iterator loop finish
 return pointer_delta(_sp->end(), addr);
 }
 assert(addr < _limit, "sweep invariant");
 // check if we should yield
 do_yield_check(addr);
 if (fc->isFree()) {
 // Chunk that is already free
 res = fc->size();
-doAlreadyFreeChunk(fc);
+do_already_free_chunk(fc);
 debug_only(_sp->verifyFreeLists());
 assert(res == fc->size(), "Don't expect the size to change");
 NOT_PRODUCT(
 _numObjectsAlreadyFree++;
 _numWordsAlreadyFree += res;
 )
 NOT_PRODUCT(_last_fc = fc;)
 } else if (!_bitMap->isMarked(addr)) {
 // Chunk is fresh garbage
-res = doGarbageChunk(fc);
+res = do_garbage_chunk(fc);
 debug_only(_sp->verifyFreeLists());
 NOT_PRODUCT(
 _numObjectsFreed++;
 _numWordsFreed += res;
 )
 } else {
 // Chunk that is alive.
-res = doLiveChunk(fc);
+res = do_live_chunk(fc);
 debug_only(_sp->verifyFreeLists());
 NOT_PRODUCT(
 _numObjectsLive++;
 _numWordsLive += res;
 )
 // a chunk of an overpopulated (currently more chunks than desired) size may
 // be chosen.  The "hint" associated with a free list, if non-null, points
 // to a free list which may be overpopulated.
 //
-void SweepClosure::doAlreadyFreeChunk(FreeChunk* fc) {
+void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
 size_t size = fc->size();
 // Chunks that cannot be coalesced are not in the
 // free lists.
 if (CMSTestInFreeList && !fc->cantCoalesce()) {
 assert(_sp->verifyChunkInFreeLists(fc),
 assert(!_bitMap->isMarked(addr), "free chunk should be unmarked");
 // Verify that the bit map has no bits marked between
 // addr and purported end of this block.
 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
-// Some chunks cannot be coalesced in under any circumstances.
+// Some chunks cannot be coalesced under any circumstances.
 // See the definition of cantCoalesce().
 if (!fc->cantCoalesce()) {
 // This chunk can potentially be coalesced.
 if (_sp->adaptive_freelists()) {
 // All the work is done in
-doPostIsFreeOrGarbageChunk(fc, size);
+do_post_free_or_garbage_chunk(fc, size);
 } else {  // Not adaptive free lists
 // this is a free chunk that can potentially be coalesced by the sweeper;
 if (!inFreeRange()) {
 // if the next chunk is a free block that can't be coalesced
 // it doesn't make sense to remove this chunk from the free lists
 FreeChunk* nextChunk = (FreeChunk*)(addr + size);
-assert((HeapWord*)nextChunk <= _limit, "sweep invariant");
+assert((HeapWord*)nextChunk <= _sp->end(), "Chunk size out of bounds?");
-if ((HeapWord*)nextChunk < _limit  &&    // there's a next chunk...
+if ((HeapWord*)nextChunk < _sp->end() &&     // There is another free chunk to the right ...
-nextChunk->isFree()    &&            // which is free...
+nextChunk->isFree()               &&     // ... which is free...
-nextChunk->cantCoalesce()) {         // ... but cant be coalesced
+nextChunk->cantCoalesce()) {             // ... but can't be coalesced
 // nothing to do
 } else {
 // Potentially the start of a new free range:
 // Don't eagerly remove it from the free lists.
 // No need to remove it if it will just be put
 // cant coalesce with previous block; this should be treated
 // as the end of a free run if any
 if (inFreeRange()) {
 // we kicked some butt; time to pick up the garbage
-assert(freeFinger() < addr, "the finger pointeth off base");
+assert(freeFinger() < addr, "freeFinger points too high");
-flushCurFreeChunk(freeFinger(), pointer_delta(addr, freeFinger()));
+flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger()));
 }
 // else, nothing to do, just continue
 }
 }
-size_t SweepClosure::doGarbageChunk(FreeChunk* fc) {
+size_t SweepClosure::do_garbage_chunk(FreeChunk* fc) {
 // This is a chunk of garbage.  It is not in any free list.
 // Add it to a free list or let it possibly be coalesced into
 // a larger chunk.
 HeapWord* addr = (HeapWord*) fc;
 size_t size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size());
 if (_sp->adaptive_freelists()) {
 // Verify that the bit map has no bits marked between
 // addr and purported end of just dead object.
 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
-doPostIsFreeOrGarbageChunk(fc, size);
+do_post_free_or_garbage_chunk(fc, size);
 } else {
 if (!inFreeRange()) {
 // start of a new free range
 assert(size > 0, "A free range should have a size");
 initialize_free_range(addr, false);
 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
 }
 return size;
 }
-size_t SweepClosure::doLiveChunk(FreeChunk* fc) {
+size_t SweepClosure::do_live_chunk(FreeChunk* fc) {
 HeapWord* addr = (HeapWord*) fc;
 // The sweeper has just found a live object. Return any accumulated
 // left hand chunk to the free lists.
 if (inFreeRange()) {
-if (_sp->adaptive_freelists()) {
+assert(freeFinger() < addr, "freeFinger points too high");
-flushCurFreeChunk(freeFinger(),
+flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger()));
-pointer_delta(addr, freeFinger()));
+}
-} else { // not adaptive freelists
-set_inFreeRange(false);
+// This object is live: we'd normally expect this to be
-// Add the free range back to the free list if it is not already
-// there.
-if (!freeRangeInFreeLists()) {
-assert(freeFinger() < addr, "the finger pointeth off base");
-if (CMSTraceSweeper) {
-gclog_or_tty->print("Sweep:put_free_blk 0x%x (%d) "
-"[coalesced:%d]\n",
-freeFinger(), pointer_delta(addr, freeFinger()),
-lastFreeRangeCoalesced());
-}
-_sp->addChunkAndRepairOffsetTable(freeFinger(),
-pointer_delta(addr, freeFinger()), lastFreeRangeCoalesced());
-}
-}
-}
-// Common code path for original and adaptive free lists.
-// this object is live: we'd normally expect this to be
 // an oop, and like to assert the following:
 // assert(oop(addr)->is_oop(), "live block should be an oop");
 // However, as we commented above, this may be an object whose
 // header hasn't yet been initialized.
 size_t size;
 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
 size = pointer_delta(nextOneAddr + 1, addr);
 assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
 "alignment problem");
 #ifdef DEBUG
 if (oop(addr)->klass_or_null() != NULL &&
 (   !_collector->should_unload_classes()
 || (oop(addr)->is_parsable()) &&
 oop(addr)->is_conc_safe())) {
 // Ignore mark word because we are running concurrent with mutators
 // the return from size() correct.
 assert(size ==
 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()),
 "P-mark and computed size do not agree");
 }
 #endif
 } else {
 // This should be an initialized object that's alive.
 assert(oop(addr)->klass_or_null() != NULL &&
 (!_collector->should_unload_classes()
 DEBUG_ONLY(_bitMap->verifyNoOneBitsInRange(addr+2, addr+size);)
 }
 return size;
 }
-void SweepClosure::doPostIsFreeOrGarbageChunk(FreeChunk* fc,
+void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
 size_t chunkSize) {
-// doPostIsFreeOrGarbageChunk() should only be called in the smart allocation
+// do_post_free_or_garbage_chunk() should only be called in the case
-// scheme.
+// of the adaptive free list allocator.
 bool fcInFreeLists = fc->isFree();
 assert(_sp->adaptive_freelists(), "Should only be used in this case.");
 assert((HeapWord*)fc <= _limit, "sweep invariant");
 if (CMSTestInFreeList && fcInFreeLists) {
-assert(_sp->verifyChunkInFreeLists(fc),
+assert(_sp->verifyChunkInFreeLists(fc), "free chunk is not in free lists");
-"free chunk is not in free lists");
+}
-}
 if (CMSTraceSweeper) {
 gclog_or_tty->print_cr("  -- pick up another chunk at 0x%x (%d)", fc, chunkSize);
 }
 } else {  // not in a free range and/or should not coalesce
 // Return the current free range and start a new one.
 if (inFreeRange()) {
 // In a free range but cannot coalesce with the right hand chunk.
 // Put the current free range into the free lists.
-flushCurFreeChunk(freeFinger(),
+flush_cur_free_chunk(freeFinger(),
 pointer_delta(addr, freeFinger()));
 }
 // Set up for new free range.  Pass along whether the right hand
 // chunk is in the free lists.
 initialize_free_range((HeapWord*)fc, fcInFreeLists);
 }
 }
-void SweepClosure::flushCurFreeChunk(HeapWord* chunk, size_t size) {
+void SweepClosure::flush_cur_free_chunk(HeapWord* chunk, size_t size) {
 assert(inFreeRange(), "Should only be called if currently in a free range.");
 assert(size > 0,
 "A zero sized chunk cannot be added to the free lists.");
 if (!freeRangeInFreeLists()) {
-if(CMSTestInFreeList) {
+if (CMSTestInFreeList) {
 FreeChunk* fc = (FreeChunk*) chunk;
 fc->setSize(size);
 assert(!_sp->verifyChunkInFreeLists(fc),
 "chunk should not be in free lists yet");
 }
 // free block encountered will start a coalescing range of
 // free blocks.  If the next free block is adjacent to the
 // chunk just flushed, they will need to wait for the next
 // sweep to be coalesced.
 if (inFreeRange()) {
-flushCurFreeChunk(freeFinger(), pointer_delta(addr, freeFinger()));
+flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger()));
 }
 // First give up the locks, then yield, then re-lock.
 // We should probably use a constructor/destructor idiom to
 // do this unlock/lock or modify the MutexUnlocker class to

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 2137:ffd725ff6943