truffle: src/share/vm/memory/referenceProcessor.cpp comparison

comparison src/share/vm/memory/referenceProcessor.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 c2844108a708
children	f01ebceea995

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 }
 _discoveredSoftRefs    = &_discovered_refs[0];
 _discoveredWeakRefs    = &_discoveredSoftRefs[_max_num_q];
 _discoveredFinalRefs   = &_discoveredWeakRefs[_max_num_q];
 _discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];
+_discoveredCleanerRefs = &_discoveredPhantomRefs[_max_num_q];
 // Initialize all entries to NULL
 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 _discovered_refs[i].set_head(NULL);
 _discovered_refs[i].set_length(0);
 ReferenceProcessorStats ReferenceProcessor::process_discovered_references(
 BoolObjectClosure*           is_alive,
 OopClosure*                  keep_alive,
 VoidClosure*                 complete_gc,
 AbstractRefProcTaskExecutor* task_executor,
-GCTimer*                     gc_timer) {
+GCTimer*                     gc_timer,
+GCId                         gc_id) {
 NOT_PRODUCT(verify_ok_to_handle_reflists());
 assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
 // Stop treating discovered references specially.
 disable_discovery();
 bool trace_time = PrintGCDetails && PrintReferenceGC;
 // Soft references
 size_t soft_count = 0;
 {
-GCTraceTime tt("SoftReference", trace_time, false, gc_timer);
+GCTraceTime tt("SoftReference", trace_time, false, gc_timer, gc_id);
 soft_count =
 process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
 is_alive, keep_alive, complete_gc, task_executor);
 }
 update_soft_ref_master_clock();
 // Weak references
 size_t weak_count = 0;
 {
-GCTraceTime tt("WeakReference", trace_time, false, gc_timer);
+GCTraceTime tt("WeakReference", trace_time, false, gc_timer, gc_id);
 weak_count =
 process_discovered_reflist(_discoveredWeakRefs, NULL, true,
 is_alive, keep_alive, complete_gc, task_executor);
 }
 // Final references
 size_t final_count = 0;
 {
-GCTraceTime tt("FinalReference", trace_time, false, gc_timer);
+GCTraceTime tt("FinalReference", trace_time, false, gc_timer, gc_id);
 final_count =
 process_discovered_reflist(_discoveredFinalRefs, NULL, false,
 is_alive, keep_alive, complete_gc, task_executor);
 }
 // Phantom references
 size_t phantom_count = 0;
 {
-GCTraceTime tt("PhantomReference", trace_time, false, gc_timer);
+GCTraceTime tt("PhantomReference", trace_time, false, gc_timer, gc_id);
 phantom_count =
 process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
+is_alive, keep_alive, complete_gc, task_executor);
+// Process cleaners, but include them in phantom statistics.  We expect
+// Cleaner references to be temporary, and don't want to deal with
+// possible incompatibilities arising from making it more visible.
+phantom_count +=
+process_discovered_reflist(_discoveredCleanerRefs, NULL, false,
 is_alive, keep_alive, complete_gc, task_executor);
 }
 // Weak global JNI references. It would make more sense (semantically) to
 // traverse these simultaneously with the regular weak references above, but
 // that is not how the JDK1.2 specification is. See #4126360. Native code can
 // thus use JNI weak references to circumvent the phantom references and
 // resurrect a "post-mortem" object.
 {
-GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer);
+GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer, gc_id);
 if (task_executor != NULL) {
 task_executor->set_single_threaded_mode();
 }
 process_phaseJNI(is_alive, keep_alive, complete_gc);
 }
 void ReferenceProcessor::balance_all_queues() {
 balance_queues(_discoveredSoftRefs);
 balance_queues(_discoveredWeakRefs);
 balance_queues(_discoveredFinalRefs);
 balance_queues(_discoveredPhantomRefs);
+balance_queues(_discoveredCleanerRefs);
 }
 size_t
 ReferenceProcessor::process_discovered_reflist(
 DiscoveredList               refs_lists[],
 case REF_FINAL:
 list = &_discoveredFinalRefs[id];
 break;
 case REF_PHANTOM:
 list = &_discoveredPhantomRefs[id];
+break;
+case REF_CLEANER:
+list = &_discoveredCleanerRefs[id];
 break;
 case REF_NONE:
 // we should not reach here if we are an InstanceRefKlass
 default:
 ShouldNotReachHere();
 void ReferenceProcessor::preclean_discovered_references(
 BoolObjectClosure* is_alive,
 OopClosure* keep_alive,
 VoidClosure* complete_gc,
 YieldClosure* yield,
-GCTimer* gc_timer) {
+GCTimer* gc_timer,
+GCId     gc_id) {
 NOT_PRODUCT(verify_ok_to_handle_reflists());
 // Soft references
 {
 GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
-false, gc_timer);
+false, gc_timer, gc_id);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredSoftRefs[i], is_alive,
 }
 // Weak references
 {
 GCTraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC,
-false, gc_timer);
+false, gc_timer, gc_id);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredWeakRefs[i], is_alive,
 }
 // Final references
 {
 GCTraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC,
-false, gc_timer);
+false, gc_timer, gc_id);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredFinalRefs[i], is_alive,
 }
 // Phantom references
 {
 GCTraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
-false, gc_timer);
+false, gc_timer, gc_id);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,
+keep_alive, complete_gc, yield);
+}
+// Cleaner references.  Included in timing for phantom references.  We
+// expect Cleaner references to be temporary, and don't want to deal with
+// possible incompatibilities arising from making it more visible.
+for (uint i = 0; i < _max_num_q; i++) {
+if (yield->should_return()) {
+return;
+}
+preclean_discovered_reflist(_discoveredCleanerRefs[i], is_alive,
 keep_alive, complete_gc, yield);
 }
 }
 }
 switch (j) {
 case 0: return "SoftRef";
 case 1: return "WeakRef";
 case 2: return "FinalRef";
 case 3: return "PhantomRef";
+case 4: return "CleanerRef";
 }
 ShouldNotReachHere();
 return NULL;
 }

Mercurial > hg > truffle

comparison src/share/vm/memory/referenceProcessor.cpp @ 20804:7848fc12602b