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

annotate src/share/vm/memory/referenceProcessor.cpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp

author	ysr
date	Tue, 07 Dec 2010 21:55:53 -0800
parents	fd1d227ef1b9
children	8df09fb45352

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

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/referenceProcessor.cpp @ 1994:6cd6d394f280