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

annotate src/share/vm/memory/referenceProcessor.cpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	4dfb2df418f2
children	bf2d2b8b1726

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

Mercurial > hg > truffle

annotate src/share/vm/memory/referenceProcessor.cpp @ 3992:d1bdeef3e3e2