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

annotate src/share/vm/memory/referenceProcessor.cpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes

author	ysr
date	Thu, 20 Nov 2008 12:27:41 -0800
parents	1ee8caae33af
children	c96030fff130

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

Mercurial > hg > truffle

annotate src/share/vm/memory/referenceProcessor.cpp @ 452:00b023ae2d78