graal-jvmci-8: src/share/vm/memory/referenceProcessor.cpp comparison

comparison src/share/vm/memory/referenceProcessor.cpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank

author	ysr
date	Wed, 07 Sep 2011 13:55:42 -0700
parents	c2bf0120ee5d
children	4dfb2df418f2

comparison

equal deleted inserted replaced

-:05550041d664
+:eca1193ca245
 #include "runtime/jniHandles.hpp"
 ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
 ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;
 const int        subclasses_of_ref                = REF_PHANTOM - REF_OTHER;
+bool             ReferenceProcessor::_pending_list_uses_discovered_field = false;
 // List of discovered references.
 class DiscoveredList {
 public:
 DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
 vm_exit_during_initialization("Could not allocate reference policy object");
 }
 guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery ||
 RefDiscoveryPolicy == ReferentBasedDiscovery,
 "Unrecongnized RefDiscoveryPolicy");
+_pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field();
 }
 ReferenceProcessor::ReferenceProcessor(MemRegion span,
 bool      mt_processing,
 int       mt_processing_degree,
 // Initialized all entries to NULL
 for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
 _discoveredSoftRefs[i].set_head(NULL);
 _discoveredSoftRefs[i].set_length(0);
 }
-// If we do barreirs, cache a copy of the barrier set.
+// If we do barriers, cache a copy of the barrier set.
 if (discovered_list_needs_barrier) {
 _bs = Universe::heap()->barrier_set();
 }
 setup_policy(false /* default soft ref policy */);
 }
 }
 void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
 HeapWord* pending_list_addr) {
 // Given a list of refs linked through the "discovered" field
-// (java.lang.ref.Reference.discovered) chain them through the
+// (java.lang.ref.Reference.discovered), self-loop their "next" field
-// "next" field (java.lang.ref.Reference.next) and prepend
+// thus distinguishing them from active References, then
-// to the pending list.
+// prepend them to the pending list.
+// BKWRD COMPATIBILITY NOTE: For older JDKs (prior to the fix for 4956777),
+// the "next" field is used to chain the pending list, not the discovered
+// field.
 if (TraceReferenceGC && PrintGCDetails) {
 gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list "
 INTPTR_FORMAT, (address)refs_list.head());
 }
 oop obj = NULL;
-oop next = refs_list.head();
+oop next_d = refs_list.head();
-// Walk down the list, copying the discovered field into
+if (pending_list_uses_discovered_field()) { // New behaviour
-// the next field and clearing it.
+// Walk down the list, self-looping the next field
-while (obj != next) {
+// so that the References are not considered active.
-obj = next;
+while (obj != next_d) {
-assert(obj->is_instanceRef(), "should be reference object");
+obj = next_d;
-next = java_lang_ref_Reference::discovered(obj);
+assert(obj->is_instanceRef(), "should be reference object");
-if (TraceReferenceGC && PrintGCDetails) {
+next_d = java_lang_ref_Reference::discovered(obj);
-gclog_or_tty->print_cr("        obj " INTPTR_FORMAT "/next " INTPTR_FORMAT,
+if (TraceReferenceGC && PrintGCDetails) {
-obj, next);
+gclog_or_tty->print_cr("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
-}
+obj, next_d);
-assert(java_lang_ref_Reference::next(obj) == NULL,
+}
-"The reference should not be enqueued");
+assert(java_lang_ref_Reference::next(obj) == NULL,
-if (next == obj) {  // obj is last
+"Reference not active; should not be discovered");
-// Swap refs_list into pendling_list_addr and
+// Self-loop next, so as to make Ref not active.
-// set obj's next to what we read from pending_list_addr.
+java_lang_ref_Reference::set_next(obj, obj);
-oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
+if (next_d == obj) {  // obj is last
-// Need oop_check on pending_list_addr above;
+// Swap refs_list into pendling_list_addr and
-// see special oop-check code at the end of
+// set obj's discovered to what we read from pending_list_addr.
-// enqueue_discovered_reflists() further below.
+oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
-if (old == NULL) {
+// Need oop_check on pending_list_addr above;
-// obj should be made to point to itself, since
+// see special oop-check code at the end of
-// pending list was empty.
+// enqueue_discovered_reflists() further below.
-java_lang_ref_Reference::set_next(obj, obj);
+java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL
+}
+}
+} else { // Old behaviour
+// Walk down the list, copying the discovered field into
+// the next field and clearing the discovered field.
+while (obj != next_d) {
+obj = next_d;
+assert(obj->is_instanceRef(), "should be reference object");
+next_d = java_lang_ref_Reference::discovered(obj);
+if (TraceReferenceGC && PrintGCDetails) {
+gclog_or_tty->print_cr("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
+obj, next_d);
+}
+assert(java_lang_ref_Reference::next(obj) == NULL,
+"The reference should not be enqueued");
+if (next_d == obj) {  // obj is last
+// Swap refs_list into pendling_list_addr and
+// set obj's next to what we read from pending_list_addr.
+oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
+// Need oop_check on pending_list_addr above;
+// see special oop-check code at the end of
+// enqueue_discovered_reflists() further below.
+if (old == NULL) {
+// obj should be made to point to itself, since
+// pending list was empty.
+java_lang_ref_Reference::set_next(obj, obj);
+} else {
+java_lang_ref_Reference::set_next(obj, old);
+}
 } else {
-java_lang_ref_Reference::set_next(obj, old);
+java_lang_ref_Reference::set_next(obj, next_d);
 }
-} else {
+java_lang_ref_Reference::set_discovered(obj, (oop) NULL);
-java_lang_ref_Reference::set_next(obj, next);
+}
-}
-java_lang_ref_Reference::set_discovered(obj, (oop) NULL);
 }
 }
 // Parallel enqueue task
 class RefProcEnqueueTask: public AbstractRefProcTaskExecutor::EnqueueTask {
 // Close the reachable set
 complete_gc->do_void();
 NOT_PRODUCT(
 if (PrintGCDetails && TraceReferenceGC) {
 gclog_or_tty->print_cr(" Dropped %d dead Refs out of %d "
-"discovered Refs by policy  list " INTPTR_FORMAT,
+"discovered Refs by policy, from list " INTPTR_FORMAT,
 iter.removed(), iter.processed(), (address)refs_list.head());
 }
 )
 }
 // Note: In the case of G1, this specific pre-barrier is strictly
 // not necessary because the only case we are interested in
 // 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.
+// collector that might have need for a pre-barrier here, e.g.:-
-if (_discovered_list_needs_barrier && !UseG1GC) {
+// _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
-if (UseCompressedOops) {
+assert(!_discovered_list_needs_barrier || UseG1GC,
-_bs->write_ref_field_pre((narrowOop*)discovered_addr, next_discovered);
+"Need to check non-G1 collector: "
-} else {
+"may need a pre-write-barrier for CAS from NULL below");
-_bs->write_ref_field_pre((oop*)discovered_addr, next_discovered);
-}
-guarantee(false, "Need to check non-G1 collector");
-}
 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
+// 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) {
 _bs->write_ref_field((void*)discovered_addr, next_discovered);
 }
 if (TraceReferenceGC) {
-gclog_or_tty->print_cr("Enqueued reference (mt) (" INTPTR_FORMAT ": %s)",
+gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
 obj, obj->blueprint()->internal_name());
 }
 } else {
 // If retest was non NULL, another thread beat us to it:
 // The reference has already been discovered...
 if (TraceReferenceGC) {
-gclog_or_tty->print_cr("Already enqueued reference (" INTPTR_FORMAT ": %s)",
+gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
 obj, obj->blueprint()->internal_name());
 }
 }
 }
 // We mention two of several possible choices here:
 // #0: if the reference object is not in the "originating generation"
 //     (or part of the heap being collected, indicated by our "span"
 //     we don't treat it specially (i.e. we scan it as we would
 //     a normal oop, treating its references as strong references).
-//     This means that references can't be enqueued unless their
+//     This means that references can't be discovered unless their
 //     referent is also in the same span. This is the simplest,
 //     most "local" and most conservative approach, albeit one
 //     that may cause weak references to be enqueued least promptly.
 //     We call this choice the "ReferenceBasedDiscovery" policy.
 // #1: the reference object may be in any generation (span), but if
 //     in certain cases, enqueue references somewhat sooner than
 //     might Policy #0 above, but at marginally increased cost
 //     and complexity in processing these references.
 //     We call this choice the "RefeferentBasedDiscovery" policy.
 bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
-// We enqueue references only if we are discovering refs
+// Make sure we are discovering refs (rather than processing discovered refs).
-// (rather than processing discovered refs).
 if (!_discovering_refs || !RegisterReferences) {
 return false;
 }
-// We only enqueue active references.
+// We only discover active references.
 oop next = java_lang_ref_Reference::next(obj);
-if (next != NULL) {
+if (next != NULL) {   // Ref is no longer active
 return false;
 }
 HeapWord* obj_addr = (HeapWord*)obj;
 if (RefDiscoveryPolicy == ReferenceBasedDiscovery &&
 // don't treat it specially (i.e. we want to scan it as a normal
 // object with strong references).
 return false;
 }
-// We only enqueue references whose referents are not (yet) strongly
+// We only discover references whose referents are not (yet)
-// reachable.
+// known to be strongly reachable.
 if (is_alive_non_header() != NULL) {
 verify_referent(obj);
 if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {
 return false;  // referent is reachable
 }
 const oop  discovered = java_lang_ref_Reference::discovered(obj);
 assert(discovered->is_oop_or_null(), "bad discovered field");
 if (discovered != NULL) {
 // The reference has already been discovered...
 if (TraceReferenceGC) {
-gclog_or_tty->print_cr("Already enqueued reference (" INTPTR_FORMAT ": %s)",
+gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
 obj, obj->blueprint()->internal_name());
 }
 if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
 // assumes that an object is not processed twice;
 // if it's been already discovered it must be on another
 }
 }
 if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
 verify_referent(obj);
-// enqueue if and only if either:
+// Discover if and only if EITHER:
-// reference is in our span or
+// .. reference is in our span, OR
-// we are an atomic collector and referent is in our span
+// .. we are an atomic collector and referent is in our span
 if (_span.contains(obj_addr) ||
 (discovery_is_atomic() &&
 _span.contains(java_lang_ref_Reference::referent(obj)))) {
 // should_enqueue = true;
 } else {
 // The last ref must have its discovered field pointing to itself.
 oop next_discovered = (current_head != NULL) ? current_head : obj;
 // 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.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
 assert(discovered == NULL, "control point invariant");
-if (_discovered_list_needs_barrier && !UseG1GC) { // safe to elide for G1
+assert(!_discovered_list_needs_barrier || UseG1GC,
-if (UseCompressedOops) {
+"For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
-_bs->write_ref_field_pre((narrowOop*)discovered_addr, next_discovered);
-} else {
-_bs->write_ref_field_pre((oop*)discovered_addr, next_discovered);
-}
-guarantee(false, "Need to check non-G1 collector");
-}
 oop_store_raw(discovered_addr, next_discovered);
 if (_discovered_list_needs_barrier) {
 _bs->write_ref_field((void*)discovered_addr, next_discovered);
 }
 list->set_head(obj);
 list->inc_length(1);
 if (TraceReferenceGC) {
-gclog_or_tty->print_cr("Enqueued reference (" INTPTR_FORMAT ": %s)",
+gclog_or_tty->print_cr("Discovered reference (" INTPTR_FORMAT ": %s)",
 obj, obj->blueprint()->internal_name());
 }
 }
-assert(obj->is_oop(), "Enqueued a bad reference");
+assert(obj->is_oop(), "Discovered a bad reference");
 verify_referent(obj);
 return true;
 }
 // Preclean the discovered references by removing those

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/referenceProcessor.cpp @ 3917:eca1193ca245