hotspot/src/share/vm/gc/shared/referenceProcessor.cpp
changeset 30766 8afe4435d599
parent 30764 fec48bf5a827
child 32607 c69a7b61ab02
equal deleted inserted replaced
30765:32398da8ba8f 30766:8afe4435d599
   187   OopClosure*                  keep_alive,
   187   OopClosure*                  keep_alive,
   188   VoidClosure*                 complete_gc,
   188   VoidClosure*                 complete_gc,
   189   AbstractRefProcTaskExecutor* task_executor,
   189   AbstractRefProcTaskExecutor* task_executor,
   190   GCTimer*                     gc_timer,
   190   GCTimer*                     gc_timer,
   191   GCId                         gc_id) {
   191   GCId                         gc_id) {
   192   NOT_PRODUCT(verify_ok_to_handle_reflists());
       
   193 
   192 
   194   assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
   193   assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
   195   // Stop treating discovered references specially.
   194   // Stop treating discovered references specially.
   196   disable_discovery();
   195   disable_discovery();
   197 
   196 
   327   // Return true if new pending references were added
   326   // Return true if new pending references were added
   328   return old_pending_list_value != *pending_list_addr;
   327   return old_pending_list_value != *pending_list_addr;
   329 }
   328 }
   330 
   329 
   331 bool ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor) {
   330 bool ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor) {
   332   NOT_PRODUCT(verify_ok_to_handle_reflists());
       
   333   if (UseCompressedOops) {
   331   if (UseCompressedOops) {
   334     return enqueue_discovered_ref_helper<narrowOop>(this, task_executor);
   332     return enqueue_discovered_ref_helper<narrowOop>(this, task_executor);
   335   } else {
   333   } else {
   336     return enqueue_discovered_ref_helper<oop>(this, task_executor);
   334     return enqueue_discovered_ref_helper<oop>(this, task_executor);
   337   }
   335   }
   649   }
   647   }
   650   refs_list.set_head(NULL);
   648   refs_list.set_head(NULL);
   651   refs_list.set_length(0);
   649   refs_list.set_length(0);
   652 }
   650 }
   653 
   651 
   654 void
       
   655 ReferenceProcessor::abandon_partial_discovered_list(DiscoveredList& refs_list) {
       
   656   clear_discovered_references(refs_list);
       
   657 }
       
   658 
       
   659 void ReferenceProcessor::abandon_partial_discovery() {
   652 void ReferenceProcessor::abandon_partial_discovery() {
   660   // loop over the lists
   653   // loop over the lists
   661   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
   654   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
   662     if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
   655     if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
   663       gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i));
   656       gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i));
   664     }
   657     }
   665     abandon_partial_discovered_list(_discovered_refs[i]);
   658     clear_discovered_references(_discovered_refs[i]);
   666   }
   659   }
   667 }
   660 }
   668 
   661 
   669 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
   662 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
   670 public:
   663 public:
  1157   OopClosure* keep_alive,
  1150   OopClosure* keep_alive,
  1158   VoidClosure* complete_gc,
  1151   VoidClosure* complete_gc,
  1159   YieldClosure* yield,
  1152   YieldClosure* yield,
  1160   GCTimer* gc_timer,
  1153   GCTimer* gc_timer,
  1161   GCId     gc_id) {
  1154   GCId     gc_id) {
  1162 
       
  1163   NOT_PRODUCT(verify_ok_to_handle_reflists());
       
  1164 
  1155 
  1165   // Soft references
  1156   // Soft references
  1166   {
  1157   {
  1167     GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
  1158     GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
  1168               false, gc_timer, gc_id);
  1159               false, gc_timer, gc_id);
  1295    }
  1286    }
  1296    ShouldNotReachHere();
  1287    ShouldNotReachHere();
  1297    return NULL;
  1288    return NULL;
  1298 }
  1289 }
  1299 
  1290 
  1300 #ifndef PRODUCT
       
  1301 void ReferenceProcessor::verify_ok_to_handle_reflists() {
       
  1302   // empty for now
       
  1303 }
       
  1304 #endif
       
  1305 
       
  1306 #ifndef PRODUCT
       
  1307 void ReferenceProcessor::clear_discovered_references() {
       
  1308   guarantee(!_discovering_refs, "Discovering refs?");
       
  1309   for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
       
  1310     clear_discovered_references(_discovered_refs[i]);
       
  1311   }
       
  1312 }
       
  1313 
       
  1314 #endif // PRODUCT