truffle: src/share/vm/memory/cardTableRS.cpp comparison

comparison src/share/vm/memory/cardTableRS.cpp @ 3287:c48ad6ab8bdf

7037276: Unnecessary double traversal of dirty card windows Summary: Short-circuited an unnecessary double traversal of dirty card windows when iterating younger refs. Also renamed some cardtable methods for more clarity. Reviewed-by: jmasa, stefank, poonam

author	ysr
date	Wed, 20 Apr 2011 19:19:30 -0700
parents	c69b1043dfb1
children	1f4413413144

comparison

equal deleted inserted replaced

-:49a67202bc67
+:c48ad6ab8bdf
 OopsInGenClosure* blk) {
 _last_cur_val_in_gen[g->level()+1] = cur_youngergen_card_val();
 g->younger_refs_iterate(blk);
 }
-class ClearNoncleanCardWrapper: public MemRegionClosure {
+inline bool ClearNoncleanCardWrapper::clear_card(jbyte* entry) {
-MemRegionClosure* _dirty_card_closure;
+if (_is_par) {
-CardTableRS* _ct;
+return clear_card_parallel(entry);
-bool _is_par;
+} else {
-private:
+return clear_card_serial(entry);
-// Clears the given card, return true if the corresponding card should be
+}
-// processed.
+}
-bool clear_card(jbyte* entry) {
-if (_is_par) {
+inline bool ClearNoncleanCardWrapper::clear_card_parallel(jbyte* entry) {
 while (true) {
 // In the parallel case, we may have to do this several times.
 jbyte entry_val = *entry;
 assert(entry_val != CardTableRS::clean_card_val(),
 "We shouldn't be looking at clean cards, and this should "
 "be the only place they get cleaned.");
 if (CardTableRS::card_is_dirty_wrt_gen_iter(entry_val)
 || _ct->is_prev_youngergen_card_val(entry_val)) {
 jbyte res =
 Atomic::cmpxchg(CardTableRS::clean_card_val(), entry, entry_val);
 if (res == entry_val) {
 break;
 } else {
 assert(res == CardTableRS::cur_youngergen_and_prev_nonclean_card,
 "The CAS above should only fail if another thread did "
 "a GC write barrier.");
-}
-} else if (entry_val ==
-CardTableRS::cur_youngergen_and_prev_nonclean_card) {
-// Parallelism shouldn't matter in this case.  Only the thread
-// assigned to scan the card should change this value.
-*entry = _ct->cur_youngergen_card_val();
-break;
-} else {
-assert(entry_val == _ct->cur_youngergen_card_val(),
-"Should be the only possibility.");
-// In this case, the card was clean before, and become
-// cur_youngergen only because of processing of a promoted object.
-// We don't have to look at the card.
-return false;
-}
 }
-return true;
+} else if (entry_val ==
+CardTableRS::cur_youngergen_and_prev_nonclean_card) {
+// Parallelism shouldn't matter in this case.  Only the thread
+// assigned to scan the card should change this value.
+*entry = _ct->cur_youngergen_card_val();
+break;
 } else {
-jbyte entry_val = *entry;
+assert(entry_val == _ct->cur_youngergen_card_val(),
-assert(entry_val != CardTableRS::clean_card_val(),
+"Should be the only possibility.");
-"We shouldn't be looking at clean cards, and this should "
+// In this case, the card was clean before, and become
-"be the only place they get cleaned.");
+// cur_youngergen only because of processing of a promoted object.
-assert(entry_val != CardTableRS::cur_youngergen_and_prev_nonclean_card,
+// We don't have to look at the card.
-"This should be possible in the sequential case.");
+return false;
-*entry = CardTableRS::clean_card_val();
+}
-return true;
+}
-}
+return true;
 }
-public:
-ClearNoncleanCardWrapper(MemRegionClosure* dirty_card_closure,
+inline bool ClearNoncleanCardWrapper::clear_card_serial(jbyte* entry) {
-CardTableRS* ct) :
+jbyte entry_val = *entry;
+assert(entry_val != CardTableRS::clean_card_val(),
+"We shouldn't be looking at clean cards, and this should "
+"be the only place they get cleaned.");
+assert(entry_val != CardTableRS::cur_youngergen_and_prev_nonclean_card,
+"This should be possible in the sequential case.");
+*entry = CardTableRS::clean_card_val();
+return true;
+}
+ClearNoncleanCardWrapper::ClearNoncleanCardWrapper(
+MemRegionClosure* dirty_card_closure, CardTableRS* ct) :
 _dirty_card_closure(dirty_card_closure), _ct(ct) {
 _is_par = (SharedHeap::heap()->n_par_threads() > 0);
 }
-void do_MemRegion(MemRegion mr) {
-// We start at the high end of "mr", walking backwards
+void ClearNoncleanCardWrapper::do_MemRegion(MemRegion mr) {
-// while accumulating a contiguous dirty range of cards in
+assert(mr.word_size() > 0, "Error");
-// [start_of_non_clean, end_of_non_clean) which we then
+assert(_ct->is_aligned(mr.start()), "mr.start() should be card aligned");
-// process en masse.
+// mr.end() may not necessarily be card aligned.
-HeapWord* end_of_non_clean = mr.end();
+jbyte* cur_entry = _ct->byte_for(mr.last());
-HeapWord* start_of_non_clean = end_of_non_clean;
+const jbyte* limit = _ct->byte_for(mr.start());
-jbyte*       entry = _ct->byte_for(mr.last());
+HeapWord* end_of_non_clean = mr.end();
-const jbyte* first_entry = _ct->byte_for(mr.start());
+HeapWord* start_of_non_clean = end_of_non_clean;
-while (entry >= first_entry) {
+while (cur_entry >= limit) {
-HeapWord* cur = _ct->addr_for(entry);
+HeapWord* cur_hw = _ct->addr_for(cur_entry);
-if (!clear_card(entry)) {
+if ((*cur_entry != CardTableRS::clean_card_val()) && clear_card(cur_entry)) {
-// We hit a clean card; process any non-empty
+// Continue the dirty range by opening the
-// dirty range accumulated so far.
+// dirty window one card to the left.
-if (start_of_non_clean < end_of_non_clean) {
+start_of_non_clean = cur_hw;
-MemRegion mr2(start_of_non_clean, end_of_non_clean);
+} else {
-_dirty_card_closure->do_MemRegion(mr2);
+// We hit a "clean" card; process any non-empty
-}
+// "dirty" range accumulated so far.
-// Reset the dirty window while continuing to
+if (start_of_non_clean < end_of_non_clean) {
-// look for the next dirty window to process.
+const MemRegion mrd(start_of_non_clean, end_of_non_clean);
-end_of_non_clean = cur;
+_dirty_card_closure->do_MemRegion(mrd);
-start_of_non_clean = end_of_non_clean;
 }
-// Open the left end of the window one card to the left.
+// Reset the dirty window, while continuing to look
-start_of_non_clean = cur;
+// for the next dirty card that will start a
-// Note that "entry" leads "start_of_non_clean" in
+// new dirty window.
-// its leftward excursion after this point
+end_of_non_clean = cur_hw;
-// in the loop and, when we hit the left end of "mr",
+start_of_non_clean = cur_hw;
-// will point off of the left end of the card-table
+}
-// for "mr".
+// Note that "cur_entry" leads "start_of_non_clean" in
-entry--;
+// its leftward excursion after this point
-}
+// in the loop and, when we hit the left end of "mr",
-// If the first card of "mr" was dirty, we will have
+// will point off of the left end of the card-table
-// been left with a dirty window, co-initial with "mr",
+// for "mr".
-// which we now process.
+cur_entry--;
-if (start_of_non_clean < end_of_non_clean) {
+}
-MemRegion mr2(start_of_non_clean, end_of_non_clean);
+// If the first card of "mr" was dirty, we will have
-_dirty_card_closure->do_MemRegion(mr2);
+// been left with a dirty window, co-initial with "mr",
-}
+// which we now process.
-}
+if (start_of_non_clean < end_of_non_clean) {
-};
+const MemRegion mrd(start_of_non_clean, end_of_non_clean);
+_dirty_card_closure->do_MemRegion(mrd);
+}
+}
 // clean (by dirty->clean before) ==> cur_younger_gen
 // dirty                          ==> cur_youngergen_and_prev_nonclean_card
 // precleaned                     ==> cur_youngergen_and_prev_nonclean_card
 // prev-younger-gen               ==> cur_youngergen_and_prev_nonclean_card
 // cur-younger-gen                ==> cur_younger_gen
 OopsInGenClosure* cl) {
 DirtyCardToOopClosure* dcto_cl = sp->new_dcto_cl(cl, _ct_bs->precision(),
 cl->gen_boundary());
 ClearNoncleanCardWrapper clear_cl(dcto_cl, this);
-_ct_bs->non_clean_card_iterate(sp, sp->used_region_at_save_marks(),
+_ct_bs->non_clean_card_iterate_possibly_parallel(sp, sp->used_region_at_save_marks(),
 dcto_cl, &clear_cl);
 }
 void CardTableRS::clear_into_younger(Generation* gen, bool clear_perm) {
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 // Generations younger than gen have been evacuated. We can clear

Mercurial > hg > truffle

comparison src/share/vm/memory/cardTableRS.cpp @ 3287:c48ad6ab8bdf