1 /*

     2  * Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "classfile/javaClasses.inline.hpp"

    27 #include "classfile/systemDictionary.hpp"

    28 #include "gc/shared/collectedHeap.hpp"

    29 #include "gc/shared/collectedHeap.inline.hpp"

    30 #include "gc/shared/gcTimer.hpp"

    31 #include "gc/shared/gcTraceTime.inline.hpp"

    32 #include "gc/shared/referencePolicy.hpp"

    33 #include "gc/shared/referenceProcessor.inline.hpp"

    34 #include "logging/log.hpp"

    35 #include "memory/allocation.hpp"

    36 #include "memory/resourceArea.hpp"

    37 #include "oops/oop.inline.hpp"

    38 #include "runtime/java.hpp"

    39 #include "runtime/jniHandles.hpp"

    40 

    41 ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;

    42 ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;

    43 jlong            ReferenceProcessor::_soft_ref_timestamp_clock = 0;

    44 

    45 void referenceProcessor_init() {

    46   ReferenceProcessor::init_statics();

    47 }

    48 

    49 void ReferenceProcessor::init_statics() {

    50   // We need a monotonically non-decreasing time in ms but

    51   // os::javaTimeMillis() does not guarantee monotonicity.

    52   jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;

    53 

    54   // Initialize the soft ref timestamp clock.

    55   _soft_ref_timestamp_clock = now;

    56   // Also update the soft ref clock in j.l.r.SoftReference

    57   java_lang_ref_SoftReference::set_clock(_soft_ref_timestamp_clock);

    58 

    59   _always_clear_soft_ref_policy = new AlwaysClearPolicy();

    60   if (is_server_compilation_mode_vm()) {

    61     _default_soft_ref_policy = new LRUMaxHeapPolicy();

    62   } else {

    63     _default_soft_ref_policy = new LRUCurrentHeapPolicy();

    64   }

    65   if (_always_clear_soft_ref_policy == NULL || _default_soft_ref_policy == NULL) {

    66     vm_exit_during_initialization("Could not allocate reference policy object");

    67   }

    68   guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery ||

    69             RefDiscoveryPolicy == ReferentBasedDiscovery,

    70             "Unrecognized RefDiscoveryPolicy");

    71 }

    72 

    73 void ReferenceProcessor::enable_discovery(bool check_no_refs) {

    74 #ifdef ASSERT

    75   // Verify that we're not currently discovering refs

    76   assert(!_discovering_refs, "nested call?");

    77 

    78   if (check_no_refs) {

    79     // Verify that the discovered lists are empty

    80     verify_no_references_recorded();

    81   }

    82 #endif // ASSERT

    83 

    84   // Someone could have modified the value of the static

    85   // field in the j.l.r.SoftReference class that holds the

    86   // soft reference timestamp clock using reflection or

    87   // Unsafe between GCs. Unconditionally update the static

    88   // field in ReferenceProcessor here so that we use the new

    89   // value during reference discovery.

    90 

    91   _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();

    92   _discovering_refs = true;

    93 }

    94 

    95 ReferenceProcessor::ReferenceProcessor(MemRegion span,

    96                                        bool      mt_processing,

    97                                        uint      mt_processing_degree,

    98                                        bool      mt_discovery,

    99                                        uint      mt_discovery_degree,

   100                                        bool      atomic_discovery,

   101                                        BoolObjectClosure* is_alive_non_header)  :

   102   _discovering_refs(false),

   103   _enqueuing_is_done(false),

   104   _is_alive_non_header(is_alive_non_header),

   105   _processing_is_mt(mt_processing),

   106   _next_id(0)

   107 {

   108   _span = span;

   109   _discovery_is_atomic = atomic_discovery;

   110   _discovery_is_mt     = mt_discovery;

   111   _num_q               = MAX2(1U, mt_processing_degree);

   112   _max_num_q           = MAX2(_num_q, mt_discovery_degree);

   113   _discovered_refs     = NEW_C_HEAP_ARRAY(DiscoveredList,

   114             _max_num_q * number_of_subclasses_of_ref(), mtGC);

   115 

   116   if (_discovered_refs == NULL) {

   117     vm_exit_during_initialization("Could not allocated RefProc Array");

   118   }

   119   _discoveredSoftRefs    = &_discovered_refs[0];

   120   _discoveredWeakRefs    = &_discoveredSoftRefs[_max_num_q];

   121   _discoveredFinalRefs   = &_discoveredWeakRefs[_max_num_q];

   122   _discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];

   123 

   124   // Initialize all entries to NULL

   125   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

   126     _discovered_refs[i].set_head(NULL);

   127     _discovered_refs[i].set_length(0);

   128   }

   129 

   130   setup_policy(false /* default soft ref policy */);

   131 }

   132 

   133 #ifndef PRODUCT

   134 void ReferenceProcessor::verify_no_references_recorded() {

   135   guarantee(!_discovering_refs, "Discovering refs?");

   136   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

   137     guarantee(_discovered_refs[i].is_empty(),

   138               "Found non-empty discovered list at %u", i);

   139   }

   140 }

   141 #endif

   142 

   143 void ReferenceProcessor::weak_oops_do(OopClosure* f) {

   144   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

   145     if (UseCompressedOops) {

   146       f->do_oop((narrowOop*)_discovered_refs[i].adr_head());

   147     } else {

   148       f->do_oop((oop*)_discovered_refs[i].adr_head());

   149     }

   150   }

   151 }

   152 

   153 void ReferenceProcessor::update_soft_ref_master_clock() {

   154   // Update (advance) the soft ref master clock field. This must be done

   155   // after processing the soft ref list.

   156 

   157   // We need a monotonically non-decreasing time in ms but

   158   // os::javaTimeMillis() does not guarantee monotonicity.

   159   jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;

   160   jlong soft_ref_clock = java_lang_ref_SoftReference::clock();

   161   assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");

   162 

   163   NOT_PRODUCT(

   164   if (now < _soft_ref_timestamp_clock) {

   165     log_warning(gc)("time warp: " JLONG_FORMAT " to " JLONG_FORMAT,

   166                     _soft_ref_timestamp_clock, now);

   167   }

   168   )

   169   // The values of now and _soft_ref_timestamp_clock are set using

   170   // javaTimeNanos(), which is guaranteed to be monotonically

   171   // non-decreasing provided the underlying platform provides such

   172   // a time source (and it is bug free).

   173   // In product mode, however, protect ourselves from non-monotonicity.

   174   if (now > _soft_ref_timestamp_clock) {

   175     _soft_ref_timestamp_clock = now;

   176     java_lang_ref_SoftReference::set_clock(now);

   177   }

   178   // Else leave clock stalled at its old value until time progresses

   179   // past clock value.

   180 }

   181 

   182 size_t ReferenceProcessor::total_count(DiscoveredList lists[]) const {

   183   size_t total = 0;

   184   for (uint i = 0; i < _max_num_q; ++i) {

   185     total += lists[i].length();

   186   }

   187   return total;

   188 }

   189 

   190 ReferenceProcessorStats ReferenceProcessor::process_discovered_references(

   191   BoolObjectClosure*            is_alive,

   192   OopClosure*                   keep_alive,

   193   VoidClosure*                  complete_gc,

   194   AbstractRefProcTaskExecutor*  task_executor,

   195   ReferenceProcessorPhaseTimes* phase_times) {

   196 

   197   double start_time = os::elapsedTime();

   198 

   199   assert(!enqueuing_is_done(), "If here enqueuing should not be complete");

   200   // Stop treating discovered references specially.

   201   disable_discovery();

   202 

   203   // If discovery was concurrent, someone could have modified

   204   // the value of the static field in the j.l.r.SoftReference

   205   // class that holds the soft reference timestamp clock using

   206   // reflection or Unsafe between when discovery was enabled and

   207   // now. Unconditionally update the static field in ReferenceProcessor

   208   // here so that we use the new value during processing of the

   209   // discovered soft refs.

   210 

   211   _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();

   212 

   213   ReferenceProcessorStats stats(total_count(_discoveredSoftRefs),

   214                                 total_count(_discoveredWeakRefs),

   215                                 total_count(_discoveredFinalRefs),

   216                                 total_count(_discoveredPhantomRefs));

   217 

   218   // Soft references

   219   {

   220     RefProcPhaseTimesTracker tt(REF_SOFT, phase_times, this);

   221     process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,

   222                                is_alive, keep_alive, complete_gc, task_executor, phase_times);

   223   }

   224 

   225   update_soft_ref_master_clock();

   226 

   227   // Weak references

   228   {

   229     RefProcPhaseTimesTracker tt(REF_WEAK, phase_times, this);

   230     process_discovered_reflist(_discoveredWeakRefs, NULL, true,

   231                                is_alive, keep_alive, complete_gc, task_executor, phase_times);

   232   }

   233 

   234   // Final references

   235   {

   236     RefProcPhaseTimesTracker tt(REF_FINAL, phase_times, this);

   237     process_discovered_reflist(_discoveredFinalRefs, NULL, false,

   238                                is_alive, keep_alive, complete_gc, task_executor, phase_times);

   239   }

   240 

   241   // Phantom references

   242   {

   243     RefProcPhaseTimesTracker tt(REF_PHANTOM, phase_times, this);

   244     process_discovered_reflist(_discoveredPhantomRefs, NULL, true,

   245                                is_alive, keep_alive, complete_gc, task_executor, phase_times);

   246   }

   247 

   248   // Weak global JNI references. It would make more sense (semantically) to

   249   // traverse these simultaneously with the regular weak references above, but

   250   // that is not how the JDK1.2 specification is. See #4126360. Native code can

   251   // thus use JNI weak references to circumvent the phantom references and

   252   // resurrect a "post-mortem" object.

   253   {

   254     GCTraceTime(Debug, gc, ref) tt("JNI Weak Reference", phase_times->gc_timer());

   255     if (task_executor != NULL) {

   256       task_executor->set_single_threaded_mode();

   257     }

   258     process_phaseJNI(is_alive, keep_alive, complete_gc);

   259   }

   260 

   261   phase_times->set_total_time_ms((os::elapsedTime() - start_time) * 1000);

   262 

   263   log_develop_trace(gc, ref)("JNI Weak Reference count: " SIZE_FORMAT, count_jni_refs());

   264 

   265   return stats;

   266 }

   267 

   268 #ifndef PRODUCT

   269 // Calculate the number of jni handles.

   270 size_t ReferenceProcessor::count_jni_refs() {

   271   class CountHandleClosure: public OopClosure {

   272   private:

   273     size_t _count;

   274   public:

   275     CountHandleClosure(): _count(0) {}

   276     void do_oop(oop* unused)       { _count++; }

   277     void do_oop(narrowOop* unused) { ShouldNotReachHere(); }

   278     size_t count() { return _count; }

   279   };

   280   CountHandleClosure global_handle_count;

   281   JNIHandles::weak_oops_do(&global_handle_count);

   282   return global_handle_count.count();

   283 }

   284 #endif

   285 

   286 void ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive,

   287                                           OopClosure*        keep_alive,

   288                                           VoidClosure*       complete_gc) {

   289   JNIHandles::weak_oops_do(is_alive, keep_alive);

   290   complete_gc->do_void();

   291 }

   292 

   293 void ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor*  task_executor,

   294                                                        ReferenceProcessorPhaseTimes* phase_times) {

   295   // Enqueue references that are not made active again, and

   296   // clear the decks for the next collection (cycle).

   297   enqueue_discovered_reflists(task_executor, phase_times);

   298 

   299   // Stop treating discovered references specially.

   300   disable_discovery();

   301 }

   302 

   303 void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list) {

   304   // Given a list of refs linked through the "discovered" field

   305   // (java.lang.ref.Reference.discovered), self-loop their "next" field

   306   // thus distinguishing them from active References, then

   307   // prepend them to the pending list.

   308   //

   309   // The Java threads will see the Reference objects linked together through

   310   // the discovered field. Instead of trying to do the write barrier updates

   311   // in all places in the reference processor where we manipulate the discovered

   312   // field we make sure to do the barrier here where we anyway iterate through

   313   // all linked Reference objects. Note that it is important to not dirty any

   314   // cards during reference processing since this will cause card table

   315   // verification to fail for G1.

   316   log_develop_trace(gc, ref)("ReferenceProcessor::enqueue_discovered_reflist list " INTPTR_FORMAT, p2i(&refs_list));

   317 

   318   oop obj = NULL;

   319   oop next_d = refs_list.head();

   320   // Walk down the list, self-looping the next field

   321   // so that the References are not considered active.

   322   while (obj != next_d) {

   323     obj = next_d;

   324     assert(obj->is_instance(), "should be an instance object");

   325     assert(InstanceKlass::cast(obj->klass())->is_reference_instance_klass(), "should be reference object");

   326     next_d = java_lang_ref_Reference::discovered(obj);

   327     log_develop_trace(gc, ref)("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, p2i(obj), p2i(next_d));

   328     assert(java_lang_ref_Reference::next(obj) == NULL,

   329            "Reference not active; should not be discovered");

   330     // Self-loop next, so as to make Ref not active.

   331     java_lang_ref_Reference::set_next_raw(obj, obj);

   332     if (next_d != obj) {

   333       oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d);

   334     } else {

   335       // This is the last object.

   336       // Swap refs_list into pending list and set obj's

   337       // discovered to what we read from the pending list.

   338       oop old = Universe::swap_reference_pending_list(refs_list.head());

   339       java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL

   340       oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);

   341     }

   342   }

   343 }

   344 

   345 // Parallel enqueue task

   346 class RefProcEnqueueTask: public AbstractRefProcTaskExecutor::EnqueueTask {

   347 public:

   348   RefProcEnqueueTask(ReferenceProcessor&           ref_processor,

   349                      DiscoveredList                discovered_refs[],

   350                      int                           n_queues,

   351                      ReferenceProcessorPhaseTimes* phase_times)

   352     : EnqueueTask(ref_processor, discovered_refs, n_queues, phase_times)

   353   { }

   354 

   355   virtual void work(unsigned int work_id) {

   356     RefProcWorkerTimeTracker tt(ReferenceProcessorPhaseTimes::RefEnqueue, _phase_times, work_id);

   357 

   358     assert(work_id < (unsigned int)_ref_processor.max_num_q(), "Index out-of-bounds");

   359     // Simplest first cut: static partitioning.

   360     int index = work_id;

   361     // The increment on "index" must correspond to the maximum number of queues

   362     // (n_queues) with which that ReferenceProcessor was created.  That

   363     // is because of the "clever" way the discovered references lists were

   364     // allocated and are indexed into.

   365     assert(_n_queues == (int) _ref_processor.max_num_q(), "Different number not expected");

   366     for (int j = 0;

   367          j < ReferenceProcessor::number_of_subclasses_of_ref();

   368          j++, index += _n_queues) {

   369       _ref_processor.enqueue_discovered_reflist(_refs_lists[index]);

   370       _refs_lists[index].set_head(NULL);

   371       _refs_lists[index].set_length(0);

   372     }

   373   }

   374 };

   375 

   376 // Enqueue references that are not made active again

   377 void ReferenceProcessor::enqueue_discovered_reflists(AbstractRefProcTaskExecutor*  task_executor,

   378                                                      ReferenceProcessorPhaseTimes* phase_times) {

   379 

   380   ReferenceProcessorStats stats(total_count(_discoveredSoftRefs),

   381                                 total_count(_discoveredWeakRefs),

   382                                 total_count(_discoveredFinalRefs),

   383                                 total_count(_discoveredPhantomRefs));

   384 

   385   RefProcEnqueueTimeTracker tt(phase_times, stats);

   386 

   387   if (_processing_is_mt && task_executor != NULL) {

   388     // Parallel code

   389     RefProcEnqueueTask tsk(*this, _discovered_refs, _max_num_q, phase_times);

   390     task_executor->execute(tsk);

   391   } else {

   392     // Serial code: call the parent class's implementation

   393     for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

   394       enqueue_discovered_reflist(_discovered_refs[i]);

   395       _discovered_refs[i].set_head(NULL);

   396       _discovered_refs[i].set_length(0);

   397     }

   398   }

   399 }

   400 

   401 void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {

   402   _discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);

   403   oop discovered = java_lang_ref_Reference::discovered(_ref);

   404   assert(_discovered_addr && oopDesc::is_oop_or_null(discovered),

   405          "Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered));

   406   _next = discovered;

   407   _referent_addr = java_lang_ref_Reference::referent_addr(_ref);

   408   _referent = java_lang_ref_Reference::referent(_ref);

   409   assert(Universe::heap()->is_in_reserved_or_null(_referent),

   410          "Wrong oop found in java.lang.Reference object");

   411   assert(allow_null_referent ?

   412              oopDesc::is_oop_or_null(_referent)

   413            : oopDesc::is_oop(_referent),

   414          "Expected an oop%s for referent field at " PTR_FORMAT,

   415          (allow_null_referent ? " or NULL" : ""),

   416          p2i(_referent));

   417 }

   418 

   419 void DiscoveredListIterator::remove() {

   420   assert(oopDesc::is_oop(_ref), "Dropping a bad reference");

   421   oop_store_raw(_discovered_addr, NULL);

   422 

   423   // First _prev_next ref actually points into DiscoveredList (gross).

   424   oop new_next;

   425   if (_next == _ref) {

   426     // At the end of the list, we should make _prev point to itself.

   427     // If _ref is the first ref, then _prev_next will be in the DiscoveredList,

   428     // and _prev will be NULL.

   429     new_next = _prev;

   430   } else {

   431     new_next = _next;

   432   }

   433   // Remove Reference object from discovered list. Note that G1 does not need a

   434   // pre-barrier here because we know the Reference has already been found/marked,

   435   // that's how it ended up in the discovered list in the first place.

   436   oop_store_raw(_prev_next, new_next);

   437   NOT_PRODUCT(_removed++);

   438   _refs_list.dec_length(1);

   439 }

   440 

   441 void DiscoveredListIterator::clear_referent() {

   442   oop_store_raw(_referent_addr, NULL);

   443 }

   444 

   445 // NOTE: process_phase*() are largely similar, and at a high level

   446 // merely iterate over the extant list applying a predicate to

   447 // each of its elements and possibly removing that element from the

   448 // list and applying some further closures to that element.

   449 // We should consider the possibility of replacing these

   450 // process_phase*() methods by abstracting them into

   451 // a single general iterator invocation that receives appropriate

   452 // closures that accomplish this work.

   453 

   454 // (SoftReferences only) Traverse the list and remove any SoftReferences whose

   455 // referents are not alive, but that should be kept alive for policy reasons.

   456 // Keep alive the transitive closure of all such referents.

   457 void

   458 ReferenceProcessor::process_phase1(DiscoveredList&    refs_list,

   459                                    ReferencePolicy*   policy,

   460                                    BoolObjectClosure* is_alive,

   461                                    OopClosure*        keep_alive,

   462                                    VoidClosure*       complete_gc) {

   463   assert(policy != NULL, "Must have a non-NULL policy");

   464   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

   465   // Decide which softly reachable refs should be kept alive.

   466   while (iter.has_next()) {

   467     iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));

   468     bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();

   469     if (referent_is_dead &&

   470         !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {

   471       log_develop_trace(gc, ref)("Dropping reference (" INTPTR_FORMAT ": %s"  ") by policy",

   472                                  p2i(iter.obj()), iter.obj()->klass()->internal_name());

   473       // Remove Reference object from list

   474       iter.remove();

   475       // keep the referent around

   476       iter.make_referent_alive();

   477       iter.move_to_next();

   478     } else {

   479       iter.next();

   480     }

   481   }

   482   // Close the reachable set

   483   complete_gc->do_void();

   484   log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " dead Refs out of " SIZE_FORMAT " discovered Refs by policy, from list " INTPTR_FORMAT,

   485                              iter.removed(), iter.processed(), p2i(&refs_list));

   486 }

   487 

   488 // Traverse the list and remove any Refs that are not active, or

   489 // whose referents are either alive or NULL.

   490 void

   491 ReferenceProcessor::pp2_work(DiscoveredList&    refs_list,

   492                              BoolObjectClosure* is_alive,

   493                              OopClosure*        keep_alive) {

   494   assert(discovery_is_atomic(), "Error");

   495   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

   496   while (iter.has_next()) {

   497     iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));

   498     DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)

   499     assert(next == NULL, "Should not discover inactive Reference");

   500     if (iter.is_referent_alive()) {

   501       log_develop_trace(gc, ref)("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)",

   502                                  p2i(iter.obj()), iter.obj()->klass()->internal_name());

   503       // The referent is reachable after all.

   504       // Remove Reference object from list.

   505       iter.remove();

   506       // Update the referent pointer as necessary: Note that this

   507       // should not entail any recursive marking because the

   508       // referent must already have been traversed.

   509       iter.make_referent_alive();

   510       iter.move_to_next();

   511     } else {

   512       iter.next();

   513     }

   514   }

   515   NOT_PRODUCT(

   516     if (iter.processed() > 0) {

   517       log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT

   518         " Refs in discovered list " INTPTR_FORMAT,

   519         iter.removed(), iter.processed(), p2i(&refs_list));

   520     }

   521   )

   522 }

   523 

   524 void

   525 ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList&    refs_list,

   526                                                   BoolObjectClosure* is_alive,

   527                                                   OopClosure*        keep_alive,

   528                                                   VoidClosure*       complete_gc) {

   529   assert(!discovery_is_atomic(), "Error");

   530   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

   531   while (iter.has_next()) {

   532     iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));

   533     HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());

   534     oop next = java_lang_ref_Reference::next(iter.obj());

   535     if ((iter.referent() == NULL || iter.is_referent_alive() ||

   536          next != NULL)) {

   537       assert(oopDesc::is_oop_or_null(next), "Expected an oop or NULL for next field at " PTR_FORMAT, p2i(next));

   538       // Remove Reference object from list

   539       iter.remove();

   540       // Trace the cohorts

   541       iter.make_referent_alive();

   542       if (UseCompressedOops) {

   543         keep_alive->do_oop((narrowOop*)next_addr);

   544       } else {

   545         keep_alive->do_oop((oop*)next_addr);

   546       }

   547       iter.move_to_next();

   548     } else {

   549       iter.next();

   550     }

   551   }

   552   // Now close the newly reachable set

   553   complete_gc->do_void();

   554   NOT_PRODUCT(

   555     if (iter.processed() > 0) {

   556       log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT

   557         " Refs in discovered list " INTPTR_FORMAT,

   558         iter.removed(), iter.processed(), p2i(&refs_list));

   559     }

   560   )

   561 }

   562 

   563 // Traverse the list and process the referents, by either

   564 // clearing them or keeping them (and their reachable

   565 // closure) alive.

   566 void

   567 ReferenceProcessor::process_phase3(DiscoveredList&    refs_list,

   568                                    bool               clear_referent,

   569                                    BoolObjectClosure* is_alive,

   570                                    OopClosure*        keep_alive,

   571                                    VoidClosure*       complete_gc) {

   572   ResourceMark rm;

   573   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);

   574   while (iter.has_next()) {

   575     iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));

   576     if (clear_referent) {

   577       // NULL out referent pointer

   578       iter.clear_referent();

   579     } else {

   580       // keep the referent around

   581       iter.make_referent_alive();

   582     }

   583     log_develop_trace(gc, ref)("Adding %sreference (" INTPTR_FORMAT ": %s) as pending",

   584                                clear_referent ? "cleared " : "", p2i(iter.obj()), iter.obj()->klass()->internal_name());

   585     assert(oopDesc::is_oop(iter.obj(), UseConcMarkSweepGC), "Adding a bad reference");

   586     iter.next();

   587   }

   588   // Close the reachable set

   589   complete_gc->do_void();

   590 }

   591 

   592 void

   593 ReferenceProcessor::clear_discovered_references(DiscoveredList& refs_list) {

   594   oop obj = NULL;

   595   oop next = refs_list.head();

   596   while (next != obj) {

   597     obj = next;

   598     next = java_lang_ref_Reference::discovered(obj);

   599     java_lang_ref_Reference::set_discovered_raw(obj, NULL);

   600   }

   601   refs_list.set_head(NULL);

   602   refs_list.set_length(0);

   603 }

   604 

   605 void ReferenceProcessor::abandon_partial_discovery() {

   606   // loop over the lists

   607   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

   608     if ((i % _max_num_q) == 0) {

   609       log_develop_trace(gc, ref)("Abandoning %s discovered list", list_name(i));

   610     }

   611     clear_discovered_references(_discovered_refs[i]);

   612   }

   613 }

   614 

   615 size_t ReferenceProcessor::total_reference_count(ReferenceType type) const {

   616   DiscoveredList* list = NULL;

   617 

   618   switch (type) {

   619     case REF_SOFT:

   620       list = _discoveredSoftRefs;

   621       break;

   622     case REF_WEAK:

   623       list = _discoveredWeakRefs;

   624       break;

   625     case REF_FINAL:

   626       list = _discoveredFinalRefs;

   627       break;

   628     case REF_PHANTOM:

   629       list = _discoveredPhantomRefs;

   630       break;

   631     case REF_OTHER:

   632     case REF_NONE:

   633     default:

   634       ShouldNotReachHere();

   635   }

   636   return total_count(list);

   637 }

   638 

   639 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {

   640 public:

   641   RefProcPhase1Task(ReferenceProcessor&           ref_processor,

   642                     DiscoveredList                refs_lists[],

   643                     ReferencePolicy*              policy,

   644                     bool                          marks_oops_alive,

   645                     ReferenceProcessorPhaseTimes* phase_times)

   646     : ProcessTask(ref_processor, refs_lists, marks_oops_alive, phase_times),

   647       _policy(policy)

   648   { }

   649   virtual void work(unsigned int i, BoolObjectClosure& is_alive,

   650                     OopClosure& keep_alive,

   651                     VoidClosure& complete_gc)

   652   {

   653     RefProcWorkerTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase1, _phase_times, i);

   654 

   655     _ref_processor.process_phase1(_refs_lists[i], _policy,

   656                                   &is_alive, &keep_alive, &complete_gc);

   657   }

   658 private:

   659   ReferencePolicy* _policy;

   660 };

   661 

   662 class RefProcPhase2Task: public AbstractRefProcTaskExecutor::ProcessTask {

   663 public:

   664   RefProcPhase2Task(ReferenceProcessor&           ref_processor,

   665                     DiscoveredList                refs_lists[],

   666                     bool                          marks_oops_alive,

   667                     ReferenceProcessorPhaseTimes* phase_times)

   668     : ProcessTask(ref_processor, refs_lists, marks_oops_alive, phase_times)

   669   { }

   670   virtual void work(unsigned int i, BoolObjectClosure& is_alive,

   671                     OopClosure& keep_alive,

   672                     VoidClosure& complete_gc)

   673   {

   674     RefProcWorkerTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase2, _phase_times, i);

   675 

   676     _ref_processor.process_phase2(_refs_lists[i],

   677                                   &is_alive, &keep_alive, &complete_gc);

   678   }

   679 };

   680 

   681 class RefProcPhase3Task: public AbstractRefProcTaskExecutor::ProcessTask {

   682 public:

   683   RefProcPhase3Task(ReferenceProcessor&           ref_processor,

   684                     DiscoveredList                refs_lists[],

   685                     bool                         clear_referent,

   686                     bool                          marks_oops_alive,

   687                     ReferenceProcessorPhaseTimes* phase_times)

   688     : ProcessTask(ref_processor, refs_lists, marks_oops_alive, phase_times),

   689       _clear_referent(clear_referent)

   690   { }

   691   virtual void work(unsigned int i, BoolObjectClosure& is_alive,

   692                     OopClosure& keep_alive,

   693                     VoidClosure& complete_gc)

   694   {

   695     RefProcWorkerTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase3, _phase_times, i);

   696 

   697     _ref_processor.process_phase3(_refs_lists[i], _clear_referent,

   698                                   &is_alive, &keep_alive, &complete_gc);

   699   }

   700 private:

   701   bool _clear_referent;

   702 };

   703 

   704 #ifndef PRODUCT

   705 void ReferenceProcessor::log_reflist_counts(DiscoveredList ref_lists[], uint active_length, size_t total_refs) {

   706   if (!log_is_enabled(Trace, gc, ref)) {

   707     return;

   708   }

   709 

   710   stringStream st;

   711   for (uint i = 0; i < active_length; ++i) {

   712     st.print(SIZE_FORMAT " ", ref_lists[i].length());

   713   }

   714   log_develop_trace(gc, ref)("%s= " SIZE_FORMAT, st.as_string(), total_refs);

   715 #ifdef ASSERT

   716   for (uint i = active_length; i < _max_num_q; i++) {

   717     assert(ref_lists[i].length() == 0, SIZE_FORMAT " unexpected References in %u",

   718            ref_lists[i].length(), i);

   719   }

   720 #endif

   721 }

   722 #endif

   723 

   724 void ReferenceProcessor::set_active_mt_degree(uint v) {

   725   _num_q = v;

   726   _next_id = 0;

   727 }

   728 

   729 // Balances reference queues.

   730 // Move entries from all queues[0, 1, ..., _max_num_q-1] to

   731 // queues[0, 1, ..., _num_q-1] because only the first _num_q

   732 // corresponding to the active workers will be processed.

   733 void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])

   734 {

   735   // calculate total length

   736   size_t total_refs = 0;

   737   log_develop_trace(gc, ref)("Balance ref_lists ");

   738 

   739   for (uint i = 0; i < _max_num_q; ++i) {

   740     total_refs += ref_lists[i].length();

   741   }

   742   log_reflist_counts(ref_lists, _max_num_q, total_refs);

   743   size_t avg_refs = total_refs / _num_q + 1;

   744   uint to_idx = 0;

   745   for (uint from_idx = 0; from_idx < _max_num_q; from_idx++) {

   746     bool move_all = false;

   747     if (from_idx >= _num_q) {

   748       move_all = ref_lists[from_idx].length() > 0;

   749     }

   750     while ((ref_lists[from_idx].length() > avg_refs) ||

   751            move_all) {

   752       assert(to_idx < _num_q, "Sanity Check!");

   753       if (ref_lists[to_idx].length() < avg_refs) {

   754         // move superfluous refs

   755         size_t refs_to_move;

   756         // Move all the Ref's if the from queue will not be processed.

   757         if (move_all) {

   758           refs_to_move = MIN2(ref_lists[from_idx].length(),

   759                               avg_refs - ref_lists[to_idx].length());

   760         } else {

   761           refs_to_move = MIN2(ref_lists[from_idx].length() - avg_refs,

   762                               avg_refs - ref_lists[to_idx].length());

   763         }

   764 

   765         assert(refs_to_move > 0, "otherwise the code below will fail");

   766 

   767         oop move_head = ref_lists[from_idx].head();

   768         oop move_tail = move_head;

   769         oop new_head  = move_head;

   770         // find an element to split the list on

   771         for (size_t j = 0; j < refs_to_move; ++j) {

   772           move_tail = new_head;

   773           new_head = java_lang_ref_Reference::discovered(new_head);

   774         }

   775 

   776         // Add the chain to the to list.

   777         if (ref_lists[to_idx].head() == NULL) {

   778           // to list is empty. Make a loop at the end.

   779           java_lang_ref_Reference::set_discovered_raw(move_tail, move_tail);

   780         } else {

   781           java_lang_ref_Reference::set_discovered_raw(move_tail, ref_lists[to_idx].head());

   782         }

   783         ref_lists[to_idx].set_head(move_head);

   784         ref_lists[to_idx].inc_length(refs_to_move);

   785 

   786         // Remove the chain from the from list.

   787         if (move_tail == new_head) {

   788           // We found the end of the from list.

   789           ref_lists[from_idx].set_head(NULL);

   790         } else {

   791           ref_lists[from_idx].set_head(new_head);

   792         }

   793         ref_lists[from_idx].dec_length(refs_to_move);

   794         if (ref_lists[from_idx].length() == 0) {

   795           break;

   796         }

   797       } else {

   798         to_idx = (to_idx + 1) % _num_q;

   799       }

   800     }

   801   }

   802 #ifdef ASSERT

   803   size_t balanced_total_refs = 0;

   804   for (uint i = 0; i < _num_q; ++i) {

   805     balanced_total_refs += ref_lists[i].length();

   806   }

   807   log_reflist_counts(ref_lists, _num_q, balanced_total_refs);

   808   assert(total_refs == balanced_total_refs, "Balancing was incomplete");

   809 #endif

   810 }

   811 

   812 void ReferenceProcessor::balance_all_queues() {

   813   balance_queues(_discoveredSoftRefs);

   814   balance_queues(_discoveredWeakRefs);

   815   balance_queues(_discoveredFinalRefs);

   816   balance_queues(_discoveredPhantomRefs);

   817 }

   818 

   819 void ReferenceProcessor::process_discovered_reflist(

   820   DiscoveredList                refs_lists[],

   821   ReferencePolicy*              policy,

   822   bool                          clear_referent,

   823   BoolObjectClosure*            is_alive,

   824   OopClosure*                   keep_alive,

   825   VoidClosure*                  complete_gc,

   826   AbstractRefProcTaskExecutor*  task_executor,

   827   ReferenceProcessorPhaseTimes* phase_times)

   828 {

   829   bool mt_processing = task_executor != NULL && _processing_is_mt;

   830 

   831   phase_times->set_processing_is_mt(mt_processing);

   832 

   833   // If discovery used MT and a dynamic number of GC threads, then

   834   // the queues must be balanced for correctness if fewer than the

   835   // maximum number of queues were used.  The number of queue used

   836   // during discovery may be different than the number to be used

   837   // for processing so don't depend of _num_q < _max_num_q as part

   838   // of the test.

   839   bool must_balance = _discovery_is_mt;

   840 

   841   if ((mt_processing && ParallelRefProcBalancingEnabled) ||

   842       must_balance) {

   843     RefProcBalanceQueuesTimeTracker tt(phase_times);

   844     balance_queues(refs_lists);

   845   }

   846 

   847   // Phase 1 (soft refs only):

   848   // . Traverse the list and remove any SoftReferences whose

   849   //   referents are not alive, but that should be kept alive for

   850   //   policy reasons. Keep alive the transitive closure of all

   851   //   such referents.

   852   if (policy != NULL) {

   853     RefProcParPhaseTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase1, phase_times);

   854 

   855     if (mt_processing) {

   856       RefProcPhase1Task phase1(*this, refs_lists, policy, true /*marks_oops_alive*/, phase_times);

   857       task_executor->execute(phase1);

   858     } else {

   859       for (uint i = 0; i < _max_num_q; i++) {

   860         process_phase1(refs_lists[i], policy,

   861                        is_alive, keep_alive, complete_gc);

   862       }

   863     }

   864   } else { // policy == NULL

   865     assert(refs_lists != _discoveredSoftRefs,

   866            "Policy must be specified for soft references.");

   867   }

   868 

   869   // Phase 2:

   870   // . Traverse the list and remove any refs whose referents are alive.

   871   {

   872     RefProcParPhaseTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase2, phase_times);

   873 

   874     if (mt_processing) {

   875       RefProcPhase2Task phase2(*this, refs_lists, !discovery_is_atomic() /*marks_oops_alive*/, phase_times);

   876       task_executor->execute(phase2);

   877     } else {

   878       for (uint i = 0; i < _max_num_q; i++) {

   879         process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);

   880       }

   881     }

   882   }

   883 

   884   // Phase 3:

   885   // . Traverse the list and process referents as appropriate.

   886   {

   887     RefProcParPhaseTimeTracker tt(ReferenceProcessorPhaseTimes::RefPhase3, phase_times);

   888 

   889     if (mt_processing) {

   890       RefProcPhase3Task phase3(*this, refs_lists, clear_referent, true /*marks_oops_alive*/, phase_times);

   891       task_executor->execute(phase3);

   892     } else {

   893       for (uint i = 0; i < _max_num_q; i++) {

   894         process_phase3(refs_lists[i], clear_referent,

   895                        is_alive, keep_alive, complete_gc);

   896       }

   897     }

   898   }

   899 }

   900 

   901 inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt) {

   902   uint id = 0;

   903   // Determine the queue index to use for this object.

   904   if (_discovery_is_mt) {

   905     // During a multi-threaded discovery phase,

   906     // each thread saves to its "own" list.

   907     Thread* thr = Thread::current();

   908     id = thr->as_Worker_thread()->id();

   909   } else {

   910     // single-threaded discovery, we save in round-robin

   911     // fashion to each of the lists.

   912     if (_processing_is_mt) {

   913       id = next_id();

   914     }

   915   }

   916   assert(id < _max_num_q, "Id is out-of-bounds id %u and max id %u)", id, _max_num_q);

   917 

   918   // Get the discovered queue to which we will add

   919   DiscoveredList* list = NULL;

   920   switch (rt) {

   921     case REF_OTHER:

   922       // Unknown reference type, no special treatment

   923       break;

   924     case REF_SOFT:

   925       list = &_discoveredSoftRefs[id];

   926       break;

   927     case REF_WEAK:

   928       list = &_discoveredWeakRefs[id];

   929       break;

   930     case REF_FINAL:

   931       list = &_discoveredFinalRefs[id];

   932       break;

   933     case REF_PHANTOM:

   934       list = &_discoveredPhantomRefs[id];

   935       break;

   936     case REF_NONE:

   937       // we should not reach here if we are an InstanceRefKlass

   938     default:

   939       ShouldNotReachHere();

   940   }

   941   log_develop_trace(gc, ref)("Thread %d gets list " INTPTR_FORMAT, id, p2i(list));

   942   return list;

   943 }

   944 

   945 inline void

   946 ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,

   947                                               oop             obj,

   948                                               HeapWord*       discovered_addr) {

   949   assert(_discovery_is_mt, "!_discovery_is_mt should have been handled by caller");

   950   // First we must make sure this object is only enqueued once. CAS in a non null

   951   // discovered_addr.

   952   oop current_head = refs_list.head();

   953   // The last ref must have its discovered field pointing to itself.

   954   oop next_discovered = (current_head != NULL) ? current_head : obj;

   955 

   956   oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,

   957                                                     NULL);

   958   if (retest == NULL) {

   959     // This thread just won the right to enqueue the object.

   960     // We have separate lists for enqueueing, so no synchronization

   961     // is necessary.

   962     refs_list.set_head(obj);

   963     refs_list.inc_length(1);

   964 

   965     log_develop_trace(gc, ref)("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",

   966                                p2i(obj), obj->klass()->internal_name());

   967   } else {

   968     // If retest was non NULL, another thread beat us to it:

   969     // The reference has already been discovered...

   970     log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)",

   971                                p2i(obj), obj->klass()->internal_name());

   972     }

   973   }

   974 

   975 #ifndef PRODUCT

   976 // Non-atomic (i.e. concurrent) discovery might allow us

   977 // to observe j.l.References with NULL referents, being those

   978 // cleared concurrently by mutators during (or after) discovery.

   979 void ReferenceProcessor::verify_referent(oop obj) {

   980   bool da = discovery_is_atomic();

   981   oop referent = java_lang_ref_Reference::referent(obj);

   982   assert(da ? oopDesc::is_oop(referent) : oopDesc::is_oop_or_null(referent),

   983          "Bad referent " INTPTR_FORMAT " found in Reference "

   984          INTPTR_FORMAT " during %satomic discovery ",

   985          p2i(referent), p2i(obj), da ? "" : "non-");

   986 }

   987 #endif

   988 

   989 // We mention two of several possible choices here:

   990 // #0: if the reference object is not in the "originating generation"

   991 //     (or part of the heap being collected, indicated by our "span"

   992 //     we don't treat it specially (i.e. we scan it as we would

   993 //     a normal oop, treating its references as strong references).

   994 //     This means that references can't be discovered unless their

   995 //     referent is also in the same span. This is the simplest,

   996 //     most "local" and most conservative approach, albeit one

   997 //     that may cause weak references to be enqueued least promptly.

   998 //     We call this choice the "ReferenceBasedDiscovery" policy.

   999 // #1: the reference object may be in any generation (span), but if

  1000 //     the referent is in the generation (span) being currently collected

  1001 //     then we can discover the reference object, provided

  1002 //     the object has not already been discovered by

  1003 //     a different concurrently running collector (as may be the

  1004 //     case, for instance, if the reference object is in CMS and

  1005 //     the referent in DefNewGeneration), and provided the processing

  1006 //     of this reference object by the current collector will

  1007 //     appear atomic to every other collector in the system.

  1008 //     (Thus, for instance, a concurrent collector may not

  1009 //     discover references in other generations even if the

  1010 //     referent is in its own generation). This policy may,

  1011 //     in certain cases, enqueue references somewhat sooner than

  1012 //     might Policy #0 above, but at marginally increased cost

  1013 //     and complexity in processing these references.

  1014 //     We call this choice the "RefeferentBasedDiscovery" policy.

  1015 bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {

  1016   // Make sure we are discovering refs (rather than processing discovered refs).

  1017   if (!_discovering_refs || !RegisterReferences) {

  1018     return false;

  1019   }

  1020   // We only discover active references.

  1021   oop next = java_lang_ref_Reference::next(obj);

  1022   if (next != NULL) {   // Ref is no longer active

  1023     return false;

  1024   }

  1025 

  1026   HeapWord* obj_addr = (HeapWord*)obj;

  1027   if (RefDiscoveryPolicy == ReferenceBasedDiscovery &&

  1028       !_span.contains(obj_addr)) {

  1029     // Reference is not in the originating generation;

  1030     // don't treat it specially (i.e. we want to scan it as a normal

  1031     // object with strong references).

  1032     return false;

  1033   }

  1034 

  1035   // We only discover references whose referents are not (yet)

  1036   // known to be strongly reachable.

  1037   if (is_alive_non_header() != NULL) {

  1038     verify_referent(obj);

  1039     if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {

  1040       return false;  // referent is reachable

  1041     }

  1042   }

  1043   if (rt == REF_SOFT) {

  1044     // For soft refs we can decide now if these are not

  1045     // current candidates for clearing, in which case we

  1046     // can mark through them now, rather than delaying that

  1047     // to the reference-processing phase. Since all current

  1048     // time-stamp policies advance the soft-ref clock only

  1049     // at a full collection cycle, this is always currently

  1050     // accurate.

  1051     if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) {

  1052       return false;

  1053     }

  1054   }

  1055 

  1056   ResourceMark rm;      // Needed for tracing.

  1057 

  1058   HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);

  1059   const oop  discovered = java_lang_ref_Reference::discovered(obj);

  1060   assert(oopDesc::is_oop_or_null(discovered), "Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered));

  1061   if (discovered != NULL) {

  1062     // The reference has already been discovered...

  1063     log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)",

  1064                                p2i(obj), obj->klass()->internal_name());

  1065     if (RefDiscoveryPolicy == ReferentBasedDiscovery) {

  1066       // assumes that an object is not processed twice;

  1067       // if it's been already discovered it must be on another

  1068       // generation's discovered list; so we won't discover it.

  1069       return false;

  1070     } else {

  1071       assert(RefDiscoveryPolicy == ReferenceBasedDiscovery,

  1072              "Unrecognized policy");

  1073       // Check assumption that an object is not potentially

  1074       // discovered twice except by concurrent collectors that potentially

  1075       // trace the same Reference object twice.

  1076       assert(UseConcMarkSweepGC || UseG1GC,

  1077              "Only possible with a concurrent marking collector");

  1078       return true;

  1079     }

  1080   }

  1081 

  1082   if (RefDiscoveryPolicy == ReferentBasedDiscovery) {

  1083     verify_referent(obj);

  1084     // Discover if and only if EITHER:

  1085     // .. reference is in our span, OR

  1086     // .. we are an atomic collector and referent is in our span

  1087     if (_span.contains(obj_addr) ||

  1088         (discovery_is_atomic() &&

  1089          _span.contains(java_lang_ref_Reference::referent(obj)))) {

  1090       // should_enqueue = true;

  1091     } else {

  1092       return false;

  1093     }

  1094   } else {

  1095     assert(RefDiscoveryPolicy == ReferenceBasedDiscovery &&

  1096            _span.contains(obj_addr), "code inconsistency");

  1097   }

  1098 

  1099   // Get the right type of discovered queue head.

  1100   DiscoveredList* list = get_discovered_list(rt);

  1101   if (list == NULL) {

  1102     return false;   // nothing special needs to be done

  1103   }

  1104 

  1105   if (_discovery_is_mt) {

  1106     add_to_discovered_list_mt(*list, obj, discovered_addr);

  1107   } else {

  1108     // We do a raw store here: the field will be visited later when processing

  1109     // the discovered references.

  1110     oop current_head = list->head();

  1111     // The last ref must have its discovered field pointing to itself.

  1112     oop next_discovered = (current_head != NULL) ? current_head : obj;

  1113 

  1114     assert(discovered == NULL, "control point invariant");

  1115     oop_store_raw(discovered_addr, next_discovered);

  1116     list->set_head(obj);

  1117     list->inc_length(1);

  1118 

  1119     log_develop_trace(gc, ref)("Discovered reference (" INTPTR_FORMAT ": %s)", p2i(obj), obj->klass()->internal_name());

  1120   }

  1121   assert(oopDesc::is_oop(obj), "Discovered a bad reference");

  1122   verify_referent(obj);

  1123   return true;

  1124 }

  1125 

  1126 bool ReferenceProcessor::has_discovered_references() {

  1127   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {

  1128     if (!_discovered_refs[i].is_empty()) {

  1129       return true;

  1130     }

  1131   }

  1132   return false;

  1133 }

  1134