graal-jvmci-8: src/share/vm/memory/referenceProcessor.cpp annotate

annotate src/share/vm/memory/referenceProcessor.cpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank

author	ysr
date	Wed, 07 Sep 2011 13:55:42 -0700
parents	c2bf0120ee5d
children	4dfb2df418f2

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

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/referenceProcessor.cpp @ 3917:eca1193ca245