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

annotate src/share/vm/memory/referenceProcessor.cpp @ 453:c96030fff130

6684579: SoftReference processing can be made more efficient Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not. Reviewed-by: jmasa

author	ysr
date	Thu, 20 Nov 2008 16:56:09 -0800
parents	00b023ae2d78
children	27a80744a83b

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

Mercurial > hg > truffle

annotate src/share/vm/memory/referenceProcessor.cpp @ 453:c96030fff130