1.1 --- a/src/share/vm/memory/referenceProcessor.cpp Thu Mar 20 13:29:03 2014 -0700
1.2 +++ b/src/share/vm/memory/referenceProcessor.cpp Fri Jan 10 09:53:53 2014 +0100
1.3 @@ -100,7 +100,6 @@
1.4 _enqueuing_is_done(false),
1.5 _is_alive_non_header(is_alive_non_header),
1.6 _discovered_list_needs_barrier(discovered_list_needs_barrier),
1.7 - _bs(NULL),
1.8 _processing_is_mt(mt_processing),
1.9 _next_id(0)
1.10 {
1.11 @@ -126,10 +125,6 @@
1.12 _discovered_refs[i].set_length(0);
1.13 }
1.14
1.15 - // If we do barriers, cache a copy of the barrier set.
1.16 - if (discovered_list_needs_barrier) {
1.17 - _bs = Universe::heap()->barrier_set();
1.18 - }
1.19 setup_policy(false /* default soft ref policy */);
1.20 }
1.21
1.22 @@ -317,13 +312,9 @@
1.23 // Enqueue references that are not made active again, and
1.24 // clear the decks for the next collection (cycle).
1.25 ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
1.26 - // Do the oop-check on pending_list_addr missed in
1.27 - // enqueue_discovered_reflist. We should probably
1.28 - // do a raw oop_check so that future such idempotent
1.29 - // oop_stores relying on the oop-check side-effect
1.30 - // may be elided automatically and safely without
1.31 - // affecting correctness.
1.32 - oop_store(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
1.33 + // Do the post-barrier on pending_list_addr missed in
1.34 + // enqueue_discovered_reflist.
1.35 + oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
1.36
1.37 // Stop treating discovered references specially.
1.38 ref->disable_discovery();
1.39 @@ -372,15 +363,17 @@
1.40 assert(java_lang_ref_Reference::next(obj) == NULL,
1.41 "Reference not active; should not be discovered");
1.42 // Self-loop next, so as to make Ref not active.
1.43 - java_lang_ref_Reference::set_next(obj, obj);
1.44 + // Post-barrier not needed when looping to self.
1.45 + java_lang_ref_Reference::set_next_raw(obj, obj);
1.46 if (next_d == obj) { // obj is last
1.47 // Swap refs_list into pendling_list_addr and
1.48 // set obj's discovered to what we read from pending_list_addr.
1.49 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
1.50 - // Need oop_check on pending_list_addr above;
1.51 - // see special oop-check code at the end of
1.52 + // Need post-barrier on pending_list_addr above;
1.53 + // see special post-barrier code at the end of
1.54 // enqueue_discovered_reflists() further below.
1.55 - java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL
1.56 + java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
1.57 + oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
1.58 }
1.59 }
1.60 } else { // Old behaviour
1.61 @@ -516,13 +509,11 @@
1.62 // the reference object and will fail
1.63 // CT verification.
1.64 if (UseG1GC) {
1.65 - BarrierSet* bs = oopDesc::bs();
1.66 HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
1.67 -
1.68 if (UseCompressedOops) {
1.69 - bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
1.70 + oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
1.71 } else {
1.72 - bs->write_ref_field_pre((oop*)next_addr, NULL);
1.73 + oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
1.74 }
1.75 java_lang_ref_Reference::set_next_raw(_ref, NULL);
1.76 } else {
1.77 @@ -790,10 +781,9 @@
1.78 };
1.79
1.80 void ReferenceProcessor::set_discovered(oop ref, oop value) {
1.81 + java_lang_ref_Reference::set_discovered_raw(ref, value);
1.82 if (_discovered_list_needs_barrier) {
1.83 - java_lang_ref_Reference::set_discovered(ref, value);
1.84 - } else {
1.85 - java_lang_ref_Reference::set_discovered_raw(ref, value);
1.86 + oopDesc::bs()->write_ref_field(ref, value);
1.87 }
1.88 }
1.89
1.90 @@ -1085,7 +1075,7 @@
1.91 // so this will expand to nothing. As a result, we have manually
1.92 // elided this out for G1, but left in the test for some future
1.93 // collector that might have need for a pre-barrier here, e.g.:-
1.94 - // _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
1.95 + // oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
1.96 assert(!_discovered_list_needs_barrier || UseG1GC,
1.97 "Need to check non-G1 collector: "
1.98 "may need a pre-write-barrier for CAS from NULL below");
1.99 @@ -1098,7 +1088,7 @@
1.100 refs_list.set_head(obj);
1.101 refs_list.inc_length(1);
1.102 if (_discovered_list_needs_barrier) {
1.103 - _bs->write_ref_field((void*)discovered_addr, next_discovered);
1.104 + oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
1.105 }
1.106
1.107 if (TraceReferenceGC) {
1.108 @@ -1260,13 +1250,13 @@
1.109
1.110 // As in the case further above, since we are over-writing a NULL
1.111 // pre-value, we can safely elide the pre-barrier here for the case of G1.
1.112 - // e.g.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
1.113 + // e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
1.114 assert(discovered == NULL, "control point invariant");
1.115 assert(!_discovered_list_needs_barrier || UseG1GC,
1.116 "For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
1.117 oop_store_raw(discovered_addr, next_discovered);
1.118 if (_discovered_list_needs_barrier) {
1.119 - _bs->write_ref_field((void*)discovered_addr, next_discovered);
1.120 + oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
1.121 }
1.122 list->set_head(obj);
1.123 list->inc_length(1);
