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

comparison src/share/vm/memory/referenceProcessor.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	4a7dc38ae96b f2110083203d
children	f22cbff51c12

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 */
 #include "precompiled.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/systemDictionary.hpp"
+#include "gc_implementation/shared/gcTimer.hpp"
+#include "gc_implementation/shared/gcTraceTime.hpp"
 #include "gc_interface/collectedHeap.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "memory/referencePolicy.hpp"
 #include "memory/referenceProcessor.hpp"
 #include "oops/oop.inline.hpp"
 }
 // Else leave clock stalled at its old value until time progresses
 // past clock value.
 }
-void ReferenceProcessor::process_discovered_references(
+size_t ReferenceProcessor::total_count(DiscoveredList lists[]) {
+size_t total = 0;
+for (uint i = 0; i < _max_num_q; ++i) {
+total += lists[i].length();
+}
+return total;
+}
+ReferenceProcessorStats ReferenceProcessor::process_discovered_references(
 BoolObjectClosure*           is_alive,
 OopClosure*                  keep_alive,
 VoidClosure*                 complete_gc,
-AbstractRefProcTaskExecutor* task_executor) {
+AbstractRefProcTaskExecutor* task_executor,
+GCTimer*                     gc_timer) {
 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();
 // discovered soft refs.
 _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
 bool trace_time = PrintGCDetails && PrintReferenceGC;
 // Soft references
+size_t soft_count = 0;
 {
-TraceTime tt("SoftReference", trace_time, false, gclog_or_tty);
+GCTraceTime tt("SoftReference", trace_time, false, gc_timer);
-process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
+soft_count =
-is_alive, keep_alive, complete_gc, task_executor);
+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;
 {
-TraceTime tt("WeakReference", trace_time, false, gclog_or_tty);
+GCTraceTime tt("WeakReference", trace_time, false, gc_timer);
-process_discovered_reflist(_discoveredWeakRefs, NULL, true,
+weak_count =
-is_alive, keep_alive, complete_gc, task_executor);
+process_discovered_reflist(_discoveredWeakRefs, NULL, true,
+is_alive, keep_alive, complete_gc, task_executor);
 }
 // Final references
+size_t final_count = 0;
 {
-TraceTime tt("FinalReference", trace_time, false, gclog_or_tty);
+GCTraceTime tt("FinalReference", trace_time, false, gc_timer);
-process_discovered_reflist(_discoveredFinalRefs, NULL, false,
+final_count =
-is_alive, keep_alive, complete_gc, task_executor);
+process_discovered_reflist(_discoveredFinalRefs, NULL, false,
+is_alive, keep_alive, complete_gc, task_executor);
 }
 // Phantom references
+size_t phantom_count = 0;
 {
-TraceTime tt("PhantomReference", trace_time, false, gclog_or_tty);
+GCTraceTime tt("PhantomReference", trace_time, false, gc_timer);
-process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
+phantom_count =
-is_alive, keep_alive, complete_gc, task_executor);
+process_discovered_reflist(_discoveredPhantomRefs, 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.
 {
-TraceTime tt("JNI Weak Reference", trace_time, false, gclog_or_tty);
+GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer);
 if (task_executor != NULL) {
 task_executor->set_single_threaded_mode();
 }
 process_phaseJNI(is_alive, keep_alive, complete_gc);
 #ifdef GRAAL
 process_phaseGraalNMethods(keep_alive, complete_gc);
 #endif
 }
+return ReferenceProcessorStats(soft_count, weak_count, final_count, phantom_count);
 }
 #ifndef PRODUCT
 // Calculate the number of jni handles.
 uint ReferenceProcessor::count_jni_refs() {
 class AlwaysAliveClosure: public BoolObjectClosure {
 public:
 virtual bool do_object_b(oop obj) { return true; }
-virtual void do_object(oop obj) { assert(false, "Don't call"); }
 };
 class CountHandleClosure: public OopClosure {
 private:
 int _count;
 balance_queues(_discoveredWeakRefs);
 balance_queues(_discoveredFinalRefs);
 balance_queues(_discoveredPhantomRefs);
 }
-void
+size_t
 ReferenceProcessor::process_discovered_reflist(
 DiscoveredList               refs_lists[],
 ReferencePolicy*             policy,
 bool                         clear_referent,
 BoolObjectClosure*           is_alive,
 if ((mt_processing && ParallelRefProcBalancingEnabled) ||
 must_balance) {
 balance_queues(refs_lists);
 }
+size_t total_list_count = total_count(refs_lists);
 if (PrintReferenceGC && PrintGCDetails) {
-size_t total = 0;
+gclog_or_tty->print(", %u refs", total_list_count);
-for (uint i = 0; i < _max_num_q; ++i) {
-total += refs_lists[i].length();
-}
-gclog_or_tty->print(", %u refs", total);
 }
 // Phase 1 (soft refs only):
 // . Traverse the list and remove any SoftReferences whose
 //   referents are not alive, but that should be kept alive for
 for (uint i = 0; i < _max_num_q; i++) {
 process_phase3(refs_lists[i], clear_referent,
 is_alive, keep_alive, complete_gc);
 }
 }
+return total_list_count;
 }
 void ReferenceProcessor::clean_up_discovered_references() {
 // loop over the lists
 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
 // in any order and, indeed, concurrently.
 void ReferenceProcessor::preclean_discovered_references(
 BoolObjectClosure* is_alive,
 OopClosure* keep_alive,
 VoidClosure* complete_gc,
-YieldClosure* yield) {
+YieldClosure* yield,
+GCTimer* gc_timer) {
 NOT_PRODUCT(verify_ok_to_handle_reflists());
 // Soft references
 {
-TraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
+GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
-false, gclog_or_tty);
+false, gc_timer);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredSoftRefs[i], is_alive,
 }
 }
 // Weak references
 {
-TraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC,
+GCTraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC,
-false, gclog_or_tty);
+false, gc_timer);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredWeakRefs[i], is_alive,
 }
 }
 // Final references
 {
-TraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC,
+GCTraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC,
-false, gclog_or_tty);
+false, gc_timer);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredFinalRefs[i], is_alive,
 }
 }
 // Phantom references
 {
-TraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
+GCTraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
-false, gclog_or_tty);
+false, gc_timer);
 for (uint i = 0; i < _max_num_q; i++) {
 if (yield->should_return()) {
 return;
 }
 preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/referenceProcessor.cpp @ 10408:836a62f43af9