Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 1359:23b1b27ac76c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.") Summary: Make sure that two marking cycles do not overlap, i.e., a new one can only start after the concurrent marking thread finishes all its work. In the fix I piggy-back a couple of minor extra fixes: some general code reformatting for consistency (only around the code I modified), the removal of a field (G1CollectorPolicy::_should_initiate_conc_mark) which doesn't seem to be used at all (it's only set but never read), as well as moving the "is GC locker active" test earlier into the G1 pause / Full GC and using a more appropriate method for it. Reviewed-by: johnc, jmasa, jcoomes, ysr
author tonyp
date Tue, 06 Apr 2010 10:59:45 -0400
parents 72f725c5a7be
children 7666957bc44d
comparison
equal deleted inserted replaced
1358:72f725c5a7be 1359:23b1b27ac76c
706 // from external roots in the CMS bit map. 706 // from external roots in the CMS bit map.
707 // Called at the first checkpoint. 707 // Called at the first checkpoint.
708 // 708 //
709 709
710 void ConcurrentMark::clearNextBitmap() { 710 void ConcurrentMark::clearNextBitmap() {
711 guarantee(!G1CollectedHeap::heap()->mark_in_progress(), "Precondition."); 711 G1CollectedHeap* g1h = G1CollectedHeap::heap();
712 712 G1CollectorPolicy* g1p = g1h->g1_policy();
713 // clear the mark bitmap (no grey objects to start with). 713
714 // We need to do this in chunks and offer to yield in between 714 // Make sure that the concurrent mark thread looks to still be in
715 // each chunk. 715 // the current cycle.
716 HeapWord* start = _nextMarkBitMap->startWord(); 716 guarantee(cmThread()->during_cycle(), "invariant");
717 HeapWord* end = _nextMarkBitMap->endWord(); 717
718 HeapWord* cur = start; 718 // We are finishing up the current cycle by clearing the next
719 size_t chunkSize = M; 719 // marking bitmap and getting it ready for the next cycle. During
720 while (cur < end) { 720 // this time no other cycle can start. So, let's make sure that this
721 HeapWord* next = cur + chunkSize; 721 // is the case.
722 if (next > end) 722 guarantee(!g1h->mark_in_progress(), "invariant");
723 next = end; 723
724 MemRegion mr(cur,next); 724 // clear the mark bitmap (no grey objects to start with).
725 _nextMarkBitMap->clearRange(mr); 725 // We need to do this in chunks and offer to yield in between
726 cur = next; 726 // each chunk.
727 do_yield_check(); 727 HeapWord* start = _nextMarkBitMap->startWord();
728 } 728 HeapWord* end = _nextMarkBitMap->endWord();
729 HeapWord* cur = start;
730 size_t chunkSize = M;
731 while (cur < end) {
732 HeapWord* next = cur + chunkSize;
733 if (next > end)
734 next = end;
735 MemRegion mr(cur,next);
736 _nextMarkBitMap->clearRange(mr);
737 cur = next;
738 do_yield_check();
739
740 // Repeat the asserts from above. We'll do them as asserts here to
741 // minimize their overhead on the product. However, we'll have
742 // them as guarantees at the beginning / end of the bitmap
743 // clearing to get some checking in the product.
744 assert(cmThread()->during_cycle(), "invariant");
745 assert(!g1h->mark_in_progress(), "invariant");
746 }
747
748 // Repeat the asserts from above.
749 guarantee(cmThread()->during_cycle(), "invariant");
750 guarantee(!g1h->mark_in_progress(), "invariant");
729 } 751 }
730 752
731 class NoteStartOfMarkHRClosure: public HeapRegionClosure { 753 class NoteStartOfMarkHRClosure: public HeapRegionClosure {
732 public: 754 public:
733 bool doHeapRegion(HeapRegion* r) { 755 bool doHeapRegion(HeapRegion* r) {