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

annotate src/share/vm/memory/referenceProcessor.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	0982ec23da03
children	c2844108a708

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17748 diff changeset	2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	27 #include "classfile/systemDictionary.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	28 #include "gc_implementation/shared/gcTimer.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	29 #include "gc_implementation/shared/gcTraceTime.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	30 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	31 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	32 #include "memory/referencePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	33 #include "memory/referenceProcessor.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	35 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	36 #include "runtime/jniHandles.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	37
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17748 diff changeset	38 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17748 diff changeset	39
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	40 ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	41 ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy = NULL;
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	42 bool ReferenceProcessor::_pending_list_uses_discovered_field = false;
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	43 jlong ReferenceProcessor::_soft_ref_timestamp_clock = 0;
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	44
0 a61af66fc99e Initial load duke parents: diff changeset	45 void referenceProcessor_init() {
a61af66fc99e Initial load duke parents: diff changeset	46 ReferenceProcessor::init_statics();
a61af66fc99e Initial load duke parents: diff changeset	47 }
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 void ReferenceProcessor::init_statics() {
4712 e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	50 // We need a monotonically non-deccreasing time in ms but
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	51 // os::javaTimeMillis() does not guarantee monotonicity.
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	52 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	53
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	54 // Initialize the soft ref timestamp clock.
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	55 _soft_ref_timestamp_clock = now;
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	56 // Also update the soft ref clock in j.l.r.SoftReference
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	57 java_lang_ref_SoftReference::set_clock(_soft_ref_timestamp_clock);
0 a61af66fc99e Initial load duke parents: diff changeset	58
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	59 _always_clear_soft_ref_policy = new AlwaysClearPolicy();
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	60 _default_soft_ref_policy = new COMPILER2_PRESENT(LRUMaxHeapPolicy())
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	61 NOT_COMPILER2(LRUCurrentHeapPolicy());
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	62 if (_always_clear_soft_ref_policy == NULL \|\| _default_soft_ref_policy == NULL) {
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	63 vm_exit_during_initialization("Could not allocate reference policy object");
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	64 }
0 a61af66fc99e Initial load duke parents: diff changeset	65 guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery \|\|
a61af66fc99e Initial load duke parents: diff changeset	66 RefDiscoveryPolicy == ReferentBasedDiscovery,
a61af66fc99e Initial load duke parents: diff changeset	67 "Unrecongnized RefDiscoveryPolicy");
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	68 _pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field();
0 a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	71 void ReferenceProcessor::enable_discovery(bool verify_disabled, bool check_no_refs) {
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	72 #ifdef ASSERT
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	73 // Verify that we're not currently discovering refs
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	74 assert(!verify_disabled \|\| !_discovering_refs, "nested call?");
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	75
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	76 if (check_no_refs) {
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	77 // Verify that the discovered lists are empty
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	78 verify_no_references_recorded();
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	79 }
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	80 #endif // ASSERT
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	81
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	82 // Someone could have modified the value of the static
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	83 // field in the j.l.r.SoftReference class that holds the
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	84 // soft reference timestamp clock using reflection or
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	85 // Unsafe between GCs. Unconditionally update the static
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	86 // field in ReferenceProcessor here so that we use the new
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	87 // value during reference discovery.
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	88
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	89 _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	90 _discovering_refs = true;
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	91 }
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	92
0 a61af66fc99e Initial load duke parents: diff changeset	93 ReferenceProcessor::ReferenceProcessor(MemRegion span,
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	94 bool mt_processing,
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	95 uint mt_processing_degree,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	96 bool mt_discovery,
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	97 uint mt_discovery_degree,
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	98 bool atomic_discovery,
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	99 BoolObjectClosure* is_alive_non_header) :
0 a61af66fc99e Initial load duke parents: diff changeset	100 _discovering_refs(false),
a61af66fc99e Initial load duke parents: diff changeset	101 _enqueuing_is_done(false),
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	102 _is_alive_non_header(is_alive_non_header),
0 a61af66fc99e Initial load duke parents: diff changeset	103 _processing_is_mt(mt_processing),
a61af66fc99e Initial load duke parents: diff changeset	104 _next_id(0)
a61af66fc99e Initial load duke parents: diff changeset	105 {
a61af66fc99e Initial load duke parents: diff changeset	106 _span = span;
a61af66fc99e Initial load duke parents: diff changeset	107 _discovery_is_atomic = atomic_discovery;
a61af66fc99e Initial load duke parents: diff changeset	108 _discovery_is_mt = mt_discovery;
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	109 _num_q = MAX2(1U, mt_processing_degree);
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	110 _max_num_q = MAX2(_num_q, mt_discovery_degree);
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	111 _discovered_refs = NEW_C_HEAP_ARRAY(DiscoveredList,
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	112 _max_num_q * number_of_subclasses_of_ref(), mtGC);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	113
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	114 if (_discovered_refs == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	115 vm_exit_during_initialization("Could not allocated RefProc Array");
a61af66fc99e Initial load duke parents: diff changeset	116 }
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	117 _discoveredSoftRefs = &_discovered_refs[0];
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	118 _discoveredWeakRefs = &_discoveredSoftRefs[_max_num_q];
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	119 _discoveredFinalRefs = &_discoveredWeakRefs[_max_num_q];
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	120 _discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	121
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	122 // Initialize all entries to NULL
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	123 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	124 _discovered_refs[i].set_head(NULL);
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	125 _discovered_refs[i].set_length(0);
0 a61af66fc99e Initial load duke parents: diff changeset	126 }
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	127
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	128 setup_policy(false /* default soft ref policy */);
0 a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	132 void ReferenceProcessor::verify_no_references_recorded() {
a61af66fc99e Initial load duke parents: diff changeset	133 guarantee(!_discovering_refs, "Discovering refs?");
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	134 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	135 guarantee(_discovered_refs[i].is_empty(),
0 a61af66fc99e Initial load duke parents: diff changeset	136 "Found non-empty discovered list");
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138 }
a61af66fc99e Initial load duke parents: diff changeset	139 #endif
a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141 void ReferenceProcessor::weak_oops_do(OopClosure* f) {
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	142 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	143 if (UseCompressedOops) {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	144 f->do_oop((narrowOop*)_discovered_refs[i].adr_head());
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	145 } else {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	146 f->do_oop((oop*)_discovered_refs[i].adr_head());
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	147 }
0 a61af66fc99e Initial load duke parents: diff changeset	148 }
a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	151 void ReferenceProcessor::update_soft_ref_master_clock() {
0 a61af66fc99e Initial load duke parents: diff changeset	152 // Update (advance) the soft ref master clock field. This must be done
a61af66fc99e Initial load duke parents: diff changeset	153 // after processing the soft ref list.
4712 e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	154
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	155 // We need a monotonically non-deccreasing time in ms but
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	156 // os::javaTimeMillis() does not guarantee monotonicity.
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	157 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	158 jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	159 assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	160
0 a61af66fc99e Initial load duke parents: diff changeset	161 NOT_PRODUCT(
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	162 if (now < _soft_ref_timestamp_clock) {
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	163 warning("time warp: "INT64_FORMAT" to "INT64_FORMAT,
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	164 _soft_ref_timestamp_clock, now);
0 a61af66fc99e Initial load duke parents: diff changeset	165 }
a61af66fc99e Initial load duke parents: diff changeset	166 )
4712 e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	167 // The values of now and _soft_ref_timestamp_clock are set using
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	168 // javaTimeNanos(), which is guaranteed to be monotonically
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	169 // non-decreasing provided the underlying platform provides such
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	170 // a time source (and it is bug free).
e7dead7e90af 7117303: VM uses non-monotonic time source and complains that it is non-monotonic johnc parents: 4014 diff changeset	171 // In product mode, however, protect ourselves from non-monotonicty.
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	172 if (now > _soft_ref_timestamp_clock) {
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	173 _soft_ref_timestamp_clock = now;
0 a61af66fc99e Initial load duke parents: diff changeset	174 java_lang_ref_SoftReference::set_clock(now);
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176 // Else leave clock stalled at its old value until time progresses
a61af66fc99e Initial load duke parents: diff changeset	177 // past clock value.
a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	180 size_t ReferenceProcessor::total_count(DiscoveredList lists[]) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	181 size_t total = 0;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	182 for (uint i = 0; i < _max_num_q; ++i) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	183 total += lists[i].length();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	184 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	185 return total;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	186 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	187
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	188 ReferenceProcessorStats ReferenceProcessor::process_discovered_references(
0 a61af66fc99e Initial load duke parents: diff changeset	189 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	190 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	191 VoidClosure* complete_gc,
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	192 AbstractRefProcTaskExecutor* task_executor,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	193 GCTimer* gc_timer,
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	194 GCId gc_id) {
0 a61af66fc99e Initial load duke parents: diff changeset	195 NOT_PRODUCT(verify_ok_to_handle_reflists());
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
a61af66fc99e Initial load duke parents: diff changeset	198 // Stop treating discovered references specially.
a61af66fc99e Initial load duke parents: diff changeset	199 disable_discovery();
a61af66fc99e Initial load duke parents: diff changeset	200
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	201 // If discovery was concurrent, someone could have modified
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	202 // the value of the static field in the j.l.r.SoftReference
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	203 // class that holds the soft reference timestamp clock using
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	204 // reflection or Unsafe between when discovery was enabled and
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	205 // now. Unconditionally update the static field in ReferenceProcessor
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	206 // here so that we use the new value during processing of the
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	207 // discovered soft refs.
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	208
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	209 _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	210
0 a61af66fc99e Initial load duke parents: diff changeset	211 bool trace_time = PrintGCDetails && PrintReferenceGC;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	212
0 a61af66fc99e Initial load duke parents: diff changeset	213 // Soft references
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	214 size_t soft_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	215 {
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	216 GCTraceTime tt("SoftReference", trace_time, false, gc_timer, gc_id);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	217 soft_count =
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	218 process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	219 is_alive, keep_alive, complete_gc, task_executor);
0 a61af66fc99e Initial load duke parents: diff changeset	220 }
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 update_soft_ref_master_clock();
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 // Weak references
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	225 size_t weak_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	226 {
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	227 GCTraceTime tt("WeakReference", trace_time, false, gc_timer, gc_id);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	228 weak_count =
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	229 process_discovered_reflist(_discoveredWeakRefs, NULL, true,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	230 is_alive, keep_alive, complete_gc, task_executor);
0 a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233 // Final references
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	234 size_t final_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	235 {
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	236 GCTraceTime tt("FinalReference", trace_time, false, gc_timer, gc_id);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	237 final_count =
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	238 process_discovered_reflist(_discoveredFinalRefs, NULL, false,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	239 is_alive, keep_alive, complete_gc, task_executor);
0 a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 // Phantom references
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	243 size_t phantom_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	244 {
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	245 GCTraceTime tt("PhantomReference", trace_time, false, gc_timer, gc_id);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	246 phantom_count =
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	247 process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	248 is_alive, keep_alive, complete_gc, task_executor);
0 a61af66fc99e Initial load duke parents: diff changeset	249 }
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 // Weak global JNI references. It would make more sense (semantically) to
a61af66fc99e Initial load duke parents: diff changeset	252 // traverse these simultaneously with the regular weak references above, but
a61af66fc99e Initial load duke parents: diff changeset	253 // that is not how the JDK1.2 specification is. See #4126360. Native code can
a61af66fc99e Initial load duke parents: diff changeset	254 // thus use JNI weak references to circumvent the phantom references and
a61af66fc99e Initial load duke parents: diff changeset	255 // resurrect a "post-mortem" object.
a61af66fc99e Initial load duke parents: diff changeset	256 {
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	257 GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer, gc_id);
0 a61af66fc99e Initial load duke parents: diff changeset	258 if (task_executor != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	259 task_executor->set_single_threaded_mode();
a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261 process_phaseJNI(is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	262 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	263
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	264 return ReferenceProcessorStats(soft_count, weak_count, final_count, phantom_count);
0 a61af66fc99e Initial load duke parents: diff changeset	265 }
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	268 // Calculate the number of jni handles.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	269 uint ReferenceProcessor::count_jni_refs() {
0 a61af66fc99e Initial load duke parents: diff changeset	270 class AlwaysAliveClosure: public BoolObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	271 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	272 virtual bool do_object_b(oop obj) { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	273 };
a61af66fc99e Initial load duke parents: diff changeset	274
a61af66fc99e Initial load duke parents: diff changeset	275 class CountHandleClosure: public OopClosure {
a61af66fc99e Initial load duke parents: diff changeset	276 private:
a61af66fc99e Initial load duke parents: diff changeset	277 int _count;
a61af66fc99e Initial load duke parents: diff changeset	278 public:
a61af66fc99e Initial load duke parents: diff changeset	279 CountHandleClosure(): _count(0) {}
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	280 void do_oop(oop* unused) { _count++; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	281 void do_oop(narrowOop* unused) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	282 int count() { return _count; }
a61af66fc99e Initial load duke parents: diff changeset	283 };
a61af66fc99e Initial load duke parents: diff changeset	284 CountHandleClosure global_handle_count;
a61af66fc99e Initial load duke parents: diff changeset	285 AlwaysAliveClosure always_alive;
a61af66fc99e Initial load duke parents: diff changeset	286 JNIHandles::weak_oops_do(&always_alive, &global_handle_count);
a61af66fc99e Initial load duke parents: diff changeset	287 return global_handle_count.count();
a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289 #endif
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 void ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	292 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	293 VoidClosure* complete_gc) {
a61af66fc99e Initial load duke parents: diff changeset	294 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	295 if (PrintGCDetails && PrintReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	296 unsigned int count = count_jni_refs();
a61af66fc99e Initial load duke parents: diff changeset	297 gclog_or_tty->print(", %u refs", count);
a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299 #endif
a61af66fc99e Initial load duke parents: diff changeset	300 JNIHandles::weak_oops_do(is_alive, keep_alive);
a61af66fc99e Initial load duke parents: diff changeset	301 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	304
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	305 template <class T>
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 935 diff changeset	306 bool enqueue_discovered_ref_helper(ReferenceProcessor* ref,
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 935 diff changeset	307 AbstractRefProcTaskExecutor* task_executor) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	308
0 a61af66fc99e Initial load duke parents: diff changeset	309 // Remember old value of pending references list
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	310 T* pending_list_addr = (T*)java_lang_ref_Reference::pending_list_addr();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	311 T old_pending_list_value = *pending_list_addr;
0 a61af66fc99e Initial load duke parents: diff changeset	312
a61af66fc99e Initial load duke parents: diff changeset	313 // Enqueue references that are not made active again, and
a61af66fc99e Initial load duke parents: diff changeset	314 // clear the decks for the next collection (cycle).
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	315 ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
17746 a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	316 // Do the post-barrier on pending_list_addr missed in
a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	317 // enqueue_discovered_reflist.
a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	318 oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
0 a61af66fc99e Initial load duke parents: diff changeset	319
a61af66fc99e Initial load duke parents: diff changeset	320 // Stop treating discovered references specially.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	321 ref->disable_discovery();
0 a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 // Return true if new pending references were added
a61af66fc99e Initial load duke parents: diff changeset	324 return old_pending_list_value != *pending_list_addr;
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	327 bool ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	328 NOT_PRODUCT(verify_ok_to_handle_reflists());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	329 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	330 return enqueue_discovered_ref_helper<narrowOop>(this, task_executor);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	331 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	332 return enqueue_discovered_ref_helper<oop>(this, task_executor);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	333 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	334 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	335
0 a61af66fc99e Initial load duke parents: diff changeset	336 void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	337 HeapWord* pending_list_addr) {
0 a61af66fc99e Initial load duke parents: diff changeset	338 // Given a list of refs linked through the "discovered" field
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	339 // (java.lang.ref.Reference.discovered), self-loop their "next" field
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	340 // thus distinguishing them from active References, then
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	341 // prepend them to the pending list.
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	342 //
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	343 // The Java threads will see the Reference objects linked together through
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	344 // the discovered field. Instead of trying to do the write barrier updates
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	345 // in all places in the reference processor where we manipulate the discovered
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	346 // field we make sure to do the barrier here where we anyway iterate through
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	347 // all linked Reference objects. Note that it is important to not dirty any
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	348 // cards during reference processing since this will cause card table
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	349 // verification to fail for G1.
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	350 //
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	351 // BKWRD COMPATIBILITY NOTE: For older JDKs (prior to the fix for 4956777),
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	352 // the "next" field is used to chain the pending list, not the discovered
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	353 // field.
0 a61af66fc99e Initial load duke parents: diff changeset	354 if (TraceReferenceGC && PrintGCDetails) {
a61af66fc99e Initial load duke parents: diff changeset	355 gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list "
a61af66fc99e Initial load duke parents: diff changeset	356 INTPTR_FORMAT, (address)refs_list.head());
a61af66fc99e Initial load duke parents: diff changeset	357 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	358
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	359 oop obj = NULL;
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	360 oop next_d = refs_list.head();
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	361 if (pending_list_uses_discovered_field()) { // New behavior
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	362 // Walk down the list, self-looping the next field
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	363 // so that the References are not considered active.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	364 while (obj != next_d) {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	365 obj = next_d;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	366 assert(obj->is_instanceRef(), "should be reference object");
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	367 next_d = java_lang_ref_Reference::discovered(obj);
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	368 if (TraceReferenceGC && PrintGCDetails) {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	369 gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	370 (void )obj, (void )next_d);
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	371 }
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	372 assert(java_lang_ref_Reference::next(obj) == NULL,
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	373 "Reference not active; should not be discovered");
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	374 // Self-loop next, so as to make Ref not active.
17746 a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	375 java_lang_ref_Reference::set_next_raw(obj, obj);
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	376 if (next_d != obj) {
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	377 oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d);
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	378 } else {
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	379 // This is the last object.
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	380 // Swap refs_list into pending_list_addr and
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	381 // set obj's discovered to what we read from pending_list_addr.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	382 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	383 // Need post-barrier on pending_list_addr. See enqueue_discovered_ref_helper() above.
17746 a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	384 java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	385 oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	386 }
0 a61af66fc99e Initial load duke parents: diff changeset	387 }
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	388 } else { // Old behaviour
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	389 // Walk down the list, copying the discovered field into
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	390 // the next field and clearing the discovered field.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	391 while (obj != next_d) {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	392 obj = next_d;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	393 assert(obj->is_instanceRef(), "should be reference object");
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	394 next_d = java_lang_ref_Reference::discovered(obj);
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	395 if (TraceReferenceGC && PrintGCDetails) {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	396 gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	397 (void )obj, (void )next_d);
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	398 }
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	399 assert(java_lang_ref_Reference::next(obj) == NULL,
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	400 "The reference should not be enqueued");
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	401 if (next_d == obj) { // obj is last
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	402 // Swap refs_list into pendling_list_addr and
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	403 // set obj's next to what we read from pending_list_addr.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	404 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	405 // Need oop_check on pending_list_addr above;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	406 // see special oop-check code at the end of
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	407 // enqueue_discovered_reflists() further below.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	408 if (old == NULL) {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	409 // obj should be made to point to itself, since
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	410 // pending list was empty.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	411 java_lang_ref_Reference::set_next(obj, obj);
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	412 } else {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	413 java_lang_ref_Reference::set_next(obj, old);
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	414 }
0 a61af66fc99e Initial load duke parents: diff changeset	415 } else {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	416 java_lang_ref_Reference::set_next(obj, next_d);
0 a61af66fc99e Initial load duke parents: diff changeset	417 }
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	418 java_lang_ref_Reference::set_discovered(obj, (oop) NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	419 }
a61af66fc99e Initial load duke parents: diff changeset	420 }
a61af66fc99e Initial load duke parents: diff changeset	421 }
a61af66fc99e Initial load duke parents: diff changeset	422
a61af66fc99e Initial load duke parents: diff changeset	423 // Parallel enqueue task
a61af66fc99e Initial load duke parents: diff changeset	424 class RefProcEnqueueTask: public AbstractRefProcTaskExecutor::EnqueueTask {
a61af66fc99e Initial load duke parents: diff changeset	425 public:
a61af66fc99e Initial load duke parents: diff changeset	426 RefProcEnqueueTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	427 DiscoveredList discovered_refs[],
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	428 HeapWord* pending_list_addr,
0 a61af66fc99e Initial load duke parents: diff changeset	429 int n_queues)
a61af66fc99e Initial load duke parents: diff changeset	430 : EnqueueTask(ref_processor, discovered_refs,
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	431 pending_list_addr, n_queues)
0 a61af66fc99e Initial load duke parents: diff changeset	432 { }
a61af66fc99e Initial load duke parents: diff changeset	433
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	434 virtual void work(unsigned int work_id) {
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	435 assert(work_id < (unsigned int)_ref_processor.max_num_q(), "Index out-of-bounds");
0 a61af66fc99e Initial load duke parents: diff changeset	436 // Simplest first cut: static partitioning.
a61af66fc99e Initial load duke parents: diff changeset	437 int index = work_id;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	438 // The increment on "index" must correspond to the maximum number of queues
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	439 // (n_queues) with which that ReferenceProcessor was created. That
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	440 // is because of the "clever" way the discovered references lists were
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	441 // allocated and are indexed into.
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	442 assert(_n_queues == (int) _ref_processor.max_num_q(), "Different number not expected");
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	443 for (int j = 0;
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	444 j < ReferenceProcessor::number_of_subclasses_of_ref();
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	445 j++, index += _n_queues) {
0 a61af66fc99e Initial load duke parents: diff changeset	446 _ref_processor.enqueue_discovered_reflist(
a61af66fc99e Initial load duke parents: diff changeset	447 _refs_lists[index], _pending_list_addr);
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	448 _refs_lists[index].set_head(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	449 _refs_lists[index].set_length(0);
a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 };
a61af66fc99e Initial load duke parents: diff changeset	453
a61af66fc99e Initial load duke parents: diff changeset	454 // Enqueue references that are not made active again
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	455 void ReferenceProcessor::enqueue_discovered_reflists(HeapWord* pending_list_addr,
0 a61af66fc99e Initial load duke parents: diff changeset	456 AbstractRefProcTaskExecutor* task_executor) {
a61af66fc99e Initial load duke parents: diff changeset	457 if (_processing_is_mt && task_executor != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	458 // Parallel code
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	459 RefProcEnqueueTask tsk(*this, _discovered_refs,
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	460 pending_list_addr, _max_num_q);
0 a61af66fc99e Initial load duke parents: diff changeset	461 task_executor->execute(tsk);
a61af66fc99e Initial load duke parents: diff changeset	462 } else {
a61af66fc99e Initial load duke parents: diff changeset	463 // Serial code: call the parent class's implementation
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	464 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	465 enqueue_discovered_reflist(_discovered_refs[i], pending_list_addr);
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	466 _discovered_refs[i].set_head(NULL);
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	467 _discovered_refs[i].set_length(0);
0 a61af66fc99e Initial load duke parents: diff changeset	468 }
a61af66fc99e Initial load duke parents: diff changeset	469 }
a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	472 void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
0 a61af66fc99e Initial load duke parents: diff changeset	473 _discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	474 oop discovered = java_lang_ref_Reference::discovered(_ref);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	475 assert(_discovered_addr && discovered->is_oop_or_null(),
0 a61af66fc99e Initial load duke parents: diff changeset	476 "discovered field is bad");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	477 _next = discovered;
0 a61af66fc99e Initial load duke parents: diff changeset	478 _referent_addr = java_lang_ref_Reference::referent_addr(_ref);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	479 _referent = java_lang_ref_Reference::referent(_ref);
0 a61af66fc99e Initial load duke parents: diff changeset	480 assert(Universe::heap()->is_in_reserved_or_null(_referent),
a61af66fc99e Initial load duke parents: diff changeset	481 "Wrong oop found in java.lang.Reference object");
a61af66fc99e Initial load duke parents: diff changeset	482 assert(allow_null_referent ?
a61af66fc99e Initial load duke parents: diff changeset	483 _referent->is_oop_or_null()
a61af66fc99e Initial load duke parents: diff changeset	484 : _referent->is_oop(),
a61af66fc99e Initial load duke parents: diff changeset	485 "bad referent");
a61af66fc99e Initial load duke parents: diff changeset	486 }
a61af66fc99e Initial load duke parents: diff changeset	487
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	488 void DiscoveredListIterator::remove() {
0 a61af66fc99e Initial load duke parents: diff changeset	489 assert(_ref->is_oop(), "Dropping a bad reference");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	490 oop_store_raw(_discovered_addr, NULL);
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	491
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	492 // First _prev_next ref actually points into DiscoveredList (gross).
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	493 oop new_next;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	494 if (_next == _ref) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	495 // At the end of the list, we should make _prev point to itself.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	496 // If _ref is the first ref, then _prev_next will be in the DiscoveredList,
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	497 // and _prev will be NULL.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	498 new_next = _prev;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	499 } else {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	500 new_next = _next;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	501 }
17748 d60ecdb2773e 8031703: Missing post-barrier in ReferenceProcessor pliden parents: 17746 diff changeset	502 // Remove Reference object from discovered list. Note that G1 does not need a
d60ecdb2773e 8031703: Missing post-barrier in ReferenceProcessor pliden parents: 17746 diff changeset	503 // pre-barrier here because we know the Reference has already been found/marked,
d60ecdb2773e 8031703: Missing post-barrier in ReferenceProcessor pliden parents: 17746 diff changeset	504 // that's how it ended up in the discovered list in the first place.
d60ecdb2773e 8031703: Missing post-barrier in ReferenceProcessor pliden parents: 17746 diff changeset	505 oop_store_raw(_prev_next, new_next);
0 a61af66fc99e Initial load duke parents: diff changeset	506 NOT_PRODUCT(_removed++);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	507 _refs_list.dec_length(1);
0 a61af66fc99e Initial load duke parents: diff changeset	508 }
a61af66fc99e Initial load duke parents: diff changeset	509
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	510 // Make the Reference object active again.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	511 void DiscoveredListIterator::make_active() {
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	512 // The pre barrier for G1 is probably just needed for the old
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	513 // reference processing behavior. Should we guard this with
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	514 // ReferenceProcessor::pending_list_uses_discovered_field() ?
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	515 if (UseG1GC) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	516 HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	517 if (UseCompressedOops) {
17746 a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	518 oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	519 } else {
17746 a258f8cb530f 8029255: G1: Reference processing should not enqueue references on the shared SATB queue pliden parents: 12316 diff changeset	520 oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	521 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	522 }
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	523 java_lang_ref_Reference::set_next_raw(_ref, NULL);
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	524 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	525
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	526 void DiscoveredListIterator::clear_referent() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	527 oop_store_raw(_referent_addr, NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	528 }
a61af66fc99e Initial load duke parents: diff changeset	529
a61af66fc99e Initial load duke parents: diff changeset	530 // NOTE: process_phase*() are largely similar, and at a high level
a61af66fc99e Initial load duke parents: diff changeset	531 // merely iterate over the extant list applying a predicate to
a61af66fc99e Initial load duke parents: diff changeset	532 // each of its elements and possibly removing that element from the
a61af66fc99e Initial load duke parents: diff changeset	533 // list and applying some further closures to that element.
a61af66fc99e Initial load duke parents: diff changeset	534 // We should consider the possibility of replacing these
a61af66fc99e Initial load duke parents: diff changeset	535 // process_phase*() methods by abstracting them into
a61af66fc99e Initial load duke parents: diff changeset	536 // a single general iterator invocation that receives appropriate
a61af66fc99e Initial load duke parents: diff changeset	537 // closures that accomplish this work.
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // (SoftReferences only) Traverse the list and remove any SoftReferences whose
a61af66fc99e Initial load duke parents: diff changeset	540 // referents are not alive, but that should be kept alive for policy reasons.
a61af66fc99e Initial load duke parents: diff changeset	541 // Keep alive the transitive closure of all such referents.
a61af66fc99e Initial load duke parents: diff changeset	542 void
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	543 ReferenceProcessor::process_phase1(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	544 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	545 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	546 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	547 VoidClosure* complete_gc) {
a61af66fc99e Initial load duke parents: diff changeset	548 assert(policy != NULL, "Must have a non-NULL policy");
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	549 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	550 // Decide which softly reachable refs should be kept alive.
a61af66fc99e Initial load duke parents: diff changeset	551 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	552 iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
a61af66fc99e Initial load duke parents: diff changeset	553 bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	554 if (referent_is_dead &&
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	555 !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
0 a61af66fc99e Initial load duke parents: diff changeset	556 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	557 gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	558 (void *)iter.obj(), iter.obj()->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	559 }
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	560 // Remove Reference object from list
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	561 iter.remove();
0 a61af66fc99e Initial load duke parents: diff changeset	562 // Make the Reference object active again
a61af66fc99e Initial load duke parents: diff changeset	563 iter.make_active();
a61af66fc99e Initial load duke parents: diff changeset	564 // keep the referent around
a61af66fc99e Initial load duke parents: diff changeset	565 iter.make_referent_alive();
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	566 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	567 } else {
a61af66fc99e Initial load duke parents: diff changeset	568 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	569 }
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571 // Close the reachable set
a61af66fc99e Initial load duke parents: diff changeset	572 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	573 NOT_PRODUCT(
a61af66fc99e Initial load duke parents: diff changeset	574 if (PrintGCDetails && TraceReferenceGC) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	575 gclog_or_tty->print_cr(" Dropped %d dead Refs out of %d "
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	576 "discovered Refs by policy, from list " INTPTR_FORMAT,
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	577 iter.removed(), iter.processed(), (address)refs_list.head());
0 a61af66fc99e Initial load duke parents: diff changeset	578 }
a61af66fc99e Initial load duke parents: diff changeset	579 )
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 // Traverse the list and remove any Refs that are not active, or
a61af66fc99e Initial load duke parents: diff changeset	583 // whose referents are either alive or NULL.
a61af66fc99e Initial load duke parents: diff changeset	584 void
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	585 ReferenceProcessor::pp2_work(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	586 BoolObjectClosure* is_alive,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	587 OopClosure* keep_alive) {
0 a61af66fc99e Initial load duke parents: diff changeset	588 assert(discovery_is_atomic(), "Error");
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	589 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	590 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	591 iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	592 DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	593 assert(next == NULL, "Should not discover inactive Reference");
0 a61af66fc99e Initial load duke parents: diff changeset	594 if (iter.is_referent_alive()) {
a61af66fc99e Initial load duke parents: diff changeset	595 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	596 gclog_or_tty->print_cr("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	597 (void *)iter.obj(), iter.obj()->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599 // The referent is reachable after all.
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	600 // Remove Reference object from list.
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	601 iter.remove();
0 a61af66fc99e Initial load duke parents: diff changeset	602 // Update the referent pointer as necessary: Note that this
a61af66fc99e Initial load duke parents: diff changeset	603 // should not entail any recursive marking because the
a61af66fc99e Initial load duke parents: diff changeset	604 // referent must already have been traversed.
a61af66fc99e Initial load duke parents: diff changeset	605 iter.make_referent_alive();
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	606 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	607 } else {
a61af66fc99e Initial load duke parents: diff changeset	608 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610 }
a61af66fc99e Initial load duke parents: diff changeset	611 NOT_PRODUCT(
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	612 if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	613 gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	614 "Refs in discovered list " INTPTR_FORMAT,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	615 iter.removed(), iter.processed(), (address)refs_list.head());
0 a61af66fc99e Initial load duke parents: diff changeset	616 }
a61af66fc99e Initial load duke parents: diff changeset	617 )
a61af66fc99e Initial load duke parents: diff changeset	618 }
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 void
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	621 ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList& refs_list,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	622 BoolObjectClosure* is_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	623 OopClosure* keep_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	624 VoidClosure* complete_gc) {
0 a61af66fc99e Initial load duke parents: diff changeset	625 assert(!discovery_is_atomic(), "Error");
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	626 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	627 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	628 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	629 HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	630 oop next = java_lang_ref_Reference::next(iter.obj());
0 a61af66fc99e Initial load duke parents: diff changeset	631 if ((iter.referent() == NULL \|\| iter.is_referent_alive() \|\|
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	632 next != NULL)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	633 assert(next->is_oop_or_null(), "bad next field");
0 a61af66fc99e Initial load duke parents: diff changeset	634 // Remove Reference object from list
a61af66fc99e Initial load duke parents: diff changeset	635 iter.remove();
a61af66fc99e Initial load duke parents: diff changeset	636 // Trace the cohorts
a61af66fc99e Initial load duke parents: diff changeset	637 iter.make_referent_alive();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	638 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	639 keep_alive->do_oop((narrowOop*)next_addr);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	640 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	641 keep_alive->do_oop((oop*)next_addr);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	642 }
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	643 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	644 } else {
a61af66fc99e Initial load duke parents: diff changeset	645 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	646 }
a61af66fc99e Initial load duke parents: diff changeset	647 }
a61af66fc99e Initial load duke parents: diff changeset	648 // Now close the newly reachable set
a61af66fc99e Initial load duke parents: diff changeset	649 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	650 NOT_PRODUCT(
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	651 if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	652 gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	653 "Refs in discovered list " INTPTR_FORMAT,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	654 iter.removed(), iter.processed(), (address)refs_list.head());
0 a61af66fc99e Initial load duke parents: diff changeset	655 }
a61af66fc99e Initial load duke parents: diff changeset	656 )
a61af66fc99e Initial load duke parents: diff changeset	657 }
a61af66fc99e Initial load duke parents: diff changeset	658
a61af66fc99e Initial load duke parents: diff changeset	659 // Traverse the list and process the referents, by either
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	660 // clearing them or keeping them (and their reachable
0 a61af66fc99e Initial load duke parents: diff changeset	661 // closure) alive.
a61af66fc99e Initial load duke parents: diff changeset	662 void
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	663 ReferenceProcessor::process_phase3(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	664 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	665 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	666 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	667 VoidClosure* complete_gc) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	668 ResourceMark rm;
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	669 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	670 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	671 iter.update_discovered();
a61af66fc99e Initial load duke parents: diff changeset	672 iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
a61af66fc99e Initial load duke parents: diff changeset	673 if (clear_referent) {
a61af66fc99e Initial load duke parents: diff changeset	674 // NULL out referent pointer
a61af66fc99e Initial load duke parents: diff changeset	675 iter.clear_referent();
a61af66fc99e Initial load duke parents: diff changeset	676 } else {
a61af66fc99e Initial load duke parents: diff changeset	677 // keep the referent around
a61af66fc99e Initial load duke parents: diff changeset	678 iter.make_referent_alive();
a61af66fc99e Initial load duke parents: diff changeset	679 }
a61af66fc99e Initial load duke parents: diff changeset	680 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	681 gclog_or_tty->print_cr("Adding %sreference (" INTPTR_FORMAT ": %s) as pending",
a61af66fc99e Initial load duke parents: diff changeset	682 clear_referent ? "cleared " : "",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	683 (void *)iter.obj(), iter.obj()->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	684 }
a61af66fc99e Initial load duke parents: diff changeset	685 assert(iter.obj()->is_oop(UseConcMarkSweepGC), "Adding a bad reference");
a61af66fc99e Initial load duke parents: diff changeset	686 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	687 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	688 // Remember to update the next pointer of the last ref.
0 a61af66fc99e Initial load duke parents: diff changeset	689 iter.update_discovered();
a61af66fc99e Initial load duke parents: diff changeset	690 // Close the reachable set
a61af66fc99e Initial load duke parents: diff changeset	691 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	692 }
a61af66fc99e Initial load duke parents: diff changeset	693
a61af66fc99e Initial load duke parents: diff changeset	694 void
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	695 ReferenceProcessor::clear_discovered_references(DiscoveredList& refs_list) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	696 oop obj = NULL;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	697 oop next = refs_list.head();
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	698 while (next != obj) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	699 obj = next;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	700 next = java_lang_ref_Reference::discovered(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	701 java_lang_ref_Reference::set_discovered_raw(obj, NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	702 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	703 refs_list.set_head(NULL);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	704 refs_list.set_length(0);
0 a61af66fc99e Initial load duke parents: diff changeset	705 }
a61af66fc99e Initial load duke parents: diff changeset	706
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	707 void
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	708 ReferenceProcessor::abandon_partial_discovered_list(DiscoveredList& refs_list) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	709 clear_discovered_references(refs_list);
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	710 }
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	711
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	712 void ReferenceProcessor::abandon_partial_discovery() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	713 // loop over the lists
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	714 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	715 if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	716 gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i));
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	717 }
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	718 abandon_partial_discovered_list(_discovered_refs[i]);
0 a61af66fc99e Initial load duke parents: diff changeset	719 }
a61af66fc99e Initial load duke parents: diff changeset	720 }
a61af66fc99e Initial load duke parents: diff changeset	721
a61af66fc99e Initial load duke parents: diff changeset	722 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	723 public:
a61af66fc99e Initial load duke parents: diff changeset	724 RefProcPhase1Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	725 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	726 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	727 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	728 : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
a61af66fc99e Initial load duke parents: diff changeset	729 _policy(policy)
a61af66fc99e Initial load duke parents: diff changeset	730 { }
a61af66fc99e Initial load duke parents: diff changeset	731 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	732 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	733 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	734 {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	735 Thread* thr = Thread::current();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	736 int refs_list_index = ((WorkerThread*)thr)->id();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	737 _ref_processor.process_phase1(_refs_lists[refs_list_index], _policy,
0 a61af66fc99e Initial load duke parents: diff changeset	738 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	739 }
a61af66fc99e Initial load duke parents: diff changeset	740 private:
a61af66fc99e Initial load duke parents: diff changeset	741 ReferencePolicy* _policy;
a61af66fc99e Initial load duke parents: diff changeset	742 };
a61af66fc99e Initial load duke parents: diff changeset	743
a61af66fc99e Initial load duke parents: diff changeset	744 class RefProcPhase2Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	745 public:
a61af66fc99e Initial load duke parents: diff changeset	746 RefProcPhase2Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	747 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	748 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	749 : ProcessTask(ref_processor, refs_lists, marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	750 { }
a61af66fc99e Initial load duke parents: diff changeset	751 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	752 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	753 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	754 {
a61af66fc99e Initial load duke parents: diff changeset	755 _ref_processor.process_phase2(_refs_lists[i],
a61af66fc99e Initial load duke parents: diff changeset	756 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	757 }
a61af66fc99e Initial load duke parents: diff changeset	758 };
a61af66fc99e Initial load duke parents: diff changeset	759
a61af66fc99e Initial load duke parents: diff changeset	760 class RefProcPhase3Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	761 public:
a61af66fc99e Initial load duke parents: diff changeset	762 RefProcPhase3Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	763 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	764 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	765 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	766 : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
a61af66fc99e Initial load duke parents: diff changeset	767 _clear_referent(clear_referent)
a61af66fc99e Initial load duke parents: diff changeset	768 { }
a61af66fc99e Initial load duke parents: diff changeset	769 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	770 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	771 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	772 {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	773 // Don't use "refs_list_index" calculated in this way because
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	774 // balance_queues() has moved the Ref's into the first n queues.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	775 // Thread* thr = Thread::current();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	776 // int refs_list_index = ((WorkerThread*)thr)->id();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	777 // _ref_processor.process_phase3(_refs_lists[refs_list_index], _clear_referent,
0 a61af66fc99e Initial load duke parents: diff changeset	778 _ref_processor.process_phase3(_refs_lists[i], _clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	779 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	780 }
a61af66fc99e Initial load duke parents: diff changeset	781 private:
a61af66fc99e Initial load duke parents: diff changeset	782 bool _clear_referent;
a61af66fc99e Initial load duke parents: diff changeset	783 };
a61af66fc99e Initial load duke parents: diff changeset	784
a61af66fc99e Initial load duke parents: diff changeset	785 // Balances reference queues.
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	786 // Move entries from all queues[0, 1, ..., _max_num_q-1] to
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	787 // queues[0, 1, ..., _num_q-1] because only the first _num_q
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	788 // corresponding to the active workers will be processed.
0 a61af66fc99e Initial load duke parents: diff changeset	789 void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])
a61af66fc99e Initial load duke parents: diff changeset	790 {
a61af66fc99e Initial load duke parents: diff changeset	791 // calculate total length
a61af66fc99e Initial load duke parents: diff changeset	792 size_t total_refs = 0;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	793 if (TraceReferenceGC && PrintGCDetails) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	794 gclog_or_tty->print_cr("\nBalance ref_lists ");
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	795 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	796
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	797 for (uint i = 0; i < _max_num_q; ++i) {
0 a61af66fc99e Initial load duke parents: diff changeset	798 total_refs += ref_lists[i].length();
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	799 if (TraceReferenceGC && PrintGCDetails) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	800 gclog_or_tty->print("%d ", ref_lists[i].length());
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	801 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	802 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	803 if (TraceReferenceGC && PrintGCDetails) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	804 gclog_or_tty->print_cr(" = %d", total_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	805 }
a61af66fc99e Initial load duke parents: diff changeset	806 size_t avg_refs = total_refs / _num_q + 1;
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	807 uint to_idx = 0;
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	808 for (uint from_idx = 0; from_idx < _max_num_q; from_idx++) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	809 bool move_all = false;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	810 if (from_idx >= _num_q) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	811 move_all = ref_lists[from_idx].length() > 0;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	812 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	813 while ((ref_lists[from_idx].length() > avg_refs) \|\|
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	814 move_all) {
0 a61af66fc99e Initial load duke parents: diff changeset	815 assert(to_idx < _num_q, "Sanity Check!");
a61af66fc99e Initial load duke parents: diff changeset	816 if (ref_lists[to_idx].length() < avg_refs) {
a61af66fc99e Initial load duke parents: diff changeset	817 // move superfluous refs
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	818 size_t refs_to_move;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	819 // Move all the Ref's if the from queue will not be processed.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	820 if (move_all) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	821 refs_to_move = MIN2(ref_lists[from_idx].length(),
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	822 avg_refs - ref_lists[to_idx].length());
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	823 } else {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	824 refs_to_move = MIN2(ref_lists[from_idx].length() - avg_refs,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	825 avg_refs - ref_lists[to_idx].length());
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	826 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	827
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	828 assert(refs_to_move > 0, "otherwise the code below will fail");
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	829
0 a61af66fc99e Initial load duke parents: diff changeset	830 oop move_head = ref_lists[from_idx].head();
a61af66fc99e Initial load duke parents: diff changeset	831 oop move_tail = move_head;
a61af66fc99e Initial load duke parents: diff changeset	832 oop new_head = move_head;
a61af66fc99e Initial load duke parents: diff changeset	833 // find an element to split the list on
a61af66fc99e Initial load duke parents: diff changeset	834 for (size_t j = 0; j < refs_to_move; ++j) {
a61af66fc99e Initial load duke parents: diff changeset	835 move_tail = new_head;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	836 new_head = java_lang_ref_Reference::discovered(new_head);
0 a61af66fc99e Initial load duke parents: diff changeset	837 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	838
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	839 // Add the chain to the to list.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	840 if (ref_lists[to_idx].head() == NULL) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	841 // to list is empty. Make a loop at the end.
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	842 java_lang_ref_Reference::set_discovered_raw(move_tail, move_tail);
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	843 } else {
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	844 java_lang_ref_Reference::set_discovered_raw(move_tail, ref_lists[to_idx].head());
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	845 }
0 a61af66fc99e Initial load duke parents: diff changeset	846 ref_lists[to_idx].set_head(move_head);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	847 ref_lists[to_idx].inc_length(refs_to_move);
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	848
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	849 // Remove the chain from the from list.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	850 if (move_tail == new_head) {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	851 // We found the end of the from list.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	852 ref_lists[from_idx].set_head(NULL);
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	853 } else {
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	854 ref_lists[from_idx].set_head(new_head);
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	855 }
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	856 ref_lists[from_idx].dec_length(refs_to_move);
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	857 if (ref_lists[from_idx].length() == 0) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	858 break;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	859 }
0 a61af66fc99e Initial load duke parents: diff changeset	860 } else {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	861 to_idx = (to_idx + 1) % _num_q;
0 a61af66fc99e Initial load duke parents: diff changeset	862 }
a61af66fc99e Initial load duke parents: diff changeset	863 }
a61af66fc99e Initial load duke parents: diff changeset	864 }
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	865 #ifdef ASSERT
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	866 size_t balanced_total_refs = 0;
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	867 for (uint i = 0; i < _max_num_q; ++i) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	868 balanced_total_refs += ref_lists[i].length();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	869 if (TraceReferenceGC && PrintGCDetails) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	870 gclog_or_tty->print("%d ", ref_lists[i].length());
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	871 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	872 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	873 if (TraceReferenceGC && PrintGCDetails) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	874 gclog_or_tty->print_cr(" = %d", balanced_total_refs);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	875 gclog_or_tty->flush();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	876 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	877 assert(total_refs == balanced_total_refs, "Balancing was incomplete");
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	878 #endif
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	879 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	880
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	881 void ReferenceProcessor::balance_all_queues() {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	882 balance_queues(_discoveredSoftRefs);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	883 balance_queues(_discoveredWeakRefs);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	884 balance_queues(_discoveredFinalRefs);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	885 balance_queues(_discoveredPhantomRefs);
0 a61af66fc99e Initial load duke parents: diff changeset	886 }
a61af66fc99e Initial load duke parents: diff changeset	887
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	888 size_t
0 a61af66fc99e Initial load duke parents: diff changeset	889 ReferenceProcessor::process_discovered_reflist(
a61af66fc99e Initial load duke parents: diff changeset	890 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	891 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	892 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	893 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	894 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	895 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	896 AbstractRefProcTaskExecutor* task_executor)
a61af66fc99e Initial load duke parents: diff changeset	897 {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	898 bool mt_processing = task_executor != NULL && _processing_is_mt;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	899 // If discovery used MT and a dynamic number of GC threads, then
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	900 // the queues must be balanced for correctness if fewer than the
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	901 // maximum number of queues were used. The number of queue used
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	902 // during discovery may be different than the number to be used
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	903 // for processing so don't depend of _num_q < _max_num_q as part
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	904 // of the test.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	905 bool must_balance = _discovery_is_mt;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	906
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	907 if ((mt_processing && ParallelRefProcBalancingEnabled) \|\|
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	908 must_balance) {
0 a61af66fc99e Initial load duke parents: diff changeset	909 balance_queues(refs_lists);
a61af66fc99e Initial load duke parents: diff changeset	910 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	911
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	912 size_t total_list_count = total_count(refs_lists);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	913
0 a61af66fc99e Initial load duke parents: diff changeset	914 if (PrintReferenceGC && PrintGCDetails) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	915 gclog_or_tty->print(", %u refs", total_list_count);
0 a61af66fc99e Initial load duke parents: diff changeset	916 }
a61af66fc99e Initial load duke parents: diff changeset	917
a61af66fc99e Initial load duke parents: diff changeset	918 // Phase 1 (soft refs only):
a61af66fc99e Initial load duke parents: diff changeset	919 // . Traverse the list and remove any SoftReferences whose
a61af66fc99e Initial load duke parents: diff changeset	920 // referents are not alive, but that should be kept alive for
a61af66fc99e Initial load duke parents: diff changeset	921 // policy reasons. Keep alive the transitive closure of all
a61af66fc99e Initial load duke parents: diff changeset	922 // such referents.
a61af66fc99e Initial load duke parents: diff changeset	923 if (policy != NULL) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	924 if (mt_processing) {
0 a61af66fc99e Initial load duke parents: diff changeset	925 RefProcPhase1Task phase1(this, refs_lists, policy, true /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	926 task_executor->execute(phase1);
a61af66fc99e Initial load duke parents: diff changeset	927 } else {
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	928 for (uint i = 0; i < _max_num_q; i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	929 process_phase1(refs_lists[i], policy,
a61af66fc99e Initial load duke parents: diff changeset	930 is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	931 }
a61af66fc99e Initial load duke parents: diff changeset	932 }
a61af66fc99e Initial load duke parents: diff changeset	933 } else { // policy == NULL
a61af66fc99e Initial load duke parents: diff changeset	934 assert(refs_lists != _discoveredSoftRefs,
a61af66fc99e Initial load duke parents: diff changeset	935 "Policy must be specified for soft references.");
a61af66fc99e Initial load duke parents: diff changeset	936 }
a61af66fc99e Initial load duke parents: diff changeset	937
a61af66fc99e Initial load duke parents: diff changeset	938 // Phase 2:
a61af66fc99e Initial load duke parents: diff changeset	939 // . Traverse the list and remove any refs whose referents are alive.
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	940 if (mt_processing) {
0 a61af66fc99e Initial load duke parents: diff changeset	941 RefProcPhase2Task phase2(this, refs_lists, !discovery_is_atomic() /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	942 task_executor->execute(phase2);
a61af66fc99e Initial load duke parents: diff changeset	943 } else {
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	944 for (uint i = 0; i < _max_num_q; i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	945 process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	946 }
a61af66fc99e Initial load duke parents: diff changeset	947 }
a61af66fc99e Initial load duke parents: diff changeset	948
a61af66fc99e Initial load duke parents: diff changeset	949 // Phase 3:
a61af66fc99e Initial load duke parents: diff changeset	950 // . Traverse the list and process referents as appropriate.
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	951 if (mt_processing) {
0 a61af66fc99e Initial load duke parents: diff changeset	952 RefProcPhase3Task phase3(this, refs_lists, clear_referent, true /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	953 task_executor->execute(phase3);
a61af66fc99e Initial load duke parents: diff changeset	954 } else {
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	955 for (uint i = 0; i < _max_num_q; i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	956 process_phase3(refs_lists[i], clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	957 is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	958 }
a61af66fc99e Initial load duke parents: diff changeset	959 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	960
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	961 return total_list_count;
0 a61af66fc99e Initial load duke parents: diff changeset	962 }
a61af66fc99e Initial load duke parents: diff changeset	963
a61af66fc99e Initial load duke parents: diff changeset	964 void ReferenceProcessor::clean_up_discovered_references() {
a61af66fc99e Initial load duke parents: diff changeset	965 // loop over the lists
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	966 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	967 if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
0 a61af66fc99e Initial load duke parents: diff changeset	968 gclog_or_tty->print_cr(
a61af66fc99e Initial load duke parents: diff changeset	969 "\nScrubbing %s discovered list of Null referents",
a61af66fc99e Initial load duke parents: diff changeset	970 list_name(i));
a61af66fc99e Initial load duke parents: diff changeset	971 }
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	972 clean_up_discovered_reflist(_discovered_refs[i]);
0 a61af66fc99e Initial load duke parents: diff changeset	973 }
a61af66fc99e Initial load duke parents: diff changeset	974 }
a61af66fc99e Initial load duke parents: diff changeset	975
a61af66fc99e Initial load duke parents: diff changeset	976 void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
a61af66fc99e Initial load duke parents: diff changeset	977 assert(!discovery_is_atomic(), "Else why call this method?");
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	978 DiscoveredListIterator iter(refs_list, NULL, NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	979 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	980 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	981 oop next = java_lang_ref_Reference::next(iter.obj());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	982 assert(next->is_oop_or_null(), "bad next field");
0 a61af66fc99e Initial load duke parents: diff changeset	983 // If referent has been cleared or Reference is not active,
a61af66fc99e Initial load duke parents: diff changeset	984 // drop it.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	985 if (iter.referent() == NULL \|\| next != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	986 debug_only(
a61af66fc99e Initial load duke parents: diff changeset	987 if (PrintGCDetails && TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	988 gclog_or_tty->print_cr("clean_up_discovered_list: Dropping Reference: "
a61af66fc99e Initial load duke parents: diff changeset	989 INTPTR_FORMAT " with next field: " INTPTR_FORMAT
a61af66fc99e Initial load duke parents: diff changeset	990 " and referent: " INTPTR_FORMAT,
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	991 (void )iter.obj(), (void )next, (void *)iter.referent());
0 a61af66fc99e Initial load duke parents: diff changeset	992 }
a61af66fc99e Initial load duke parents: diff changeset	993 )
a61af66fc99e Initial load duke parents: diff changeset	994 // Remove Reference object from list
a61af66fc99e Initial load duke parents: diff changeset	995 iter.remove();
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	996 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	997 } else {
a61af66fc99e Initial load duke parents: diff changeset	998 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	999 }
a61af66fc99e Initial load duke parents: diff changeset	1000 }
a61af66fc99e Initial load duke parents: diff changeset	1001 NOT_PRODUCT(
a61af66fc99e Initial load duke parents: diff changeset	1002 if (PrintGCDetails && TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	1003 gclog_or_tty->print(
a61af66fc99e Initial load duke parents: diff changeset	1004 " Removed %d Refs with NULL referents out of %d discovered Refs",
a61af66fc99e Initial load duke parents: diff changeset	1005 iter.removed(), iter.processed());
a61af66fc99e Initial load duke parents: diff changeset	1006 }
a61af66fc99e Initial load duke parents: diff changeset	1007 )
a61af66fc99e Initial load duke parents: diff changeset	1008 }
a61af66fc99e Initial load duke parents: diff changeset	1009
a61af66fc99e Initial load duke parents: diff changeset	1010 inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt) {
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1011 uint id = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	1012 // Determine the queue index to use for this object.
a61af66fc99e Initial load duke parents: diff changeset	1013 if (_discovery_is_mt) {
a61af66fc99e Initial load duke parents: diff changeset	1014 // During a multi-threaded discovery phase,
a61af66fc99e Initial load duke parents: diff changeset	1015 // each thread saves to its "own" list.
a61af66fc99e Initial load duke parents: diff changeset	1016 Thread* thr = Thread::current();
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1017 id = thr->as_Worker_thread()->id();
0 a61af66fc99e Initial load duke parents: diff changeset	1018 } else {
a61af66fc99e Initial load duke parents: diff changeset	1019 // single-threaded discovery, we save in round-robin
a61af66fc99e Initial load duke parents: diff changeset	1020 // fashion to each of the lists.
a61af66fc99e Initial load duke parents: diff changeset	1021 if (_processing_is_mt) {
a61af66fc99e Initial load duke parents: diff changeset	1022 id = next_id();
a61af66fc99e Initial load duke parents: diff changeset	1023 }
a61af66fc99e Initial load duke parents: diff changeset	1024 }
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1025 assert(0 <= id && id < _max_num_q, "Id is out-of-bounds (call Freud?)");
0 a61af66fc99e Initial load duke parents: diff changeset	1026
a61af66fc99e Initial load duke parents: diff changeset	1027 // Get the discovered queue to which we will add
a61af66fc99e Initial load duke parents: diff changeset	1028 DiscoveredList* list = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1029 switch (rt) {
a61af66fc99e Initial load duke parents: diff changeset	1030 case REF_OTHER:
a61af66fc99e Initial load duke parents: diff changeset	1031 // Unknown reference type, no special treatment
a61af66fc99e Initial load duke parents: diff changeset	1032 break;
a61af66fc99e Initial load duke parents: diff changeset	1033 case REF_SOFT:
a61af66fc99e Initial load duke parents: diff changeset	1034 list = &_discoveredSoftRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	1035 break;
a61af66fc99e Initial load duke parents: diff changeset	1036 case REF_WEAK:
a61af66fc99e Initial load duke parents: diff changeset	1037 list = &_discoveredWeakRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	1038 break;
a61af66fc99e Initial load duke parents: diff changeset	1039 case REF_FINAL:
a61af66fc99e Initial load duke parents: diff changeset	1040 list = &_discoveredFinalRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	1041 break;
a61af66fc99e Initial load duke parents: diff changeset	1042 case REF_PHANTOM:
a61af66fc99e Initial load duke parents: diff changeset	1043 list = &_discoveredPhantomRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	1044 break;
a61af66fc99e Initial load duke parents: diff changeset	1045 case REF_NONE:
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	1046 // we should not reach here if we are an InstanceRefKlass
0 a61af66fc99e Initial load duke parents: diff changeset	1047 default:
a61af66fc99e Initial load duke parents: diff changeset	1048 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1049 }
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1050 if (TraceReferenceGC && PrintGCDetails) {
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1051 gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, list);
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1052 }
0 a61af66fc99e Initial load duke parents: diff changeset	1053 return list;
a61af66fc99e Initial load duke parents: diff changeset	1054 }
a61af66fc99e Initial load duke parents: diff changeset	1055
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1056 inline void
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1057 ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1058 oop obj,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1059 HeapWord* discovered_addr) {
0 a61af66fc99e Initial load duke parents: diff changeset	1060 assert(_discovery_is_mt, "!_discovery_is_mt should have been handled by caller");
a61af66fc99e Initial load duke parents: diff changeset	1061 // First we must make sure this object is only enqueued once. CAS in a non null
a61af66fc99e Initial load duke parents: diff changeset	1062 // discovered_addr.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1063 oop current_head = refs_list.head();
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1064 // The last ref must have its discovered field pointing to itself.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1065 oop next_discovered = (current_head != NULL) ? current_head : obj;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1066
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1067 oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1068 NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1069 if (retest == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1070 // This thread just won the right to enqueue the object.
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1071 // We have separate lists for enqueueing, so no synchronization
0 a61af66fc99e Initial load duke parents: diff changeset	1072 // is necessary.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1073 refs_list.set_head(obj);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1074 refs_list.inc_length(1);
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1075
fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1076 if (TraceReferenceGC) {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1077 gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1078 (void *)obj, obj->klass()->internal_name());
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1079 }
0 a61af66fc99e Initial load duke parents: diff changeset	1080 } else {
a61af66fc99e Initial load duke parents: diff changeset	1081 // If retest was non NULL, another thread beat us to it:
a61af66fc99e Initial load duke parents: diff changeset	1082 // The reference has already been discovered...
a61af66fc99e Initial load duke parents: diff changeset	1083 if (TraceReferenceGC) {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1084 gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1085 (void *)obj, obj->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	1086 }
a61af66fc99e Initial load duke parents: diff changeset	1087 }
a61af66fc99e Initial load duke parents: diff changeset	1088 }
a61af66fc99e Initial load duke parents: diff changeset	1089
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1090 #ifndef PRODUCT
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1091 // Non-atomic (i.e. concurrent) discovery might allow us
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1092 // to observe j.l.References with NULL referents, being those
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1093 // cleared concurrently by mutators during (or after) discovery.
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1094 void ReferenceProcessor::verify_referent(oop obj) {
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1095 bool da = discovery_is_atomic();
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1096 oop referent = java_lang_ref_Reference::referent(obj);
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1097 assert(da ? referent->is_oop() : referent->is_oop_or_null(),
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1098 err_msg("Bad referent " INTPTR_FORMAT " found in Reference "
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1099 INTPTR_FORMAT " during %satomic discovery ",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1100 (void )referent, (void )obj, da ? "" : "non-"));
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1101 }
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1102 #endif
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1103
0 a61af66fc99e Initial load duke parents: diff changeset	1104 // We mention two of several possible choices here:
a61af66fc99e Initial load duke parents: diff changeset	1105 // #0: if the reference object is not in the "originating generation"
a61af66fc99e Initial load duke parents: diff changeset	1106 // (or part of the heap being collected, indicated by our "span"
a61af66fc99e Initial load duke parents: diff changeset	1107 // we don't treat it specially (i.e. we scan it as we would
a61af66fc99e Initial load duke parents: diff changeset	1108 // a normal oop, treating its references as strong references).
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1109 // This means that references can't be discovered unless their
0 a61af66fc99e Initial load duke parents: diff changeset	1110 // referent is also in the same span. This is the simplest,
a61af66fc99e Initial load duke parents: diff changeset	1111 // most "local" and most conservative approach, albeit one
a61af66fc99e Initial load duke parents: diff changeset	1112 // that may cause weak references to be enqueued least promptly.
a61af66fc99e Initial load duke parents: diff changeset	1113 // We call this choice the "ReferenceBasedDiscovery" policy.
a61af66fc99e Initial load duke parents: diff changeset	1114 // #1: the reference object may be in any generation (span), but if
a61af66fc99e Initial load duke parents: diff changeset	1115 // the referent is in the generation (span) being currently collected
a61af66fc99e Initial load duke parents: diff changeset	1116 // then we can discover the reference object, provided
a61af66fc99e Initial load duke parents: diff changeset	1117 // the object has not already been discovered by
a61af66fc99e Initial load duke parents: diff changeset	1118 // a different concurrently running collector (as may be the
a61af66fc99e Initial load duke parents: diff changeset	1119 // case, for instance, if the reference object is in CMS and
a61af66fc99e Initial load duke parents: diff changeset	1120 // the referent in DefNewGeneration), and provided the processing
a61af66fc99e Initial load duke parents: diff changeset	1121 // of this reference object by the current collector will
a61af66fc99e Initial load duke parents: diff changeset	1122 // appear atomic to every other collector in the system.
a61af66fc99e Initial load duke parents: diff changeset	1123 // (Thus, for instance, a concurrent collector may not
a61af66fc99e Initial load duke parents: diff changeset	1124 // discover references in other generations even if the
a61af66fc99e Initial load duke parents: diff changeset	1125 // referent is in its own generation). This policy may,
a61af66fc99e Initial load duke parents: diff changeset	1126 // in certain cases, enqueue references somewhat sooner than
a61af66fc99e Initial load duke parents: diff changeset	1127 // might Policy #0 above, but at marginally increased cost
a61af66fc99e Initial load duke parents: diff changeset	1128 // and complexity in processing these references.
a61af66fc99e Initial load duke parents: diff changeset	1129 // We call this choice the "RefeferentBasedDiscovery" policy.
a61af66fc99e Initial load duke parents: diff changeset	1130 bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1131 // Make sure we are discovering refs (rather than processing discovered refs).
0 a61af66fc99e Initial load duke parents: diff changeset	1132 if (!_discovering_refs \|\| !RegisterReferences) {
a61af66fc99e Initial load duke parents: diff changeset	1133 return false;
a61af66fc99e Initial load duke parents: diff changeset	1134 }
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1135 // We only discover active references.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1136 oop next = java_lang_ref_Reference::next(obj);
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1137 if (next != NULL) { // Ref is no longer active
0 a61af66fc99e Initial load duke parents: diff changeset	1138 return false;
a61af66fc99e Initial load duke parents: diff changeset	1139 }
a61af66fc99e Initial load duke parents: diff changeset	1140
a61af66fc99e Initial load duke parents: diff changeset	1141 HeapWord* obj_addr = (HeapWord*)obj;
a61af66fc99e Initial load duke parents: diff changeset	1142 if (RefDiscoveryPolicy == ReferenceBasedDiscovery &&
a61af66fc99e Initial load duke parents: diff changeset	1143 !_span.contains(obj_addr)) {
a61af66fc99e Initial load duke parents: diff changeset	1144 // Reference is not in the originating generation;
a61af66fc99e Initial load duke parents: diff changeset	1145 // don't treat it specially (i.e. we want to scan it as a normal
a61af66fc99e Initial load duke parents: diff changeset	1146 // object with strong references).
a61af66fc99e Initial load duke parents: diff changeset	1147 return false;
a61af66fc99e Initial load duke parents: diff changeset	1148 }
a61af66fc99e Initial load duke parents: diff changeset	1149
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1150 // We only discover references whose referents are not (yet)
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1151 // known to be strongly reachable.
0 a61af66fc99e Initial load duke parents: diff changeset	1152 if (is_alive_non_header() != NULL) {
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1153 verify_referent(obj);
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1154 if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {
0 a61af66fc99e Initial load duke parents: diff changeset	1155 return false; // referent is reachable
a61af66fc99e Initial load duke parents: diff changeset	1156 }
a61af66fc99e Initial load duke parents: diff changeset	1157 }
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1158 if (rt == REF_SOFT) {
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1159 // For soft refs we can decide now if these are not
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1160 // current candidates for clearing, in which case we
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1161 // can mark through them now, rather than delaying that
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1162 // to the reference-processing phase. Since all current
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1163 // time-stamp policies advance the soft-ref clock only
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1164 // at a major collection cycle, this is always currently
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1165 // accurate.
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	1166 if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) {
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1167 return false;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1168 }
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 452 diff changeset	1169 }
0 a61af66fc99e Initial load duke parents: diff changeset	1170
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	1171 ResourceMark rm; // Needed for tracing.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	1172
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1173 HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1174 const oop discovered = java_lang_ref_Reference::discovered(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1175 assert(discovered->is_oop_or_null(), "bad discovered field");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1176 if (discovered != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1177 // The reference has already been discovered...
a61af66fc99e Initial load duke parents: diff changeset	1178 if (TraceReferenceGC) {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1179 gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1180 (void *)obj, obj->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	1181 }
a61af66fc99e Initial load duke parents: diff changeset	1182 if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
a61af66fc99e Initial load duke parents: diff changeset	1183 // assumes that an object is not processed twice;
a61af66fc99e Initial load duke parents: diff changeset	1184 // if it's been already discovered it must be on another
a61af66fc99e Initial load duke parents: diff changeset	1185 // generation's discovered list; so we won't discover it.
a61af66fc99e Initial load duke parents: diff changeset	1186 return false;
a61af66fc99e Initial load duke parents: diff changeset	1187 } else {
a61af66fc99e Initial load duke parents: diff changeset	1188 assert(RefDiscoveryPolicy == ReferenceBasedDiscovery,
a61af66fc99e Initial load duke parents: diff changeset	1189 "Unrecognized policy");
a61af66fc99e Initial load duke parents: diff changeset	1190 // Check assumption that an object is not potentially
a61af66fc99e Initial load duke parents: diff changeset	1191 // discovered twice except by concurrent collectors that potentially
a61af66fc99e Initial load duke parents: diff changeset	1192 // trace the same Reference object twice.
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1193 assert(UseConcMarkSweepGC \|\| UseG1GC,
fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1194 "Only possible with a concurrent marking collector");
0 a61af66fc99e Initial load duke parents: diff changeset	1195 return true;
a61af66fc99e Initial load duke parents: diff changeset	1196 }
a61af66fc99e Initial load duke parents: diff changeset	1197 }
a61af66fc99e Initial load duke parents: diff changeset	1198
a61af66fc99e Initial load duke parents: diff changeset	1199 if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1200 verify_referent(obj);
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1201 // Discover if and only if EITHER:
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1202 // .. reference is in our span, OR
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1203 // .. we are an atomic collector and referent is in our span
0 a61af66fc99e Initial load duke parents: diff changeset	1204 if (_span.contains(obj_addr) \|\|
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1205 (discovery_is_atomic() &&
8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1206 _span.contains(java_lang_ref_Reference::referent(obj)))) {
0 a61af66fc99e Initial load duke parents: diff changeset	1207 // should_enqueue = true;
a61af66fc99e Initial load duke parents: diff changeset	1208 } else {
a61af66fc99e Initial load duke parents: diff changeset	1209 return false;
a61af66fc99e Initial load duke parents: diff changeset	1210 }
a61af66fc99e Initial load duke parents: diff changeset	1211 } else {
a61af66fc99e Initial load duke parents: diff changeset	1212 assert(RefDiscoveryPolicy == ReferenceBasedDiscovery &&
a61af66fc99e Initial load duke parents: diff changeset	1213 _span.contains(obj_addr), "code inconsistency");
a61af66fc99e Initial load duke parents: diff changeset	1214 }
a61af66fc99e Initial load duke parents: diff changeset	1215
a61af66fc99e Initial load duke parents: diff changeset	1216 // Get the right type of discovered queue head.
a61af66fc99e Initial load duke parents: diff changeset	1217 DiscoveredList* list = get_discovered_list(rt);
a61af66fc99e Initial load duke parents: diff changeset	1218 if (list == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1219 return false; // nothing special needs to be done
a61af66fc99e Initial load duke parents: diff changeset	1220 }
a61af66fc99e Initial load duke parents: diff changeset	1221
a61af66fc99e Initial load duke parents: diff changeset	1222 if (_discovery_is_mt) {
a61af66fc99e Initial load duke parents: diff changeset	1223 add_to_discovered_list_mt(*list, obj, discovered_addr);
a61af66fc99e Initial load duke parents: diff changeset	1224 } else {
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	1225 // We do a raw store here: the field will be visited later when processing
8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	1226 // the discovered references.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1227 oop current_head = list->head();
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1228 // The last ref must have its discovered field pointing to itself.
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1229 oop next_discovered = (current_head != NULL) ? current_head : obj;
c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1230
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1231 assert(discovered == NULL, "control point invariant");
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1232 oop_store_raw(discovered_addr, next_discovered);
0 a61af66fc99e Initial load duke parents: diff changeset	1233 list->set_head(obj);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1234 list->inc_length(1);
0 a61af66fc99e Initial load duke parents: diff changeset	1235
1974 fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent johnc parents: 1972 diff changeset	1236 if (TraceReferenceGC) {
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1237 gclog_or_tty->print_cr("Discovered reference (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1238 (void *)obj, obj->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	1239 }
a61af66fc99e Initial load duke parents: diff changeset	1240 }
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	1241 assert(obj->is_oop(), "Discovered a bad reference");
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1974 diff changeset	1242 verify_referent(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	1243 return true;
a61af66fc99e Initial load duke parents: diff changeset	1244 }
a61af66fc99e Initial load duke parents: diff changeset	1245
a61af66fc99e Initial load duke parents: diff changeset	1246 // Preclean the discovered references by removing those
a61af66fc99e Initial load duke parents: diff changeset	1247 // whose referents are alive, and by marking from those that
a61af66fc99e Initial load duke parents: diff changeset	1248 // are not active. These lists can be handled here
a61af66fc99e Initial load duke parents: diff changeset	1249 // in any order and, indeed, concurrently.
a61af66fc99e Initial load duke parents: diff changeset	1250 void ReferenceProcessor::preclean_discovered_references(
a61af66fc99e Initial load duke parents: diff changeset	1251 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1252 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	1253 VoidClosure* complete_gc,
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	1254 YieldClosure* yield,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1255 GCTimer* gc_timer,
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1256 GCId gc_id) {
0 a61af66fc99e Initial load duke parents: diff changeset	1257
a61af66fc99e Initial load duke parents: diff changeset	1258 NOT_PRODUCT(verify_ok_to_handle_reflists());
a61af66fc99e Initial load duke parents: diff changeset	1259
a61af66fc99e Initial load duke parents: diff changeset	1260 // Soft references
a61af66fc99e Initial load duke parents: diff changeset	1261 {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	1262 GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1263 false, gc_timer, gc_id);
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1264 for (uint i = 0; i < _max_num_q; i++) {
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1265 if (yield->should_return()) {
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1266 return;
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1267 }
0 a61af66fc99e Initial load duke parents: diff changeset	1268 preclean_discovered_reflist(_discoveredSoftRefs[i], is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1269 keep_alive, complete_gc, yield);
a61af66fc99e Initial load duke parents: diff changeset	1270 }
a61af66fc99e Initial load duke parents: diff changeset	1271 }
a61af66fc99e Initial load duke parents: diff changeset	1272
a61af66fc99e Initial load duke parents: diff changeset	1273 // Weak references
a61af66fc99e Initial load duke parents: diff changeset	1274 {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	1275 GCTraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1276 false, gc_timer, gc_id);
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1277 for (uint i = 0; i < _max_num_q; i++) {
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1278 if (yield->should_return()) {
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1279 return;
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1280 }
0 a61af66fc99e Initial load duke parents: diff changeset	1281 preclean_discovered_reflist(_discoveredWeakRefs[i], is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1282 keep_alive, complete_gc, yield);
a61af66fc99e Initial load duke parents: diff changeset	1283 }
a61af66fc99e Initial load duke parents: diff changeset	1284 }
a61af66fc99e Initial load duke parents: diff changeset	1285
a61af66fc99e Initial load duke parents: diff changeset	1286 // Final references
a61af66fc99e Initial load duke parents: diff changeset	1287 {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	1288 GCTraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1289 false, gc_timer, gc_id);
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1290 for (uint i = 0; i < _max_num_q; i++) {
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1291 if (yield->should_return()) {
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1292 return;
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1293 }
0 a61af66fc99e Initial load duke parents: diff changeset	1294 preclean_discovered_reflist(_discoveredFinalRefs[i], is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1295 keep_alive, complete_gc, yield);
a61af66fc99e Initial load duke parents: diff changeset	1296 }
a61af66fc99e Initial load duke parents: diff changeset	1297 }
a61af66fc99e Initial load duke parents: diff changeset	1298
a61af66fc99e Initial load duke parents: diff changeset	1299 // Phantom references
a61af66fc99e Initial load duke parents: diff changeset	1300 {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10327 diff changeset	1301 GCTraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	1302 false, gc_timer, gc_id);
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1303 for (uint i = 0; i < _max_num_q; i++) {
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1304 if (yield->should_return()) {
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1305 return;
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1306 }
0 a61af66fc99e Initial load duke parents: diff changeset	1307 preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1308 keep_alive, complete_gc, yield);
a61af66fc99e Initial load duke parents: diff changeset	1309 }
a61af66fc99e Initial load duke parents: diff changeset	1310 }
a61af66fc99e Initial load duke parents: diff changeset	1311 }
a61af66fc99e Initial load duke parents: diff changeset	1312
a61af66fc99e Initial load duke parents: diff changeset	1313 // Walk the given discovered ref list, and remove all reference objects
a61af66fc99e Initial load duke parents: diff changeset	1314 // whose referents are still alive, whose referents are NULL or which
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1315 // are not active (have a non-NULL next field). NOTE: When we are
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1316 // thus precleaning the ref lists (which happens single-threaded today),
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1317 // we do not disable refs discovery to honour the correct semantics of
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1318 // java.lang.Reference. As a result, we need to be careful below
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1319 // that ref removal steps interleave safely with ref discovery steps
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1320 // (in this thread).
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1321 void
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1322 ReferenceProcessor::preclean_discovered_reflist(DiscoveredList& refs_list,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1323 BoolObjectClosure* is_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1324 OopClosure* keep_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1325 VoidClosure* complete_gc,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1326 YieldClosure* yield) {
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17937 diff changeset	1327 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	1328 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	1329 iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1330 oop obj = iter.obj();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1331 oop next = java_lang_ref_Reference::next(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	1332 if (iter.referent() == NULL \|\| iter.is_referent_alive() \|\|
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1333 next != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1334 // The referent has been cleared, or is alive, or the Reference is not
a61af66fc99e Initial load duke parents: diff changeset	1335 // active; we need to trace and mark its cohort.
a61af66fc99e Initial load duke parents: diff changeset	1336 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	1337 gclog_or_tty->print_cr("Precleaning Reference (" INTPTR_FORMAT ": %s)",
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 10405 diff changeset	1338 (void *)iter.obj(), iter.obj()->klass()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	1339 }
a61af66fc99e Initial load duke parents: diff changeset	1340 // Remove Reference object from list
a61af66fc99e Initial load duke parents: diff changeset	1341 iter.remove();
a61af66fc99e Initial load duke parents: diff changeset	1342 // Keep alive its cohort.
a61af66fc99e Initial load duke parents: diff changeset	1343 iter.make_referent_alive();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1344 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1345 narrowOop* next_addr = (narrowOop*)java_lang_ref_Reference::next_addr(obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1346 keep_alive->do_oop(next_addr);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1347 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1348 oop* next_addr = (oop*)java_lang_ref_Reference::next_addr(obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1349 keep_alive->do_oop(next_addr);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1350 }
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1351 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	1352 } else {
a61af66fc99e Initial load duke parents: diff changeset	1353 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	1354 }
a61af66fc99e Initial load duke parents: diff changeset	1355 }
a61af66fc99e Initial load duke parents: diff changeset	1356 // Close the reachable set
a61af66fc99e Initial load duke parents: diff changeset	1357 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	1358
a61af66fc99e Initial load duke parents: diff changeset	1359 NOT_PRODUCT(
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	1360 if (PrintGCDetails && PrintReferenceGC && (iter.processed() > 0)) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1361 gclog_or_tty->print_cr(" Dropped %d Refs out of %d "
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1362 "Refs in discovered list " INTPTR_FORMAT,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1363 iter.removed(), iter.processed(), (address)refs_list.head());
0 a61af66fc99e Initial load duke parents: diff changeset	1364 }
a61af66fc99e Initial load duke parents: diff changeset	1365 )
a61af66fc99e Initial load duke parents: diff changeset	1366 }
a61af66fc99e Initial load duke parents: diff changeset	1367
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1368 const char* ReferenceProcessor::list_name(uint i) {
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	1369 assert(i >= 0 && i <= _max_num_q * number_of_subclasses_of_ref(),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	1370 "Out of bounds index");
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	1371
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	1372 int j = i / _max_num_q;
0 a61af66fc99e Initial load duke parents: diff changeset	1373 switch (j) {
a61af66fc99e Initial load duke parents: diff changeset	1374 case 0: return "SoftRef";
a61af66fc99e Initial load duke parents: diff changeset	1375 case 1: return "WeakRef";
a61af66fc99e Initial load duke parents: diff changeset	1376 case 2: return "FinalRef";
a61af66fc99e Initial load duke parents: diff changeset	1377 case 3: return "PhantomRef";
a61af66fc99e Initial load duke parents: diff changeset	1378 }
a61af66fc99e Initial load duke parents: diff changeset	1379 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1380 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1381 }
a61af66fc99e Initial load duke parents: diff changeset	1382
a61af66fc99e Initial load duke parents: diff changeset	1383 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1384 void ReferenceProcessor::verify_ok_to_handle_reflists() {
a61af66fc99e Initial load duke parents: diff changeset	1385 // empty for now
a61af66fc99e Initial load duke parents: diff changeset	1386 }
a61af66fc99e Initial load duke parents: diff changeset	1387 #endif
a61af66fc99e Initial load duke parents: diff changeset	1388
a61af66fc99e Initial load duke parents: diff changeset	1389 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1390 void ReferenceProcessor::clear_discovered_references() {
a61af66fc99e Initial load duke parents: diff changeset	1391 guarantee(!_discovering_refs, "Discovering refs?");
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4712 diff changeset	1392 for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	1393 clear_discovered_references(_discovered_refs[i]);
0 a61af66fc99e Initial load duke parents: diff changeset	1394 }
a61af66fc99e Initial load duke parents: diff changeset	1395 }
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	1396
0 a61af66fc99e Initial load duke parents: diff changeset	1397 #endif // PRODUCT

Mercurial > hg > truffle

annotate src/share/vm/memory/referenceProcessor.cpp @ 20543:e7d0505c8a30