1 /*
   2  * Copyright (c) 2001, 2016, 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/heapMonitoring.hpp"
  39 #include "runtime/java.hpp"
  40 #include "runtime/jniHandles.hpp"
  41 
  42 ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
  43 ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;
  44 jlong            ReferenceProcessor::_soft_ref_timestamp_clock = 0;
  45 
  46 void referenceProcessor_init() {
  47   ReferenceProcessor::init_statics();
  48 }
  49 
  50 void ReferenceProcessor::init_statics() {
  51   // We need a monotonically non-decreasing time in ms but
  52   // os::javaTimeMillis() does not guarantee monotonicity.
  53   jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
  54 
  55   // Initialize the soft ref timestamp clock.
  56   _soft_ref_timestamp_clock = now;
  57   // Also update the soft ref clock in j.l.r.SoftReference
  58   java_lang_ref_SoftReference::set_clock(_soft_ref_timestamp_clock);
  59 
  60   _always_clear_soft_ref_policy = new AlwaysClearPolicy();
  61   if (is_server_compilation_mode_vm()) {
  62     _default_soft_ref_policy = new LRUMaxHeapPolicy();
  63   } else {
  64     _default_soft_ref_policy = new LRUCurrentHeapPolicy();
  65   }
  66   if (_always_clear_soft_ref_policy == NULL || _default_soft_ref_policy == NULL) {
  67     vm_exit_during_initialization("Could not allocate reference policy object");
  68   }
  69   guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery ||
  70             RefDiscoveryPolicy == ReferentBasedDiscovery,
  71             "Unrecognized RefDiscoveryPolicy");
  72 }
  73 
  74 void ReferenceProcessor::enable_discovery(bool check_no_refs) {
  75 #ifdef ASSERT
  76   // Verify that we're not currently discovering refs
  77   assert(!_discovering_refs, "nested call?");
  78 
  79   if (check_no_refs) {
  80     // Verify that the discovered lists are empty
  81     verify_no_references_recorded();
  82   }
  83 #endif // ASSERT
  84 
  85   // Someone could have modified the value of the static
  86   // field in the j.l.r.SoftReference class that holds the
  87   // soft reference timestamp clock using reflection or
  88   // Unsafe between GCs. Unconditionally update the static
  89   // field in ReferenceProcessor here so that we use the new
  90   // value during reference discovery.
  91 
  92   _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
  93   _discovering_refs = true;
  94 }
  95 
  96 ReferenceProcessor::ReferenceProcessor(MemRegion span,
  97                                        bool      mt_processing,
  98                                        uint      mt_processing_degree,
  99                                        bool      mt_discovery,
 100                                        uint      mt_discovery_degree,
 101                                        bool      atomic_discovery,
 102                                        BoolObjectClosure* is_alive_non_header)  :
 103   _discovering_refs(false),
 104   _enqueuing_is_done(false),
 105   _is_alive_non_header(is_alive_non_header),
 106   _processing_is_mt(mt_processing),
 107   _next_id(0)
 108 {
 109   _span = span;
 110   _discovery_is_atomic = atomic_discovery;
 111   _discovery_is_mt     = mt_discovery;
 112   _num_q               = MAX2(1U, mt_processing_degree);
 113   _max_num_q           = MAX2(_num_q, mt_discovery_degree);
 114   _discovered_refs     = NEW_C_HEAP_ARRAY(DiscoveredList,
 115             _max_num_q * number_of_subclasses_of_ref(), mtGC);
 116 
 117   if (_discovered_refs == NULL) {
 118     vm_exit_during_initialization("Could not allocated RefProc Array");
 119   }
 120   _discoveredSoftRefs    = &_discovered_refs[0];
 121   _discoveredWeakRefs    = &_discoveredSoftRefs[_max_num_q];
 122   _discoveredFinalRefs   = &_discoveredWeakRefs[_max_num_q];
 123   _discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];
 124 
 125   // Initialize all entries to NULL
 126   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 127     _discovered_refs[i].set_head(NULL);
 128     _discovered_refs[i].set_length(0);
 129   }
 130 
 131   setup_policy(false /* default soft ref policy */);
 132 }
 133 
 134 #ifndef PRODUCT
 135 void ReferenceProcessor::verify_no_references_recorded() {
 136   guarantee(!_discovering_refs, "Discovering refs?");
 137   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 138     guarantee(_discovered_refs[i].is_empty(),
 139               "Found non-empty discovered list at %u", i);
 140   }
 141 }
 142 #endif
 143 
 144 void ReferenceProcessor::weak_oops_do(OopClosure* f) {
 145   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 146     if (UseCompressedOops) {
 147       f->do_oop((narrowOop*)_discovered_refs[i].adr_head());
 148     } else {
 149       f->do_oop((oop*)_discovered_refs[i].adr_head());
 150     }
 151   }
 152 }
 153 
 154 void ReferenceProcessor::update_soft_ref_master_clock() {
 155   // Update (advance) the soft ref master clock field. This must be done
 156   // after processing the soft ref list.
 157 
 158   // We need a monotonically non-decreasing time in ms but
 159   // os::javaTimeMillis() does not guarantee monotonicity.
 160   jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 161   jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
 162   assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
 163 
 164   NOT_PRODUCT(
 165   if (now < _soft_ref_timestamp_clock) {
 166     log_warning(gc)("time warp: " JLONG_FORMAT " to " JLONG_FORMAT,
 167                     _soft_ref_timestamp_clock, now);
 168   }
 169   )
 170   // The values of now and _soft_ref_timestamp_clock are set using
 171   // javaTimeNanos(), which is guaranteed to be monotonically
 172   // non-decreasing provided the underlying platform provides such
 173   // a time source (and it is bug free).
 174   // In product mode, however, protect ourselves from non-monotonicity.
 175   if (now > _soft_ref_timestamp_clock) {
 176     _soft_ref_timestamp_clock = now;
 177     java_lang_ref_SoftReference::set_clock(now);
 178   }
 179   // Else leave clock stalled at its old value until time progresses
 180   // past clock value.
 181 }
 182 
 183 size_t ReferenceProcessor::total_count(DiscoveredList lists[]) {
 184   size_t total = 0;
 185   for (uint i = 0; i < _max_num_q; ++i) {
 186     total += lists[i].length();
 187   }
 188   return total;
 189 }
 190 
 191 ReferenceProcessorStats ReferenceProcessor::process_discovered_references(
 192   BoolObjectClosure*           is_alive,
 193   OopClosure*                  keep_alive,
 194   VoidClosure*                 complete_gc,
 195   AbstractRefProcTaskExecutor* task_executor,
 196   GCTimer*                     gc_timer) {
 197 
 198   assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
 199   // Stop treating discovered references specially.
 200   disable_discovery();
 201 
 202   // If discovery was concurrent, someone could have modified
 203   // the value of the static field in the j.l.r.SoftReference
 204   // class that holds the soft reference timestamp clock using
 205   // reflection or Unsafe between when discovery was enabled and
 206   // now. Unconditionally update the static field in ReferenceProcessor
 207   // here so that we use the new value during processing of the
 208   // discovered soft refs.
 209 
 210   _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
 211 
 212   ReferenceProcessorStats stats(
 213       total_count(_discoveredSoftRefs),
 214       total_count(_discoveredWeakRefs),
 215       total_count(_discoveredFinalRefs),
 216       total_count(_discoveredPhantomRefs));
 217 
 218   // Soft references
 219   {
 220     GCTraceTime(Debug, gc, ref) tt("SoftReference", gc_timer);
 221     process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
 222                                is_alive, keep_alive, complete_gc, task_executor);
 223   }
 224 
 225   update_soft_ref_master_clock();
 226 
 227   // Weak references
 228   {
 229     GCTraceTime(Debug, gc, ref) tt("WeakReference", gc_timer);
 230     process_discovered_reflist(_discoveredWeakRefs, NULL, true,
 231                                is_alive, keep_alive, complete_gc, task_executor);
 232   }
 233 
 234   // Final references
 235   {
 236     GCTraceTime(Debug, gc, ref) tt("FinalReference", gc_timer);
 237     process_discovered_reflist(_discoveredFinalRefs, NULL, false,
 238                                is_alive, keep_alive, complete_gc, task_executor);
 239   }
 240 
 241   // Phantom references
 242   {
 243     GCTraceTime(Debug, gc, ref) tt("PhantomReference", gc_timer);
 244     process_discovered_reflist(_discoveredPhantomRefs, NULL, true,
 245                                is_alive, keep_alive, complete_gc, task_executor);
 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", 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   size_t handled;
 262   {
 263     GCTraceTime(Debug, gc, ref) tt("Heap Monitoring Weak Reference", gc_timer);
 264     handled = process_phaseHeapSampling(is_alive, keep_alive, complete_gc, task_executor);
 265   }
 266 
 267   log_debug(gc, ref)("Ref Counts: Soft: " SIZE_FORMAT " Weak: " SIZE_FORMAT " Final: " SIZE_FORMAT " Phantom: " SIZE_FORMAT,
 268                      stats.soft_count(), stats.weak_count(), stats.final_count(), stats.phantom_count());
 269   log_develop_trace(gc, ref)("JNI Weak Reference count: " SIZE_FORMAT, count_jni_refs());
 270   log_develop_trace(gc, ref)("Heap Sampler Weak Reference handled: " SIZE_FORMAT, handled);
 271 
 272   return stats;
 273 }
 274 
 275 #ifndef PRODUCT
 276 // Calculate the number of jni handles.
 277 size_t ReferenceProcessor::count_jni_refs() {
 278   class CountHandleClosure: public OopClosure {
 279   private:
 280     size_t _count;
 281   public:
 282     CountHandleClosure(): _count(0) {}
 283     void do_oop(oop* unused)       { _count++; }
 284     void do_oop(narrowOop* unused) { ShouldNotReachHere(); }
 285     size_t count() { return _count; }
 286   };
 287   CountHandleClosure global_handle_count;
 288   JNIHandles::weak_oops_do(&global_handle_count);
 289   return global_handle_count.count();
 290 }
 291 #endif
 292 
 293 void ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive,
 294                                           OopClosure*        keep_alive,
 295                                           VoidClosure*       complete_gc) {
 296   JNIHandles::weak_oops_do(is_alive, keep_alive);
 297   complete_gc->do_void();
 298 }
 299 
 300 size_t ReferenceProcessor::process_phaseHeapSampling(
 301     BoolObjectClosure*           is_alive,
 302     OopClosure*                  keep_alive,
 303     VoidClosure*                 complete_gc,
 304     AbstractRefProcTaskExecutor* task_executor) {
 305   size_t count = 0;
 306   if (HeapMonitoring::enabled()) {
 307     if (task_executor != NULL) {
 308       task_executor->set_single_threaded_mode();
 309     }
 310     count = HeapMonitoring::weak_oops_do(is_alive, keep_alive);
 311     complete_gc->do_void();
 312   }
 313   return count;
 314 }
 315 
 316 void ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor) {
 317   // Enqueue references that are not made active again, and
 318   // clear the decks for the next collection (cycle).
 319   enqueue_discovered_reflists(task_executor);
 320 
 321   // Stop treating discovered references specially.
 322   disable_discovery();
 323 }
 324 
 325 void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list) {
 326   // Given a list of refs linked through the "discovered" field
 327   // (java.lang.ref.Reference.discovered), self-loop their "next" field
 328   // thus distinguishing them from active References, then
 329   // prepend them to the pending list.
 330   //
 331   // The Java threads will see the Reference objects linked together through
 332   // the discovered field. Instead of trying to do the write barrier updates
 333   // in all places in the reference processor where we manipulate the discovered
 334   // field we make sure to do the barrier here where we anyway iterate through
 335   // all linked Reference objects. Note that it is important to not dirty any
 336   // cards during reference processing since this will cause card table
 337   // verification to fail for G1.
 338   log_develop_trace(gc, ref)("ReferenceProcessor::enqueue_discovered_reflist list " INTPTR_FORMAT, p2i(&refs_list));
 339 
 340   oop obj = NULL;
 341   oop next_d = refs_list.head();
 342   // Walk down the list, self-looping the next field
 343   // so that the References are not considered active.
 344   while (obj != next_d) {
 345     obj = next_d;
 346     assert(obj->is_instance(), "should be an instance object");
 347     assert(InstanceKlass::cast(obj->klass())->is_reference_instance_klass(), "should be reference object");
 348     next_d = java_lang_ref_Reference::discovered(obj);
 349     log_develop_trace(gc, ref)("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, p2i(obj), p2i(next_d));
 350     assert(java_lang_ref_Reference::next(obj) == NULL,
 351            "Reference not active; should not be discovered");
 352     // Self-loop next, so as to make Ref not active.
 353     java_lang_ref_Reference::set_next_raw(obj, obj);
 354     if (next_d != obj) {
 355       oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d);
 356     } else {
 357       // This is the last object.
 358       // Swap refs_list into pending list and set obj's
 359       // discovered to what we read from the pending list.
 360       oop old = Universe::swap_reference_pending_list(refs_list.head());
 361       java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
 362       oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
 363     }
 364   }
 365 }
 366 
 367 // Parallel enqueue task
 368 class RefProcEnqueueTask: public AbstractRefProcTaskExecutor::EnqueueTask {
 369 public:
 370   RefProcEnqueueTask(ReferenceProcessor& ref_processor,
 371                      DiscoveredList      discovered_refs[],
 372                      int                 n_queues)
 373     : EnqueueTask(ref_processor, discovered_refs, n_queues)
 374   { }
 375 
 376   virtual void work(unsigned int work_id) {
 377     assert(work_id < (unsigned int)_ref_processor.max_num_q(), "Index out-of-bounds");
 378     // Simplest first cut: static partitioning.
 379     int index = work_id;
 380     // The increment on "index" must correspond to the maximum number of queues
 381     // (n_queues) with which that ReferenceProcessor was created.  That
 382     // is because of the "clever" way the discovered references lists were
 383     // allocated and are indexed into.
 384     assert(_n_queues == (int) _ref_processor.max_num_q(), "Different number not expected");
 385     for (int j = 0;
 386          j < ReferenceProcessor::number_of_subclasses_of_ref();
 387          j++, index += _n_queues) {
 388       _ref_processor.enqueue_discovered_reflist(_refs_lists[index]);
 389       _refs_lists[index].set_head(NULL);
 390       _refs_lists[index].set_length(0);
 391     }
 392   }
 393 };
 394 
 395 // Enqueue references that are not made active again
 396 void ReferenceProcessor::enqueue_discovered_reflists(AbstractRefProcTaskExecutor* task_executor) {
 397   if (_processing_is_mt && task_executor != NULL) {
 398     // Parallel code
 399     RefProcEnqueueTask tsk(*this, _discovered_refs, _max_num_q);
 400     task_executor->execute(tsk);
 401   } else {
 402     // Serial code: call the parent class's implementation
 403     for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 404       enqueue_discovered_reflist(_discovered_refs[i]);
 405       _discovered_refs[i].set_head(NULL);
 406       _discovered_refs[i].set_length(0);
 407     }
 408   }
 409 }
 410 
 411 void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
 412   _discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);
 413   oop discovered = java_lang_ref_Reference::discovered(_ref);
 414   assert(_discovered_addr && discovered->is_oop_or_null(),
 415          "Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered));
 416   _next = discovered;
 417   _referent_addr = java_lang_ref_Reference::referent_addr(_ref);
 418   _referent = java_lang_ref_Reference::referent(_ref);
 419   assert(Universe::heap()->is_in_reserved_or_null(_referent),
 420          "Wrong oop found in java.lang.Reference object");
 421   assert(allow_null_referent ?
 422              _referent->is_oop_or_null()
 423            : _referent->is_oop(),
 424          "Expected an oop%s for referent field at " PTR_FORMAT,
 425          (allow_null_referent ? " or NULL" : ""),
 426          p2i(_referent));
 427 }
 428 
 429 void DiscoveredListIterator::remove() {
 430   assert(_ref->is_oop(), "Dropping a bad reference");
 431   oop_store_raw(_discovered_addr, NULL);
 432 
 433   // First _prev_next ref actually points into DiscoveredList (gross).
 434   oop new_next;
 435   if (_next == _ref) {
 436     // At the end of the list, we should make _prev point to itself.
 437     // If _ref is the first ref, then _prev_next will be in the DiscoveredList,
 438     // and _prev will be NULL.
 439     new_next = _prev;
 440   } else {
 441     new_next = _next;
 442   }
 443   // Remove Reference object from discovered list. Note that G1 does not need a
 444   // pre-barrier here because we know the Reference has already been found/marked,
 445   // that's how it ended up in the discovered list in the first place.
 446   oop_store_raw(_prev_next, new_next);
 447   NOT_PRODUCT(_removed++);
 448   _refs_list.dec_length(1);
 449 }
 450 
 451 void DiscoveredListIterator::clear_referent() {
 452   oop_store_raw(_referent_addr, NULL);
 453 }
 454 
 455 // NOTE: process_phase*() are largely similar, and at a high level
 456 // merely iterate over the extant list applying a predicate to
 457 // each of its elements and possibly removing that element from the
 458 // list and applying some further closures to that element.
 459 // We should consider the possibility of replacing these
 460 // process_phase*() methods by abstracting them into
 461 // a single general iterator invocation that receives appropriate
 462 // closures that accomplish this work.
 463 
 464 // (SoftReferences only) Traverse the list and remove any SoftReferences whose
 465 // referents are not alive, but that should be kept alive for policy reasons.
 466 // Keep alive the transitive closure of all such referents.
 467 void
 468 ReferenceProcessor::process_phase1(DiscoveredList&    refs_list,
 469                                    ReferencePolicy*   policy,
 470                                    BoolObjectClosure* is_alive,
 471                                    OopClosure*        keep_alive,
 472                                    VoidClosure*       complete_gc) {
 473   assert(policy != NULL, "Must have a non-NULL policy");
 474   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 475   // Decide which softly reachable refs should be kept alive.
 476   while (iter.has_next()) {
 477     iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
 478     bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
 479     if (referent_is_dead &&
 480         !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
 481       log_develop_trace(gc, ref)("Dropping reference (" INTPTR_FORMAT ": %s"  ") by policy",
 482                                  p2i(iter.obj()), iter.obj()->klass()->internal_name());
 483       // Remove Reference object from list
 484       iter.remove();
 485       // keep the referent around
 486       iter.make_referent_alive();
 487       iter.move_to_next();
 488     } else {
 489       iter.next();
 490     }
 491   }
 492   // Close the reachable set
 493   complete_gc->do_void();
 494   log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " dead Refs out of " SIZE_FORMAT " discovered Refs by policy, from list " INTPTR_FORMAT,
 495                              iter.removed(), iter.processed(), p2i(&refs_list));
 496     }
 497 
 498 // Traverse the list and remove any Refs that are not active, or
 499 // whose referents are either alive or NULL.
 500 void
 501 ReferenceProcessor::pp2_work(DiscoveredList&    refs_list,
 502                              BoolObjectClosure* is_alive,
 503                              OopClosure*        keep_alive) {
 504   assert(discovery_is_atomic(), "Error");
 505   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 506   while (iter.has_next()) {
 507     iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
 508     DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
 509     assert(next == NULL, "Should not discover inactive Reference");
 510     if (iter.is_referent_alive()) {
 511       log_develop_trace(gc, ref)("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)",
 512                                  p2i(iter.obj()), iter.obj()->klass()->internal_name());
 513       // The referent is reachable after all.
 514       // Remove Reference object from list.
 515       iter.remove();
 516       // Update the referent pointer as necessary: Note that this
 517       // should not entail any recursive marking because the
 518       // referent must already have been traversed.
 519       iter.make_referent_alive();
 520       iter.move_to_next();
 521     } else {
 522       iter.next();
 523     }
 524   }
 525   NOT_PRODUCT(
 526     if (iter.processed() > 0) {
 527       log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT
 528         " Refs in discovered list " INTPTR_FORMAT,
 529         iter.removed(), iter.processed(), p2i(&refs_list));
 530     }
 531   )
 532 }
 533 
 534 void
 535 ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList&    refs_list,
 536                                                   BoolObjectClosure* is_alive,
 537                                                   OopClosure*        keep_alive,
 538                                                   VoidClosure*       complete_gc) {
 539   assert(!discovery_is_atomic(), "Error");
 540   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 541   while (iter.has_next()) {
 542     iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
 543     HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
 544     oop next = java_lang_ref_Reference::next(iter.obj());
 545     if ((iter.referent() == NULL || iter.is_referent_alive() ||
 546          next != NULL)) {
 547       assert(next->is_oop_or_null(), "Expected an oop or NULL for next field at " PTR_FORMAT, p2i(next));
 548       // Remove Reference object from list
 549       iter.remove();
 550       // Trace the cohorts
 551       iter.make_referent_alive();
 552       if (UseCompressedOops) {
 553         keep_alive->do_oop((narrowOop*)next_addr);
 554       } else {
 555         keep_alive->do_oop((oop*)next_addr);
 556       }
 557       iter.move_to_next();
 558     } else {
 559       iter.next();
 560     }
 561   }
 562   // Now close the newly reachable set
 563   complete_gc->do_void();
 564   NOT_PRODUCT(
 565     if (iter.processed() > 0) {
 566       log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT
 567         " Refs in discovered list " INTPTR_FORMAT,
 568         iter.removed(), iter.processed(), p2i(&refs_list));
 569     }
 570   )
 571 }
 572 
 573 // Traverse the list and process the referents, by either
 574 // clearing them or keeping them (and their reachable
 575 // closure) alive.
 576 void
 577 ReferenceProcessor::process_phase3(DiscoveredList&    refs_list,
 578                                    bool               clear_referent,
 579                                    BoolObjectClosure* is_alive,
 580                                    OopClosure*        keep_alive,
 581                                    VoidClosure*       complete_gc) {
 582   ResourceMark rm;
 583   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
 584   while (iter.has_next()) {
 585     iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
 586     if (clear_referent) {
 587       // NULL out referent pointer
 588       iter.clear_referent();
 589     } else {
 590       // keep the referent around
 591       iter.make_referent_alive();
 592     }
 593     log_develop_trace(gc, ref)("Adding %sreference (" INTPTR_FORMAT ": %s) as pending",
 594                                clear_referent ? "cleared " : "", p2i(iter.obj()), iter.obj()->klass()->internal_name());
 595     assert(iter.obj()->is_oop(UseConcMarkSweepGC), "Adding a bad reference");
 596     iter.next();
 597   }
 598   // Close the reachable set
 599   complete_gc->do_void();
 600 }
 601 
 602 void
 603 ReferenceProcessor::clear_discovered_references(DiscoveredList& refs_list) {
 604   oop obj = NULL;
 605   oop next = refs_list.head();
 606   while (next != obj) {
 607     obj = next;
 608     next = java_lang_ref_Reference::discovered(obj);
 609     java_lang_ref_Reference::set_discovered_raw(obj, NULL);
 610   }
 611   refs_list.set_head(NULL);
 612   refs_list.set_length(0);
 613 }
 614 
 615 void ReferenceProcessor::abandon_partial_discovery() {
 616   // loop over the lists
 617   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 618     if ((i % _max_num_q) == 0) {
 619       log_develop_trace(gc, ref)("Abandoning %s discovered list", list_name(i));
 620     }
 621     clear_discovered_references(_discovered_refs[i]);
 622   }
 623 }
 624 
 625 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
 626 public:
 627   RefProcPhase1Task(ReferenceProcessor& ref_processor,
 628                     DiscoveredList      refs_lists[],
 629                     ReferencePolicy*    policy,
 630                     bool                marks_oops_alive)
 631     : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
 632       _policy(policy)
 633   { }
 634   virtual void work(unsigned int i, BoolObjectClosure& is_alive,
 635                     OopClosure& keep_alive,
 636                     VoidClosure& complete_gc)
 637   {
 638     _ref_processor.process_phase1(_refs_lists[i], _policy,
 639                                   &is_alive, &keep_alive, &complete_gc);
 640   }
 641 private:
 642   ReferencePolicy* _policy;
 643 };
 644 
 645 class RefProcPhase2Task: public AbstractRefProcTaskExecutor::ProcessTask {
 646 public:
 647   RefProcPhase2Task(ReferenceProcessor& ref_processor,
 648                     DiscoveredList      refs_lists[],
 649                     bool                marks_oops_alive)
 650     : ProcessTask(ref_processor, refs_lists, marks_oops_alive)
 651   { }
 652   virtual void work(unsigned int i, BoolObjectClosure& is_alive,
 653                     OopClosure& keep_alive,
 654                     VoidClosure& complete_gc)
 655   {
 656     _ref_processor.process_phase2(_refs_lists[i],
 657                                   &is_alive, &keep_alive, &complete_gc);
 658   }
 659 };
 660 
 661 class RefProcPhase3Task: public AbstractRefProcTaskExecutor::ProcessTask {
 662 public:
 663   RefProcPhase3Task(ReferenceProcessor& ref_processor,
 664                     DiscoveredList      refs_lists[],
 665                     bool                clear_referent,
 666                     bool                marks_oops_alive)
 667     : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
 668       _clear_referent(clear_referent)
 669   { }
 670   virtual void work(unsigned int i, BoolObjectClosure& is_alive,
 671                     OopClosure& keep_alive,
 672                     VoidClosure& complete_gc)
 673   {
 674     _ref_processor.process_phase3(_refs_lists[i], _clear_referent,
 675                                   &is_alive, &keep_alive, &complete_gc);
 676   }
 677 private:
 678   bool _clear_referent;
 679 };
 680 
 681 #ifndef PRODUCT
 682 void ReferenceProcessor::log_reflist_counts(DiscoveredList ref_lists[], uint active_length, size_t total_refs) {
 683   if (!log_is_enabled(Trace, gc, ref)) {
 684     return;
 685   }
 686 
 687   stringStream st;
 688   for (uint i = 0; i < active_length; ++i) {
 689     st.print(SIZE_FORMAT " ", ref_lists[i].length());
 690   }
 691   log_develop_trace(gc, ref)("%s= " SIZE_FORMAT, st.as_string(), total_refs);
 692 #ifdef ASSERT
 693   for (uint i = active_length; i < _max_num_q; i++) {
 694     assert(ref_lists[i].length() == 0, SIZE_FORMAT " unexpected References in %u",
 695            ref_lists[i].length(), i);
 696   }
 697 #endif
 698 }
 699 #endif
 700 
 701 void ReferenceProcessor::set_active_mt_degree(uint v) {
 702   _num_q = v;
 703   _next_id = 0;
 704 }
 705 
 706 // Balances reference queues.
 707 // Move entries from all queues[0, 1, ..., _max_num_q-1] to
 708 // queues[0, 1, ..., _num_q-1] because only the first _num_q
 709 // corresponding to the active workers will be processed.
 710 void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])
 711 {
 712   // calculate total length
 713   size_t total_refs = 0;
 714   log_develop_trace(gc, ref)("Balance ref_lists ");
 715 
 716   for (uint i = 0; i < _max_num_q; ++i) {
 717     total_refs += ref_lists[i].length();
 718   }
 719   log_reflist_counts(ref_lists, _max_num_q, total_refs);
 720   size_t avg_refs = total_refs / _num_q + 1;
 721   uint to_idx = 0;
 722   for (uint from_idx = 0; from_idx < _max_num_q; from_idx++) {
 723     bool move_all = false;
 724     if (from_idx >= _num_q) {
 725       move_all = ref_lists[from_idx].length() > 0;
 726     }
 727     while ((ref_lists[from_idx].length() > avg_refs) ||
 728            move_all) {
 729       assert(to_idx < _num_q, "Sanity Check!");
 730       if (ref_lists[to_idx].length() < avg_refs) {
 731         // move superfluous refs
 732         size_t refs_to_move;
 733         // Move all the Ref's if the from queue will not be processed.
 734         if (move_all) {
 735           refs_to_move = MIN2(ref_lists[from_idx].length(),
 736                               avg_refs - ref_lists[to_idx].length());
 737         } else {
 738           refs_to_move = MIN2(ref_lists[from_idx].length() - avg_refs,
 739                               avg_refs - ref_lists[to_idx].length());
 740         }
 741 
 742         assert(refs_to_move > 0, "otherwise the code below will fail");
 743 
 744         oop move_head = ref_lists[from_idx].head();
 745         oop move_tail = move_head;
 746         oop new_head  = move_head;
 747         // find an element to split the list on
 748         for (size_t j = 0; j < refs_to_move; ++j) {
 749           move_tail = new_head;
 750           new_head = java_lang_ref_Reference::discovered(new_head);
 751         }
 752 
 753         // Add the chain to the to list.
 754         if (ref_lists[to_idx].head() == NULL) {
 755           // to list is empty. Make a loop at the end.
 756           java_lang_ref_Reference::set_discovered_raw(move_tail, move_tail);
 757         } else {
 758           java_lang_ref_Reference::set_discovered_raw(move_tail, ref_lists[to_idx].head());
 759         }
 760         ref_lists[to_idx].set_head(move_head);
 761         ref_lists[to_idx].inc_length(refs_to_move);
 762 
 763         // Remove the chain from the from list.
 764         if (move_tail == new_head) {
 765           // We found the end of the from list.
 766           ref_lists[from_idx].set_head(NULL);
 767         } else {
 768           ref_lists[from_idx].set_head(new_head);
 769         }
 770         ref_lists[from_idx].dec_length(refs_to_move);
 771         if (ref_lists[from_idx].length() == 0) {
 772           break;
 773         }
 774       } else {
 775         to_idx = (to_idx + 1) % _num_q;
 776       }
 777     }
 778   }
 779 #ifdef ASSERT
 780   size_t balanced_total_refs = 0;
 781   for (uint i = 0; i < _num_q; ++i) {
 782     balanced_total_refs += ref_lists[i].length();
 783   }
 784   log_reflist_counts(ref_lists, _num_q, balanced_total_refs);
 785   assert(total_refs == balanced_total_refs, "Balancing was incomplete");
 786 #endif
 787 }
 788 
 789 void ReferenceProcessor::balance_all_queues() {
 790   balance_queues(_discoveredSoftRefs);
 791   balance_queues(_discoveredWeakRefs);
 792   balance_queues(_discoveredFinalRefs);
 793   balance_queues(_discoveredPhantomRefs);
 794 }
 795 
 796 void ReferenceProcessor::process_discovered_reflist(
 797   DiscoveredList               refs_lists[],
 798   ReferencePolicy*             policy,
 799   bool                         clear_referent,
 800   BoolObjectClosure*           is_alive,
 801   OopClosure*                  keep_alive,
 802   VoidClosure*                 complete_gc,
 803   AbstractRefProcTaskExecutor* task_executor)
 804 {
 805   bool mt_processing = task_executor != NULL && _processing_is_mt;
 806   // If discovery used MT and a dynamic number of GC threads, then
 807   // the queues must be balanced for correctness if fewer than the
 808   // maximum number of queues were used.  The number of queue used
 809   // during discovery may be different than the number to be used
 810   // for processing so don't depend of _num_q < _max_num_q as part
 811   // of the test.
 812   bool must_balance = _discovery_is_mt;
 813 
 814   if ((mt_processing && ParallelRefProcBalancingEnabled) ||
 815       must_balance) {
 816     balance_queues(refs_lists);
 817   }
 818 
 819   // Phase 1 (soft refs only):
 820   // . Traverse the list and remove any SoftReferences whose
 821   //   referents are not alive, but that should be kept alive for
 822   //   policy reasons. Keep alive the transitive closure of all
 823   //   such referents.
 824   if (policy != NULL) {
 825     if (mt_processing) {
 826       RefProcPhase1Task phase1(*this, refs_lists, policy, true /*marks_oops_alive*/);
 827       task_executor->execute(phase1);
 828     } else {
 829       for (uint i = 0; i < _max_num_q; i++) {
 830         process_phase1(refs_lists[i], policy,
 831                        is_alive, keep_alive, complete_gc);
 832       }
 833     }
 834   } else { // policy == NULL
 835     assert(refs_lists != _discoveredSoftRefs,
 836            "Policy must be specified for soft references.");
 837   }
 838 
 839   // Phase 2:
 840   // . Traverse the list and remove any refs whose referents are alive.
 841   if (mt_processing) {
 842     RefProcPhase2Task phase2(*this, refs_lists, !discovery_is_atomic() /*marks_oops_alive*/);
 843     task_executor->execute(phase2);
 844   } else {
 845     for (uint i = 0; i < _max_num_q; i++) {
 846       process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);
 847     }
 848   }
 849 
 850   // Phase 3:
 851   // . Traverse the list and process referents as appropriate.
 852   if (mt_processing) {
 853     RefProcPhase3Task phase3(*this, refs_lists, clear_referent, true /*marks_oops_alive*/);
 854     task_executor->execute(phase3);
 855   } else {
 856     for (uint i = 0; i < _max_num_q; i++) {
 857       process_phase3(refs_lists[i], clear_referent,
 858                      is_alive, keep_alive, complete_gc);
 859     }
 860   }
 861 }
 862 
 863 inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt) {
 864   uint id = 0;
 865   // Determine the queue index to use for this object.
 866   if (_discovery_is_mt) {
 867     // During a multi-threaded discovery phase,
 868     // each thread saves to its "own" list.
 869     Thread* thr = Thread::current();
 870     id = thr->as_Worker_thread()->id();
 871   } else {
 872     // single-threaded discovery, we save in round-robin
 873     // fashion to each of the lists.
 874     if (_processing_is_mt) {
 875       id = next_id();
 876     }
 877   }
 878   assert(id < _max_num_q, "Id is out-of-bounds id %u and max id %u)", id, _max_num_q);
 879 
 880   // Get the discovered queue to which we will add
 881   DiscoveredList* list = NULL;
 882   switch (rt) {
 883     case REF_OTHER:
 884       // Unknown reference type, no special treatment
 885       break;
 886     case REF_SOFT:
 887       list = &_discoveredSoftRefs[id];
 888       break;
 889     case REF_WEAK:
 890       list = &_discoveredWeakRefs[id];
 891       break;
 892     case REF_FINAL:
 893       list = &_discoveredFinalRefs[id];
 894       break;
 895     case REF_PHANTOM:
 896       list = &_discoveredPhantomRefs[id];
 897       break;
 898     case REF_NONE:
 899       // we should not reach here if we are an InstanceRefKlass
 900     default:
 901       ShouldNotReachHere();
 902   }
 903   log_develop_trace(gc, ref)("Thread %d gets list " INTPTR_FORMAT, id, p2i(list));
 904   return list;
 905 }
 906 
 907 inline void
 908 ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
 909                                               oop             obj,
 910                                               HeapWord*       discovered_addr) {
 911   assert(_discovery_is_mt, "!_discovery_is_mt should have been handled by caller");
 912   // First we must make sure this object is only enqueued once. CAS in a non null
 913   // discovered_addr.
 914   oop current_head = refs_list.head();
 915   // The last ref must have its discovered field pointing to itself.
 916   oop next_discovered = (current_head != NULL) ? current_head : obj;
 917 
 918   oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
 919                                                     NULL);
 920   if (retest == NULL) {
 921     // This thread just won the right to enqueue the object.
 922     // We have separate lists for enqueueing, so no synchronization
 923     // is necessary.
 924     refs_list.set_head(obj);
 925     refs_list.inc_length(1);
 926 
 927     log_develop_trace(gc, ref)("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
 928                                p2i(obj), obj->klass()->internal_name());
 929   } else {
 930     // If retest was non NULL, another thread beat us to it:
 931     // The reference has already been discovered...
 932     log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)",
 933                                p2i(obj), obj->klass()->internal_name());
 934     }
 935   }
 936 
 937 #ifndef PRODUCT
 938 // Non-atomic (i.e. concurrent) discovery might allow us
 939 // to observe j.l.References with NULL referents, being those
 940 // cleared concurrently by mutators during (or after) discovery.
 941 void ReferenceProcessor::verify_referent(oop obj) {
 942   bool da = discovery_is_atomic();
 943   oop referent = java_lang_ref_Reference::referent(obj);
 944   assert(da ? referent->is_oop() : referent->is_oop_or_null(),
 945          "Bad referent " INTPTR_FORMAT " found in Reference "
 946          INTPTR_FORMAT " during %satomic discovery ",
 947          p2i(referent), p2i(obj), da ? "" : "non-");
 948 }
 949 #endif
 950 
 951 // We mention two of several possible choices here:
 952 // #0: if the reference object is not in the "originating generation"
 953 //     (or part of the heap being collected, indicated by our "span"
 954 //     we don't treat it specially (i.e. we scan it as we would
 955 //     a normal oop, treating its references as strong references).
 956 //     This means that references can't be discovered unless their
 957 //     referent is also in the same span. This is the simplest,
 958 //     most "local" and most conservative approach, albeit one
 959 //     that may cause weak references to be enqueued least promptly.
 960 //     We call this choice the "ReferenceBasedDiscovery" policy.
 961 // #1: the reference object may be in any generation (span), but if
 962 //     the referent is in the generation (span) being currently collected
 963 //     then we can discover the reference object, provided
 964 //     the object has not already been discovered by
 965 //     a different concurrently running collector (as may be the
 966 //     case, for instance, if the reference object is in CMS and
 967 //     the referent in DefNewGeneration), and provided the processing
 968 //     of this reference object by the current collector will
 969 //     appear atomic to every other collector in the system.
 970 //     (Thus, for instance, a concurrent collector may not
 971 //     discover references in other generations even if the
 972 //     referent is in its own generation). This policy may,
 973 //     in certain cases, enqueue references somewhat sooner than
 974 //     might Policy #0 above, but at marginally increased cost
 975 //     and complexity in processing these references.
 976 //     We call this choice the "RefeferentBasedDiscovery" policy.
 977 bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
 978   // Make sure we are discovering refs (rather than processing discovered refs).
 979   if (!_discovering_refs || !RegisterReferences) {
 980     return false;
 981   }
 982   // We only discover active references.
 983   oop next = java_lang_ref_Reference::next(obj);
 984   if (next != NULL) {   // Ref is no longer active
 985     return false;
 986   }
 987 
 988   HeapWord* obj_addr = (HeapWord*)obj;
 989   if (RefDiscoveryPolicy == ReferenceBasedDiscovery &&
 990       !_span.contains(obj_addr)) {
 991     // Reference is not in the originating generation;
 992     // don't treat it specially (i.e. we want to scan it as a normal
 993     // object with strong references).
 994     return false;
 995   }
 996 
 997   // We only discover references whose referents are not (yet)
 998   // known to be strongly reachable.
 999   if (is_alive_non_header() != NULL) {
1000     verify_referent(obj);
1001     if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {
1002       return false;  // referent is reachable
1003     }
1004   }
1005   if (rt == REF_SOFT) {
1006     // For soft refs we can decide now if these are not
1007     // current candidates for clearing, in which case we
1008     // can mark through them now, rather than delaying that
1009     // to the reference-processing phase. Since all current
1010     // time-stamp policies advance the soft-ref clock only
1011     // at a full collection cycle, this is always currently
1012     // accurate.
1013     if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) {
1014       return false;
1015     }
1016   }
1017 
1018   ResourceMark rm;      // Needed for tracing.
1019 
1020   HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
1021   const oop  discovered = java_lang_ref_Reference::discovered(obj);
1022   assert(discovered->is_oop_or_null(), "Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered));
1023   if (discovered != NULL) {
1024     // The reference has already been discovered...
1025     log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)",
1026                                p2i(obj), obj->klass()->internal_name());
1027     if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
1028       // assumes that an object is not processed twice;
1029       // if it's been already discovered it must be on another
1030       // generation's discovered list; so we won't discover it.
1031       return false;
1032     } else {
1033       assert(RefDiscoveryPolicy == ReferenceBasedDiscovery,
1034              "Unrecognized policy");
1035       // Check assumption that an object is not potentially
1036       // discovered twice except by concurrent collectors that potentially
1037       // trace the same Reference object twice.
1038       assert(UseConcMarkSweepGC || UseG1GC,
1039              "Only possible with a concurrent marking collector");
1040       return true;
1041     }
1042   }
1043 
1044   if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
1045     verify_referent(obj);
1046     // Discover if and only if EITHER:
1047     // .. reference is in our span, OR
1048     // .. we are an atomic collector and referent is in our span
1049     if (_span.contains(obj_addr) ||
1050         (discovery_is_atomic() &&
1051          _span.contains(java_lang_ref_Reference::referent(obj)))) {
1052       // should_enqueue = true;
1053     } else {
1054       return false;
1055     }
1056   } else {
1057     assert(RefDiscoveryPolicy == ReferenceBasedDiscovery &&
1058            _span.contains(obj_addr), "code inconsistency");
1059   }
1060 
1061   // Get the right type of discovered queue head.
1062   DiscoveredList* list = get_discovered_list(rt);
1063   if (list == NULL) {
1064     return false;   // nothing special needs to be done
1065   }
1066 
1067   if (_discovery_is_mt) {
1068     add_to_discovered_list_mt(*list, obj, discovered_addr);
1069   } else {
1070     // We do a raw store here: the field will be visited later when processing
1071     // the discovered references.
1072     oop current_head = list->head();
1073     // The last ref must have its discovered field pointing to itself.
1074     oop next_discovered = (current_head != NULL) ? current_head : obj;
1075 
1076     assert(discovered == NULL, "control point invariant");
1077     oop_store_raw(discovered_addr, next_discovered);
1078     list->set_head(obj);
1079     list->inc_length(1);
1080 
1081     log_develop_trace(gc, ref)("Discovered reference (" INTPTR_FORMAT ": %s)", p2i(obj), obj->klass()->internal_name());
1082   }
1083   assert(obj->is_oop(), "Discovered a bad reference");
1084   verify_referent(obj);
1085   return true;
1086 }
1087 
1088 bool ReferenceProcessor::has_discovered_references() {
1089   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
1090     if (!_discovered_refs[i].is_empty()) {
1091       return true;
1092     }
1093   }
1094   return false;
1095 }
1096 
1097 // Preclean the discovered references by removing those
1098 // whose referents are alive, and by marking from those that
1099 // are not active. These lists can be handled here
1100 // in any order and, indeed, concurrently.
1101 void ReferenceProcessor::preclean_discovered_references(
1102   BoolObjectClosure* is_alive,
1103   OopClosure* keep_alive,
1104   VoidClosure* complete_gc,
1105   YieldClosure* yield,
1106   GCTimer* gc_timer) {
1107 
1108   // Soft references
1109   {
1110     GCTraceTime(Debug, gc, ref) tm("Preclean SoftReferences", gc_timer);
1111     for (uint i = 0; i < _max_num_q; i++) {
1112       if (yield->should_return()) {
1113         return;
1114       }
1115       preclean_discovered_reflist(_discoveredSoftRefs[i], is_alive,
1116                                   keep_alive, complete_gc, yield);
1117     }
1118   }
1119 
1120   // Weak references
1121   {
1122     GCTraceTime(Debug, gc, ref) tm("Preclean WeakReferences", gc_timer);
1123     for (uint i = 0; i < _max_num_q; i++) {
1124       if (yield->should_return()) {
1125         return;
1126       }
1127       preclean_discovered_reflist(_discoveredWeakRefs[i], is_alive,
1128                                   keep_alive, complete_gc, yield);
1129     }
1130   }
1131 
1132   // Final references
1133   {
1134     GCTraceTime(Debug, gc, ref) tm("Preclean FinalReferences", gc_timer);
1135     for (uint i = 0; i < _max_num_q; i++) {
1136       if (yield->should_return()) {
1137         return;
1138       }
1139       preclean_discovered_reflist(_discoveredFinalRefs[i], is_alive,
1140                                   keep_alive, complete_gc, yield);
1141     }
1142   }
1143 
1144   // Phantom references
1145   {
1146     GCTraceTime(Debug, gc, ref) tm("Preclean PhantomReferences", gc_timer);
1147     for (uint i = 0; i < _max_num_q; i++) {
1148       if (yield->should_return()) {
1149         return;
1150       }
1151       preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,
1152                                   keep_alive, complete_gc, yield);
1153     }
1154   }
1155 }
1156 
1157 // Walk the given discovered ref list, and remove all reference objects
1158 // whose referents are still alive, whose referents are NULL or which
1159 // are not active (have a non-NULL next field). NOTE: When we are
1160 // thus precleaning the ref lists (which happens single-threaded today),
1161 // we do not disable refs discovery to honor the correct semantics of
1162 // java.lang.Reference. As a result, we need to be careful below
1163 // that ref removal steps interleave safely with ref discovery steps
1164 // (in this thread).
1165 void
1166 ReferenceProcessor::preclean_discovered_reflist(DiscoveredList&    refs_list,
1167                                                 BoolObjectClosure* is_alive,
1168                                                 OopClosure*        keep_alive,
1169                                                 VoidClosure*       complete_gc,
1170                                                 YieldClosure*      yield) {
1171   DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
1172   while (iter.has_next()) {
1173     iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
1174     oop obj = iter.obj();
1175     oop next = java_lang_ref_Reference::next(obj);
1176     if (iter.referent() == NULL || iter.is_referent_alive() ||
1177         next != NULL) {
1178       // The referent has been cleared, or is alive, or the Reference is not
1179       // active; we need to trace and mark its cohort.
1180       log_develop_trace(gc, ref)("Precleaning Reference (" INTPTR_FORMAT ": %s)",
1181                                  p2i(iter.obj()), iter.obj()->klass()->internal_name());
1182       // Remove Reference object from list
1183       iter.remove();
1184       // Keep alive its cohort.
1185       iter.make_referent_alive();
1186       if (UseCompressedOops) {
1187         narrowOop* next_addr = (narrowOop*)java_lang_ref_Reference::next_addr(obj);
1188         keep_alive->do_oop(next_addr);
1189       } else {
1190         oop* next_addr = (oop*)java_lang_ref_Reference::next_addr(obj);
1191         keep_alive->do_oop(next_addr);
1192       }
1193       iter.move_to_next();
1194     } else {
1195       iter.next();
1196     }
1197   }
1198   // Close the reachable set
1199   complete_gc->do_void();
1200 
1201   NOT_PRODUCT(
1202     if (iter.processed() > 0) {
1203       log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " Refs out of " SIZE_FORMAT " Refs in discovered list " INTPTR_FORMAT,
1204         iter.removed(), iter.processed(), p2i(&refs_list));
1205     }
1206   )
1207 }
1208 
1209 const char* ReferenceProcessor::list_name(uint i) {
1210    assert(i <= _max_num_q * number_of_subclasses_of_ref(),
1211           "Out of bounds index");
1212 
1213    int j = i / _max_num_q;
1214    switch (j) {
1215      case 0: return "SoftRef";
1216      case 1: return "WeakRef";
1217      case 2: return "FinalRef";
1218      case 3: return "PhantomRef";
1219    }
1220    ShouldNotReachHere();
1221    return NULL;
1222 }
1223