src/share/vm/memory/referenceProcessor.cpp
Print this page
rev 5823 : 8031703: Missing post-barrier in ReferenceProcessor
@@ -93,15 +93,15 @@
uint mt_processing_degree,
bool mt_discovery,
uint mt_discovery_degree,
bool atomic_discovery,
BoolObjectClosure* is_alive_non_header,
- bool discovered_list_needs_barrier) :
+ bool discovered_list_needs_post_barrier) :
_discovering_refs(false),
_enqueuing_is_done(false),
_is_alive_non_header(is_alive_non_header),
- _discovered_list_needs_barrier(discovered_list_needs_barrier),
+ _discovered_list_needs_post_barrier(discovered_list_needs_post_barrier),
_processing_is_mt(mt_processing),
_next_id(0)
{
_span = span;
_discovery_is_atomic = atomic_discovery;
@@ -488,17 +488,17 @@
// and _prev will be NULL.
new_next = _prev;
} else {
new_next = _next;
}
-
- if (UseCompressedOops) {
- // Remove Reference object from list.
- oopDesc::encode_store_heap_oop((narrowOop*)_prev_next, new_next);
- } else {
- // Remove Reference object from list.
- oopDesc::store_heap_oop((oop*)_prev_next, new_next);
+ // Remove Reference object from discovered list. Note that G1 does not need a
+ // pre-barrier here because we know the Reference has already been found/marked,
+ // that's how it ended up in the discovered list in the first place.
+ oop_store_raw(_prev_next, new_next);
+ if (_discovered_list_needs_post_barrier && _prev_next != _refs_list.adr_head()) {
+ // Needs post-barrier and this is not the list head (which is not on the heap)
+ oopDesc::bs()->write_ref_field(_prev_next, new_next);
}
NOT_PRODUCT(_removed++);
_refs_list.dec_length(1);
}
@@ -542,11 +542,11 @@
ReferencePolicy* policy,
BoolObjectClosure* is_alive,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
assert(policy != NULL, "Must have a non-NULL policy");
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
+ DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
// Decide which softly reachable refs should be kept alive.
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
if (referent_is_dead &&
@@ -582,11 +582,11 @@
void
ReferenceProcessor::pp2_work(DiscoveredList& refs_list,
BoolObjectClosure* is_alive,
OopClosure* keep_alive) {
assert(discovery_is_atomic(), "Error");
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
+ DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
assert(next == NULL, "Should not discover inactive Reference");
if (iter.is_referent_alive()) {
@@ -619,11 +619,11 @@
ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList& refs_list,
BoolObjectClosure* is_alive,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
assert(!discovery_is_atomic(), "Error");
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
+ DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
oop next = java_lang_ref_Reference::next(iter.obj());
if ((iter.referent() == NULL || iter.is_referent_alive() ||
@@ -662,11 +662,11 @@
bool clear_referent,
BoolObjectClosure* is_alive,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
ResourceMark rm;
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
+ DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
while (iter.has_next()) {
iter.update_discovered();
iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
if (clear_referent) {
// NULL out referent pointer
@@ -780,12 +780,12 @@
bool _clear_referent;
};
void ReferenceProcessor::set_discovered(oop ref, oop value) {
java_lang_ref_Reference::set_discovered_raw(ref, value);
- if (_discovered_list_needs_barrier) {
- oopDesc::bs()->write_ref_field(ref, value);
+ if (_discovered_list_needs_post_barrier) {
+ oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(ref), value);
}
}
// Balances reference queues.
// Move entries from all queues[0, 1, ..., _max_num_q-1] to
@@ -978,11 +978,11 @@
}
}
void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
assert(!discovery_is_atomic(), "Else why call this method?");
- DiscoveredListIterator iter(refs_list, NULL, NULL);
+ DiscoveredListIterator iter(refs_list, NULL, NULL, _discovered_list_needs_post_barrier);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
oop next = java_lang_ref_Reference::next(iter.obj());
assert(next->is_oop_or_null(), "bad next field");
// If referent has been cleared or Reference is not active,
@@ -1074,22 +1074,22 @@
// here is when *discovered_addr is NULL (see the CAS further below),
// so this will expand to nothing. As a result, we have manually
// elided this out for G1, but left in the test for some future
// collector that might have need for a pre-barrier here, e.g.:-
// oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
- assert(!_discovered_list_needs_barrier || UseG1GC,
+ assert(!_discovered_list_needs_post_barrier || UseG1GC,
"Need to check non-G1 collector: "
"may need a pre-write-barrier for CAS from NULL below");
oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
NULL);
if (retest == NULL) {
// This thread just won the right to enqueue the object.
// We have separate lists for enqueueing, so no synchronization
// is necessary.
refs_list.set_head(obj);
refs_list.inc_length(1);
- if (_discovered_list_needs_barrier) {
+ if (_discovered_list_needs_post_barrier) {
oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
@@ -1238,11 +1238,11 @@
}
if (_discovery_is_mt) {
add_to_discovered_list_mt(*list, obj, discovered_addr);
} else {
- // If "_discovered_list_needs_barrier", we do write barriers when
+ // If "_discovered_list_needs_post_barrier", we do write barriers when
// updating the discovered reference list. Otherwise, we do a raw store
// here: the field will be visited later when processing the discovered
// references.
oop current_head = list->head();
// The last ref must have its discovered field pointing to itself.
@@ -1250,14 +1250,14 @@
// As in the case further above, since we are over-writing a NULL
// pre-value, we can safely elide the pre-barrier here for the case of G1.
// e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(discovered == NULL, "control point invariant");
- assert(!_discovered_list_needs_barrier || UseG1GC,
+ assert(!_discovered_list_needs_post_barrier || UseG1GC,
"For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
oop_store_raw(discovered_addr, next_discovered);
- if (_discovered_list_needs_barrier) {
+ if (_discovered_list_needs_post_barrier) {
oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
list->set_head(obj);
list->inc_length(1);
@@ -1349,11 +1349,11 @@
ReferenceProcessor::preclean_discovered_reflist(DiscoveredList& refs_list,
BoolObjectClosure* is_alive,
OopClosure* keep_alive,
VoidClosure* complete_gc,
YieldClosure* yield) {
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
+ DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
oop obj = iter.obj();
oop next = java_lang_ref_Reference::next(obj);
if (iter.referent() == NULL || iter.is_referent_alive() ||