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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 360:5d254928c888

Merge

author	ysr
date	Wed, 27 Aug 2008 11:20:46 -0700
parents	ebeb6490b814 1ee8caae33af
children	00b023ae2d78

comparison

equal deleted inserted replaced

-:d60e4e6d7f72
+:5d254928c888
 bool       _failed;
 public:
 VerifyMarkedClosure(CMSBitMap* bm): _marks(bm), _failed(false) {}
-void do_bit(size_t offset) {
+bool do_bit(size_t offset) {
 HeapWord* addr = _marks->offsetToHeapWord(offset);
 if (!_marks->isMarked(addr)) {
 oop(addr)->print();
 gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr);
 _failed = true;
 }
+return true;
 }
 bool failed() { return _failed; }
 };
 stopTimer();
 CMSTokenSync x(true); // is cms thread
 startTimer();
 sample_eden();
 // Get and clear dirty region from card table
-dirtyRegion = _ct->ct_bs()->dirty_card_range_after_preclean(
+dirtyRegion = _ct->ct_bs()->dirty_card_range_after_reset(
-MemRegion(nextAddr, endAddr));
+MemRegion(nextAddr, endAddr),
+true,
+CardTableModRefBS::precleaned_card_val());
 assert(dirtyRegion.start() >= nextAddr,
 "returned region inconsistent?");
 }
 lastAddr = dirtyRegion.end();
 numDirtyCards =
 NULL,  // space is set further below
 &_markBitMap, &_markStack, &_revisitStack,
 &mrias_cl);
 {
 TraceTime t("grey object rescan", PrintGCDetails, false, gclog_or_tty);
-// Iterate over the dirty cards, marking them precleaned, and
+// Iterate over the dirty cards, setting the corresponding bits in the
-// setting the corresponding bits in the mod union table.
+// mod union table.
 {
 ModUnionClosure modUnionClosure(&_modUnionTable);
 _ct->ct_bs()->dirty_card_iterate(
 _cmsGen->used_region(),
 &modUnionClosure);
 // Construct a CMS bit map infrastructure, but don't create the
 // bit vector itself. That is done by a separate call CMSBitMap::allocate()
 // further below.
 CMSBitMap::CMSBitMap(int shifter, int mutex_rank, const char* mutex_name):
-_bm(NULL,0),
+_bm(),
 _shifter(shifter),
 _lock(mutex_rank >= 0 ? new Mutex(mutex_rank, mutex_name, true) : NULL)
 {
 _bmStartWord = 0;
 _bmWordSize  = 0;
 warning("CMS bit map backing store failure");
 return false;
 }
 assert(_virtual_space.committed_size() == brs.size(),
 "didn't reserve backing store for all of CMS bit map?");
-_bm.set_map((uintptr_t*)_virtual_space.low());
+_bm.set_map((BitMap::bm_word_t*)_virtual_space.low());
 assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >=
 _bmWordSize, "inconsistency in bit map sizing");
 _bm.set_size(_bmWordSize >> _shifter);
 // bm.clear(); // can we rely on getting zero'd memory? verify below
 (intptr_t)_finger, CardTableModRefBS::card_size);
 }
 // Should revisit to see if this should be restructured for
 // greater efficiency.
-void MarkFromRootsClosure::do_bit(size_t offset) {
+bool MarkFromRootsClosure::do_bit(size_t offset) {
 if (_skipBits > 0) {
 _skipBits--;
-return;
+return true;
 }
 // convert offset into a HeapWord*
 HeapWord* addr = _bitMap->startWord() + offset;
 assert(_bitMap->endWord() && addr < _bitMap->endWord(),
 "address out of range");
 // Redirty the range of cards...
 _mut->mark_range(redirty_range);
 } // ...else the setting of klass will dirty the card anyway.
 }
 DEBUG_ONLY(})
-return;
+return true;
 }
 }
 scanOopsInOop(addr);
+return true;
 }
 // We take a break if we've been at this for a while,
 // so as to avoid monopolizing the locks involved.
 void MarkFromRootsClosure::do_yield_work() {
 assert(_span.contains(_finger), "Out of bounds _finger?");
 }
 // Should revisit to see if this should be restructured for
 // greater efficiency.
-void Par_MarkFromRootsClosure::do_bit(size_t offset) {
+bool Par_MarkFromRootsClosure::do_bit(size_t offset) {
 if (_skip_bits > 0) {
 _skip_bits--;
-return;
+return true;
 }
 // convert offset into a HeapWord*
 HeapWord* addr = _bit_map->startWord() + offset;
 assert(_bit_map->endWord() && addr < _bit_map->endWord(),
 "address out of range");
 _skip_bits = 2;  // skip next two marked bits ("Printezis-marks")
 oop p = oop(addr);
 if (p->klass_or_null() == NULL || !p->is_parsable()) {
 // in the case of Clean-on-Enter optimization, redirty card
 // and avoid clearing card by increasing  the threshold.
-return;
+return true;
 }
 }
 scan_oops_in_oop(addr);
+return true;
 }
 void Par_MarkFromRootsClosure::scan_oops_in_oop(HeapWord* ptr) {
 assert(_bit_map->isMarked(ptr), "expected bit to be set");
 // Should we assert that our work queue is empty or
 _finger = addr;
 }
 // Should revisit to see if this should be restructured for
 // greater efficiency.
-void MarkFromRootsVerifyClosure::do_bit(size_t offset) {
+bool MarkFromRootsVerifyClosure::do_bit(size_t offset) {
 // convert offset into a HeapWord*
 HeapWord* addr = _verification_bm->startWord() + offset;
 assert(_verification_bm->endWord() && addr < _verification_bm->endWord(),
 "address out of range");
 assert(_verification_bm->isMarked(addr), "tautology");
 assert(new_oop->is_oop(), "Oops! expected to pop an oop");
 // now scan this oop's oops
 new_oop->oop_iterate(&_pam_verify_closure);
 }
 assert(_mark_stack->isEmpty(), "tautology, emphasizing post-condition");
+return true;
 }
 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
 CMSCollector* collector, MemRegion span,
 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 }
 // Grey object rescan during pre-cleaning and second checkpoint phases --
 // the non-parallel version (the parallel version appears further below.)
 void PushAndMarkClosure::do_oop(oop obj) {
-// If _concurrent_precleaning, ignore mark word verification
+// Ignore mark word verification. If during concurrent precleaning,
-assert(obj->is_oop_or_null(_concurrent_precleaning),
+// the object monitor may be locked. If during the checkpoint
+// phases, the object may already have been reached by a  different
+// path and may be at the end of the global overflow list (so
+// the mark word may be NULL).
+assert(obj->is_oop_or_null(true /* ignore mark word */),
 "expected an oop or NULL");
 HeapWord* addr = (HeapWord*)obj;
 // Check if oop points into the CMS generation
 // and is not marked
 if (_span.contains(addr) && !_bit_map->isMarked(addr)) {

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 360:5d254928c888