< prev index next >
src/share/vm/gc/shared/cardTableRS.cpp
Print this page
rev 10742 : Make fields used in lock-free algorithms volatile
@@ -150,19 +150,19 @@
// the old generation record here, which is at index 2.
_last_cur_val_in_gen[2] = cur_youngergen_card_val();
g->younger_refs_iterate(blk, n_threads);
}
-inline bool ClearNoncleanCardWrapper::clear_card(jbyte* entry) {
+inline bool ClearNoncleanCardWrapper::clear_card(volatile jbyte* entry) {
if (_is_par) {
return clear_card_parallel(entry);
} else {
return clear_card_serial(entry);
}
}
-inline bool ClearNoncleanCardWrapper::clear_card_parallel(jbyte* entry) {
+inline bool ClearNoncleanCardWrapper::clear_card_parallel(volatile 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 "
@@ -195,11 +195,11 @@
}
return true;
}
-inline bool ClearNoncleanCardWrapper::clear_card_serial(jbyte* entry) {
+inline bool ClearNoncleanCardWrapper::clear_card_serial(volatile jbyte* entry) {
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,
@@ -211,11 +211,11 @@
ClearNoncleanCardWrapper::ClearNoncleanCardWrapper(
DirtyCardToOopClosure* dirty_card_closure, CardTableRS* ct, bool is_par) :
_dirty_card_closure(dirty_card_closure), _ct(ct), _is_par(is_par) {
}
-bool ClearNoncleanCardWrapper::is_word_aligned(jbyte* entry) {
+bool ClearNoncleanCardWrapper::is_word_aligned(volatile jbyte* entry) {
return (((intptr_t)entry) & (BytesPerWord-1)) == 0;
}
// The regions are visited in *decreasing* address order.
// This order aids with imprecise card marking, where a dirty
@@ -223,12 +223,12 @@
// that extend onto subsequent cards.
void ClearNoncleanCardWrapper::do_MemRegion(MemRegion mr) {
assert(mr.word_size() > 0, "Error");
assert(_ct->is_aligned(mr.start()), "mr.start() should be card aligned");
// mr.end() may not necessarily be card aligned.
- jbyte* cur_entry = _ct->byte_for(mr.last());
- const jbyte* limit = _ct->byte_for(mr.start());
+ volatile jbyte* cur_entry = _ct->byte_for(mr.last());
+ const volatile jbyte* limit = _ct->byte_for(mr.start());
HeapWord* end_of_non_clean = mr.end();
HeapWord* start_of_non_clean = end_of_non_clean;
while (cur_entry >= limit) {
HeapWord* cur_hw = _ct->addr_for(cur_entry);
if ((*cur_entry != CardTableRS::clean_card_val()) && clear_card(cur_entry)) {
@@ -243,11 +243,11 @@
_dirty_card_closure->do_MemRegion(mrd);
}
// fast forward through potential continuous whole-word range of clean cards beginning at a word-boundary
if (is_word_aligned(cur_entry)) {
- jbyte* cur_row = cur_entry - BytesPerWord;
+ volatile jbyte* cur_row = cur_entry - BytesPerWord;
while (cur_row >= limit && *((intptr_t*)cur_row) == CardTableRS::clean_card_row()) {
cur_row -= BytesPerWord;
}
cur_entry = cur_row + BytesPerWord;
cur_hw = _ct->addr_for(cur_entry);
@@ -280,11 +280,11 @@
// precleaned ==> cur_youngergen_and_prev_nonclean_card
// prev-younger-gen ==> cur_youngergen_and_prev_nonclean_card
// cur-younger-gen ==> cur_younger_gen
// cur_youngergen_and_prev_nonclean_card ==> no change.
void CardTableRS::write_ref_field_gc_par(void* field, oop new_val) {
- jbyte* entry = _ct_bs->byte_for(field);
+ volatile jbyte* entry = _ct_bs->byte_for(field);
do {
jbyte entry_val = *entry;
// We put this first because it's probably the most common case.
if (entry_val == clean_card_val()) {
// No threat of contention with cleaning threads.
@@ -435,15 +435,15 @@
void CardTableRS::verify_space(Space* s, HeapWord* gen_boundary) {
// We don't need to do young-gen spaces.
if (s->end() <= gen_boundary) return;
MemRegion used = s->used_region();
- jbyte* cur_entry = byte_for(used.start());
- jbyte* limit = byte_after(used.last());
+ volatile jbyte* cur_entry = byte_for(used.start());
+ volatile jbyte* limit = byte_after(used.last());
while (cur_entry < limit) {
if (*cur_entry == clean_card_val()) {
- jbyte* first_dirty = cur_entry+1;
+ volatile jbyte* first_dirty = cur_entry+1;
while (first_dirty < limit &&
*first_dirty == clean_card_val()) {
first_dirty++;
}
// If the first object is a regular object, and it has a
< prev index next >