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

annotate src/share/vm/memory/referenceProcessor.cpp @ 1721:413ad0331a0c

6977924: Changes for 6975078 produce build error with certain gcc versions Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error. Reviewed-by: jcoomes, ysr, phh

author	johnc
date	Wed, 18 Aug 2010 10:59:06 -0700
parents	c18cbe5936b8
children	8b10f48633dc

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	2 * Copyright (c) 2001, 2009, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1190 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
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(
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 935 diff changeset	74 SystemDictionary::Reference_klass())->
113 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);
457 27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy() ysr parents: 453 diff changeset	118 rp->setup_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>
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 935 diff changeset	302 bool enqueue_discovered_ref_helper(ReferenceProcessor* ref,
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 935 diff changeset	303 AbstractRefProcTaskExecutor* task_executor) {
113 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 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	725 }
a61af66fc99e Initial load duke parents: diff changeset	726 // Remember to keep sentinel pointer around
a61af66fc99e Initial load duke parents: diff changeset	727 iter.update_discovered();
a61af66fc99e Initial load duke parents: diff changeset	728 // Close the reachable set
a61af66fc99e Initial load duke parents: diff changeset	729 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	730 }
a61af66fc99e Initial load duke parents: diff changeset	731
a61af66fc99e Initial load duke parents: diff changeset	732 void
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	733 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	734 oop obj = refs_list.head();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	735 while (obj != sentinel_ref()) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	736 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	737 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	738 obj = discovered;
0 a61af66fc99e Initial load duke parents: diff changeset	739 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	740 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	741 refs_list.set_length(0);
0 a61af66fc99e Initial load duke parents: diff changeset	742 }
a61af66fc99e Initial load duke parents: diff changeset	743
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	744 void ReferenceProcessor::abandon_partial_discovery() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	745 // loop over the lists
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	746 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	747 if (TraceReferenceGC && PrintGCDetails && ((i % _num_q) == 0)) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	748 gclog_or_tty->print_cr(
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	749 "\nAbandoning %s discovered list",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	750 list_name(i));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	751 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	752 abandon_partial_discovered_list(_discoveredSoftRefs[i]);
0 a61af66fc99e Initial load duke parents: diff changeset	753 }
a61af66fc99e Initial load duke parents: diff changeset	754 }
a61af66fc99e Initial load duke parents: diff changeset	755
a61af66fc99e Initial load duke parents: diff changeset	756 class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	757 public:
a61af66fc99e Initial load duke parents: diff changeset	758 RefProcPhase1Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	759 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	760 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	761 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	762 : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
a61af66fc99e Initial load duke parents: diff changeset	763 _policy(policy)
a61af66fc99e Initial load duke parents: diff changeset	764 { }
a61af66fc99e Initial load duke parents: diff changeset	765 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	766 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	767 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	768 {
a61af66fc99e Initial load duke parents: diff changeset	769 _ref_processor.process_phase1(_refs_lists[i], _policy,
a61af66fc99e Initial load duke parents: diff changeset	770 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	771 }
a61af66fc99e Initial load duke parents: diff changeset	772 private:
a61af66fc99e Initial load duke parents: diff changeset	773 ReferencePolicy* _policy;
a61af66fc99e Initial load duke parents: diff changeset	774 };
a61af66fc99e Initial load duke parents: diff changeset	775
a61af66fc99e Initial load duke parents: diff changeset	776 class RefProcPhase2Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	777 public:
a61af66fc99e Initial load duke parents: diff changeset	778 RefProcPhase2Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	779 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	780 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	781 : ProcessTask(ref_processor, refs_lists, marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	782 { }
a61af66fc99e Initial load duke parents: diff changeset	783 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	784 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	785 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	786 {
a61af66fc99e Initial load duke parents: diff changeset	787 _ref_processor.process_phase2(_refs_lists[i],
a61af66fc99e Initial load duke parents: diff changeset	788 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	789 }
a61af66fc99e Initial load duke parents: diff changeset	790 };
a61af66fc99e Initial load duke parents: diff changeset	791
a61af66fc99e Initial load duke parents: diff changeset	792 class RefProcPhase3Task: public AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	793 public:
a61af66fc99e Initial load duke parents: diff changeset	794 RefProcPhase3Task(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	795 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	796 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	797 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	798 : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
a61af66fc99e Initial load duke parents: diff changeset	799 _clear_referent(clear_referent)
a61af66fc99e Initial load duke parents: diff changeset	800 { }
a61af66fc99e Initial load duke parents: diff changeset	801 virtual void work(unsigned int i, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	802 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	803 VoidClosure& complete_gc)
a61af66fc99e Initial load duke parents: diff changeset	804 {
a61af66fc99e Initial load duke parents: diff changeset	805 _ref_processor.process_phase3(_refs_lists[i], _clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	806 &is_alive, &keep_alive, &complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	807 }
a61af66fc99e Initial load duke parents: diff changeset	808 private:
a61af66fc99e Initial load duke parents: diff changeset	809 bool _clear_referent;
a61af66fc99e Initial load duke parents: diff changeset	810 };
a61af66fc99e Initial load duke parents: diff changeset	811
a61af66fc99e Initial load duke parents: diff changeset	812 // Balances reference queues.
a61af66fc99e Initial load duke parents: diff changeset	813 void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])
a61af66fc99e Initial load duke parents: diff changeset	814 {
a61af66fc99e Initial load duke parents: diff changeset	815 // calculate total length
a61af66fc99e Initial load duke parents: diff changeset	816 size_t total_refs = 0;
a61af66fc99e Initial load duke parents: diff changeset	817 for (int i = 0; i < _num_q; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	818 total_refs += ref_lists[i].length();
a61af66fc99e Initial load duke parents: diff changeset	819 }
a61af66fc99e Initial load duke parents: diff changeset	820 size_t avg_refs = total_refs / _num_q + 1;
a61af66fc99e Initial load duke parents: diff changeset	821 int to_idx = 0;
a61af66fc99e Initial load duke parents: diff changeset	822 for (int from_idx = 0; from_idx < _num_q; from_idx++) {
a61af66fc99e Initial load duke parents: diff changeset	823 while (ref_lists[from_idx].length() > avg_refs) {
a61af66fc99e Initial load duke parents: diff changeset	824 assert(to_idx < _num_q, "Sanity Check!");
a61af66fc99e Initial load duke parents: diff changeset	825 if (ref_lists[to_idx].length() < avg_refs) {
a61af66fc99e Initial load duke parents: diff changeset	826 // move superfluous refs
a61af66fc99e Initial load duke parents: diff changeset	827 size_t refs_to_move =
a61af66fc99e Initial load duke parents: diff changeset	828 MIN2(ref_lists[from_idx].length() - avg_refs,
a61af66fc99e Initial load duke parents: diff changeset	829 avg_refs - ref_lists[to_idx].length());
a61af66fc99e Initial load duke parents: diff changeset	830 oop move_head = ref_lists[from_idx].head();
a61af66fc99e Initial load duke parents: diff changeset	831 oop move_tail = move_head;
a61af66fc99e Initial load duke parents: diff changeset	832 oop new_head = move_head;
a61af66fc99e Initial load duke parents: diff changeset	833 // find an element to split the list on
a61af66fc99e Initial load duke parents: diff changeset	834 for (size_t j = 0; j < refs_to_move; ++j) {
a61af66fc99e Initial load duke parents: diff changeset	835 move_tail = new_head;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	836 new_head = java_lang_ref_Reference::discovered(new_head);
0 a61af66fc99e Initial load duke parents: diff changeset	837 }
a61af66fc99e Initial load duke parents: diff changeset	838 java_lang_ref_Reference::set_discovered(move_tail, ref_lists[to_idx].head());
a61af66fc99e Initial load duke parents: diff changeset	839 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	840 ref_lists[to_idx].inc_length(refs_to_move);
0 a61af66fc99e Initial load duke parents: diff changeset	841 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	842 ref_lists[from_idx].dec_length(refs_to_move);
0 a61af66fc99e Initial load duke parents: diff changeset	843 } else {
a61af66fc99e Initial load duke parents: diff changeset	844 ++to_idx;
a61af66fc99e Initial load duke parents: diff changeset	845 }
a61af66fc99e Initial load duke parents: diff changeset	846 }
a61af66fc99e Initial load duke parents: diff changeset	847 }
a61af66fc99e Initial load duke parents: diff changeset	848 }
a61af66fc99e Initial load duke parents: diff changeset	849
a61af66fc99e Initial load duke parents: diff changeset	850 void
a61af66fc99e Initial load duke parents: diff changeset	851 ReferenceProcessor::process_discovered_reflist(
a61af66fc99e Initial load duke parents: diff changeset	852 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	853 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	854 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	855 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	856 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	857 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	858 AbstractRefProcTaskExecutor* task_executor)
a61af66fc99e Initial load duke parents: diff changeset	859 {
a61af66fc99e Initial load duke parents: diff changeset	860 bool mt = task_executor != NULL && _processing_is_mt;
a61af66fc99e Initial load duke parents: diff changeset	861 if (mt && ParallelRefProcBalancingEnabled) {
a61af66fc99e Initial load duke parents: diff changeset	862 balance_queues(refs_lists);
a61af66fc99e Initial load duke parents: diff changeset	863 }
a61af66fc99e Initial load duke parents: diff changeset	864 if (PrintReferenceGC && PrintGCDetails) {
a61af66fc99e Initial load duke parents: diff changeset	865 size_t total = 0;
a61af66fc99e Initial load duke parents: diff changeset	866 for (int i = 0; i < _num_q; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	867 total += refs_lists[i].length();
a61af66fc99e Initial load duke parents: diff changeset	868 }
a61af66fc99e Initial load duke parents: diff changeset	869 gclog_or_tty->print(", %u refs", total);
a61af66fc99e Initial load duke parents: diff changeset	870 }
a61af66fc99e Initial load duke parents: diff changeset	871
a61af66fc99e Initial load duke parents: diff changeset	872 // Phase 1 (soft refs only):
a61af66fc99e Initial load duke parents: diff changeset	873 // . Traverse the list and remove any SoftReferences whose
a61af66fc99e Initial load duke parents: diff changeset	874 // referents are not alive, but that should be kept alive for
a61af66fc99e Initial load duke parents: diff changeset	875 // policy reasons. Keep alive the transitive closure of all
a61af66fc99e Initial load duke parents: diff changeset	876 // such referents.
a61af66fc99e Initial load duke parents: diff changeset	877 if (policy != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	878 if (mt) {
a61af66fc99e Initial load duke parents: diff changeset	879 RefProcPhase1Task phase1(this, refs_lists, policy, true /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	880 task_executor->execute(phase1);
a61af66fc99e Initial load duke parents: diff changeset	881 } else {
a61af66fc99e Initial load duke parents: diff changeset	882 for (int i = 0; i < _num_q; i++) {
a61af66fc99e Initial load duke parents: diff changeset	883 process_phase1(refs_lists[i], policy,
a61af66fc99e Initial load duke parents: diff changeset	884 is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	885 }
a61af66fc99e Initial load duke parents: diff changeset	886 }
a61af66fc99e Initial load duke parents: diff changeset	887 } else { // policy == NULL
a61af66fc99e Initial load duke parents: diff changeset	888 assert(refs_lists != _discoveredSoftRefs,
a61af66fc99e Initial load duke parents: diff changeset	889 "Policy must be specified for soft references.");
a61af66fc99e Initial load duke parents: diff changeset	890 }
a61af66fc99e Initial load duke parents: diff changeset	891
a61af66fc99e Initial load duke parents: diff changeset	892 // Phase 2:
a61af66fc99e Initial load duke parents: diff changeset	893 // . Traverse the list and remove any refs whose referents are alive.
a61af66fc99e Initial load duke parents: diff changeset	894 if (mt) {
a61af66fc99e Initial load duke parents: diff changeset	895 RefProcPhase2Task phase2(this, refs_lists, !discovery_is_atomic() /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	896 task_executor->execute(phase2);
a61af66fc99e Initial load duke parents: diff changeset	897 } else {
a61af66fc99e Initial load duke parents: diff changeset	898 for (int i = 0; i < _num_q; i++) {
a61af66fc99e Initial load duke parents: diff changeset	899 process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	900 }
a61af66fc99e Initial load duke parents: diff changeset	901 }
a61af66fc99e Initial load duke parents: diff changeset	902
a61af66fc99e Initial load duke parents: diff changeset	903 // Phase 3:
a61af66fc99e Initial load duke parents: diff changeset	904 // . Traverse the list and process referents as appropriate.
a61af66fc99e Initial load duke parents: diff changeset	905 if (mt) {
a61af66fc99e Initial load duke parents: diff changeset	906 RefProcPhase3Task phase3(this, refs_lists, clear_referent, true /marks_oops_alive*/);
a61af66fc99e Initial load duke parents: diff changeset	907 task_executor->execute(phase3);
a61af66fc99e Initial load duke parents: diff changeset	908 } else {
a61af66fc99e Initial load duke parents: diff changeset	909 for (int i = 0; i < _num_q; i++) {
a61af66fc99e Initial load duke parents: diff changeset	910 process_phase3(refs_lists[i], clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	911 is_alive, keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	912 }
a61af66fc99e Initial load duke parents: diff changeset	913 }
a61af66fc99e Initial load duke parents: diff changeset	914 }
a61af66fc99e Initial load duke parents: diff changeset	915
a61af66fc99e Initial load duke parents: diff changeset	916 void ReferenceProcessor::clean_up_discovered_references() {
a61af66fc99e Initial load duke parents: diff changeset	917 // loop over the lists
a61af66fc99e Initial load duke parents: diff changeset	918 for (int i = 0; i < _num_q * subclasses_of_ref; i++) {
a61af66fc99e Initial load duke parents: diff changeset	919 if (TraceReferenceGC && PrintGCDetails && ((i % _num_q) == 0)) {
a61af66fc99e Initial load duke parents: diff changeset	920 gclog_or_tty->print_cr(
a61af66fc99e Initial load duke parents: diff changeset	921 "\nScrubbing %s discovered list of Null referents",
a61af66fc99e Initial load duke parents: diff changeset	922 list_name(i));
a61af66fc99e Initial load duke parents: diff changeset	923 }
a61af66fc99e Initial load duke parents: diff changeset	924 clean_up_discovered_reflist(_discoveredSoftRefs[i]);
a61af66fc99e Initial load duke parents: diff changeset	925 }
a61af66fc99e Initial load duke parents: diff changeset	926 }
a61af66fc99e Initial load duke parents: diff changeset	927
a61af66fc99e Initial load duke parents: diff changeset	928 void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
a61af66fc99e Initial load duke parents: diff changeset	929 assert(!discovery_is_atomic(), "Else why call this method?");
a61af66fc99e Initial load duke parents: diff changeset	930 DiscoveredListIterator iter(refs_list, NULL, NULL);
a61af66fc99e Initial load duke parents: diff changeset	931 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	932 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	933 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	934 assert(next->is_oop_or_null(), "bad next field");
0 a61af66fc99e Initial load duke parents: diff changeset	935 // If referent has been cleared or Reference is not active,
a61af66fc99e Initial load duke parents: diff changeset	936 // drop it.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	937 if (iter.referent() == NULL \|\| next != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	938 debug_only(
a61af66fc99e Initial load duke parents: diff changeset	939 if (PrintGCDetails && TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	940 gclog_or_tty->print_cr("clean_up_discovered_list: Dropping Reference: "
a61af66fc99e Initial load duke parents: diff changeset	941 INTPTR_FORMAT " with next field: " INTPTR_FORMAT
a61af66fc99e Initial load duke parents: diff changeset	942 " and referent: " INTPTR_FORMAT,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	943 iter.obj(), next, iter.referent());
0 a61af66fc99e Initial load duke parents: diff changeset	944 }
a61af66fc99e Initial load duke parents: diff changeset	945 )
a61af66fc99e Initial load duke parents: diff changeset	946 // Remove Reference object from list
a61af66fc99e Initial load duke parents: diff changeset	947 iter.remove();
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	948 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	949 } else {
a61af66fc99e Initial load duke parents: diff changeset	950 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	951 }
a61af66fc99e Initial load duke parents: diff changeset	952 }
a61af66fc99e Initial load duke parents: diff changeset	953 NOT_PRODUCT(
a61af66fc99e Initial load duke parents: diff changeset	954 if (PrintGCDetails && TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	955 gclog_or_tty->print(
a61af66fc99e Initial load duke parents: diff changeset	956 " Removed %d Refs with NULL referents out of %d discovered Refs",
a61af66fc99e Initial load duke parents: diff changeset	957 iter.removed(), iter.processed());
a61af66fc99e Initial load duke parents: diff changeset	958 }
a61af66fc99e Initial load duke parents: diff changeset	959 )
a61af66fc99e Initial load duke parents: diff changeset	960 }
a61af66fc99e Initial load duke parents: diff changeset	961
a61af66fc99e Initial load duke parents: diff changeset	962 inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt) {
a61af66fc99e Initial load duke parents: diff changeset	963 int id = 0;
a61af66fc99e Initial load duke parents: diff changeset	964 // Determine the queue index to use for this object.
a61af66fc99e Initial load duke parents: diff changeset	965 if (_discovery_is_mt) {
a61af66fc99e Initial load duke parents: diff changeset	966 // During a multi-threaded discovery phase,
a61af66fc99e Initial load duke parents: diff changeset	967 // each thread saves to its "own" list.
a61af66fc99e Initial load duke parents: diff changeset	968 Thread* thr = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	969 assert(thr->is_GC_task_thread(),
a61af66fc99e Initial load duke parents: diff changeset	970 "Dubious cast from Thread* to WorkerThread*?");
a61af66fc99e Initial load duke parents: diff changeset	971 id = ((WorkerThread*)thr)->id();
a61af66fc99e Initial load duke parents: diff changeset	972 } else {
a61af66fc99e Initial load duke parents: diff changeset	973 // single-threaded discovery, we save in round-robin
a61af66fc99e Initial load duke parents: diff changeset	974 // fashion to each of the lists.
a61af66fc99e Initial load duke parents: diff changeset	975 if (_processing_is_mt) {
a61af66fc99e Initial load duke parents: diff changeset	976 id = next_id();
a61af66fc99e Initial load duke parents: diff changeset	977 }
a61af66fc99e Initial load duke parents: diff changeset	978 }
a61af66fc99e Initial load duke parents: diff changeset	979 assert(0 <= id && id < _num_q, "Id is out-of-bounds (call Freud?)");
a61af66fc99e Initial load duke parents: diff changeset	980
a61af66fc99e Initial load duke parents: diff changeset	981 // Get the discovered queue to which we will add
a61af66fc99e Initial load duke parents: diff changeset	982 DiscoveredList* list = NULL;
a61af66fc99e Initial load duke parents: diff changeset	983 switch (rt) {
a61af66fc99e Initial load duke parents: diff changeset	984 case REF_OTHER:
a61af66fc99e Initial load duke parents: diff changeset	985 // Unknown reference type, no special treatment
a61af66fc99e Initial load duke parents: diff changeset	986 break;
a61af66fc99e Initial load duke parents: diff changeset	987 case REF_SOFT:
a61af66fc99e Initial load duke parents: diff changeset	988 list = &_discoveredSoftRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	989 break;
a61af66fc99e Initial load duke parents: diff changeset	990 case REF_WEAK:
a61af66fc99e Initial load duke parents: diff changeset	991 list = &_discoveredWeakRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	992 break;
a61af66fc99e Initial load duke parents: diff changeset	993 case REF_FINAL:
a61af66fc99e Initial load duke parents: diff changeset	994 list = &_discoveredFinalRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	995 break;
a61af66fc99e Initial load duke parents: diff changeset	996 case REF_PHANTOM:
a61af66fc99e Initial load duke parents: diff changeset	997 list = &_discoveredPhantomRefs[id];
a61af66fc99e Initial load duke parents: diff changeset	998 break;
a61af66fc99e Initial load duke parents: diff changeset	999 case REF_NONE:
a61af66fc99e Initial load duke parents: diff changeset	1000 // we should not reach here if we are an instanceRefKlass
a61af66fc99e Initial load duke parents: diff changeset	1001 default:
a61af66fc99e Initial load duke parents: diff changeset	1002 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1003 }
a61af66fc99e Initial load duke parents: diff changeset	1004 return list;
a61af66fc99e Initial load duke parents: diff changeset	1005 }
a61af66fc99e Initial load duke parents: diff changeset	1006
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1007 inline void
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1008 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	1009 oop obj,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1010 HeapWord* discovered_addr) {
0 a61af66fc99e Initial load duke parents: diff changeset	1011 assert(_discovery_is_mt, "!_discovery_is_mt should have been handled by caller");
a61af66fc99e Initial load duke parents: diff changeset	1012 // First we must make sure this object is only enqueued once. CAS in a non null
a61af66fc99e Initial load duke parents: diff changeset	1013 // discovered_addr.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1014 oop current_head = refs_list.head();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1015
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1016 // Note: In the case of G1, this specific pre-barrier is strictly
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1017 // not necessary because the only case we are interested in
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1018 // here is when *discovered_addr is NULL (see the CAS further below),
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1019 // so this will expand to nothing. As a result, we have manually
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1020 // elided this out for G1, but left in the test for some future
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1021 // collector that might have need for a pre-barrier here.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1022 if (_discovered_list_needs_barrier && !UseG1GC) {
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1023 if (UseCompressedOops) {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1024 _bs->write_ref_field_pre((narrowOop*)discovered_addr, current_head);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1025 } else {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1026 _bs->write_ref_field_pre((oop*)discovered_addr, current_head);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1027 }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1028 guarantee(false, "Need to check non-G1 collector");
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1029 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1030 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	1031 NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1032 if (retest == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1033 // This thread just won the right to enqueue the object.
a61af66fc99e Initial load duke parents: diff changeset	1034 // We have separate lists for enqueueing so no synchronization
a61af66fc99e Initial load duke parents: diff changeset	1035 // is necessary.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1036 refs_list.set_head(obj);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1037 refs_list.inc_length(1);
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1038 if (_discovered_list_needs_barrier) {
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1039 _bs->write_ref_field((void*)discovered_addr, current_head);
342 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
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1186 if (UseCompressedOops) {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1187 _bs->write_ref_field_pre((narrowOop*)discovered_addr, current_head);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1188 } else {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1189 _bs->write_ref_field_pre((oop*)discovered_addr, current_head);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1190 }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1191 guarantee(false, "Need to check non-G1 collector");
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1192 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1193 oop_store_raw(discovered_addr, current_head);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1194 if (_discovered_list_needs_barrier) {
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	1195 _bs->write_ref_field((void*)discovered_addr, current_head);
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	1196 }
0 a61af66fc99e Initial load duke parents: diff changeset	1197 list->set_head(obj);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1198 list->inc_length(1);
0 a61af66fc99e Initial load duke parents: diff changeset	1199 }
a61af66fc99e Initial load duke parents: diff changeset	1200
a61af66fc99e Initial load duke parents: diff changeset	1201 // In the MT discovery case, it is currently possible to see
a61af66fc99e Initial load duke parents: diff changeset	1202 // the following message multiple times if several threads
a61af66fc99e Initial load duke parents: diff changeset	1203 // discover a reference about the same time. Only one will
a61af66fc99e Initial load duke parents: diff changeset	1204 // however have actually added it to the disocvered queue.
a61af66fc99e Initial load duke parents: diff changeset	1205 // One could let add_to_discovered_list_mt() return an
a61af66fc99e Initial load duke parents: diff changeset	1206 // indication for success in queueing (by 1 thread) or
a61af66fc99e Initial load duke parents: diff changeset	1207 // failure (by all other threads), but I decided the extra
a61af66fc99e Initial load duke parents: diff changeset	1208 // code was not worth the effort for something that is
a61af66fc99e Initial load duke parents: diff changeset	1209 // only used for debugging support.
a61af66fc99e Initial load duke parents: diff changeset	1210 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	1211 oop referent = java_lang_ref_Reference::referent(obj);
a61af66fc99e Initial load duke parents: diff changeset	1212 if (PrintGCDetails) {
a61af66fc99e Initial load duke parents: diff changeset	1213 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	1214 obj, obj->blueprint()->internal_name());
0 a61af66fc99e Initial load duke parents: diff changeset	1215 }
a61af66fc99e Initial load duke parents: diff changeset	1216 assert(referent->is_oop(), "Enqueued a bad referent");
a61af66fc99e Initial load duke parents: diff changeset	1217 }
a61af66fc99e Initial load duke parents: diff changeset	1218 assert(obj->is_oop(), "Enqueued a bad reference");
a61af66fc99e Initial load duke parents: diff changeset	1219 return true;
a61af66fc99e Initial load duke parents: diff changeset	1220 }
a61af66fc99e Initial load duke parents: diff changeset	1221
a61af66fc99e Initial load duke parents: diff changeset	1222 // Preclean the discovered references by removing those
a61af66fc99e Initial load duke parents: diff changeset	1223 // whose referents are alive, and by marking from those that
a61af66fc99e Initial load duke parents: diff changeset	1224 // are not active. These lists can be handled here
a61af66fc99e Initial load duke parents: diff changeset	1225 // in any order and, indeed, concurrently.
a61af66fc99e Initial load duke parents: diff changeset	1226 void ReferenceProcessor::preclean_discovered_references(
a61af66fc99e Initial load duke parents: diff changeset	1227 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1228 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	1229 VoidClosure* complete_gc,
1190 4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 1144 diff changeset	1230 YieldClosure* yield,
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 1144 diff changeset	1231 bool should_unload_classes) {
0 a61af66fc99e Initial load duke parents: diff changeset	1232
a61af66fc99e Initial load duke parents: diff changeset	1233 NOT_PRODUCT(verify_ok_to_handle_reflists());
a61af66fc99e Initial load duke parents: diff changeset	1234
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 845 diff changeset	1235 #ifdef ASSERT
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 845 diff changeset	1236 bool must_remember_klasses = ClassUnloading && !UseConcMarkSweepGC \|\|
1190 4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 1144 diff changeset	1237 CMSClassUnloadingEnabled && UseConcMarkSweepGC \|\|
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 1144 diff changeset	1238 ExplicitGCInvokesConcurrentAndUnloadsClasses &&
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 1144 diff changeset	1239 UseConcMarkSweepGC && should_unload_classes;
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 845 diff changeset	1240 RememberKlassesChecker mx(must_remember_klasses);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 845 diff changeset	1241 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1242 // Soft references
a61af66fc99e Initial load duke parents: diff changeset	1243 {
a61af66fc99e Initial load duke parents: diff changeset	1244 TraceTime tt("Preclean SoftReferences", 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(_discoveredSoftRefs[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 // Weak references
a61af66fc99e Initial load duke parents: diff changeset	1256 {
a61af66fc99e Initial load duke parents: diff changeset	1257 TraceTime tt("Preclean WeakReferences", 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(_discoveredWeakRefs[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 // Final references
a61af66fc99e Initial load duke parents: diff changeset	1269 {
a61af66fc99e Initial load duke parents: diff changeset	1270 TraceTime tt("Preclean FinalReferences", 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(_discoveredFinalRefs[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 // Phantom references
a61af66fc99e Initial load duke parents: diff changeset	1282 {
a61af66fc99e Initial load duke parents: diff changeset	1283 TraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
a61af66fc99e Initial load duke parents: diff changeset	1284 false, gclog_or_tty);
a61af66fc99e Initial load duke parents: diff changeset	1285 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	1286 if (yield->should_return()) {
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1287 return;
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1288 }
0 a61af66fc99e Initial load duke parents: diff changeset	1289 preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,
a61af66fc99e Initial load duke parents: diff changeset	1290 keep_alive, complete_gc, yield);
a61af66fc99e Initial load duke parents: diff changeset	1291 }
a61af66fc99e Initial load duke parents: diff changeset	1292 }
a61af66fc99e Initial load duke parents: diff changeset	1293 }
a61af66fc99e Initial load duke parents: diff changeset	1294
a61af66fc99e Initial load duke parents: diff changeset	1295 // Walk the given discovered ref list, and remove all reference objects
a61af66fc99e Initial load duke parents: diff changeset	1296 // 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	1297 // 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	1298 // 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	1299 // 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	1300 // 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	1301 // 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	1302 // (in this thread).
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1303 void
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1304 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	1305 BoolObjectClosure* is_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1306 OopClosure* keep_alive,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1307 VoidClosure* complete_gc,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1308 YieldClosure* yield) {
0 a61af66fc99e Initial load duke parents: diff changeset	1309 DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
a61af66fc99e Initial load duke parents: diff changeset	1310 while (iter.has_next()) {
a61af66fc99e Initial load duke parents: diff changeset	1311 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	1312 oop obj = iter.obj();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1313 oop next = java_lang_ref_Reference::next(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	1314 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	1315 next != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1316 // The referent has been cleared, or is alive, or the Reference is not
a61af66fc99e Initial load duke parents: diff changeset	1317 // active; we need to trace and mark its cohort.
a61af66fc99e Initial load duke parents: diff changeset	1318 if (TraceReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	1319 gclog_or_tty->print_cr("Precleaning Reference (" INTPTR_FORMAT ": %s)",
a61af66fc99e Initial load duke parents: diff changeset	1320 iter.obj(), iter.obj()->blueprint()->internal_name());
a61af66fc99e Initial load duke parents: diff changeset	1321 }
a61af66fc99e Initial load duke parents: diff changeset	1322 // Remove Reference object from list
a61af66fc99e Initial load duke parents: diff changeset	1323 iter.remove();
a61af66fc99e Initial load duke parents: diff changeset	1324 // Keep alive its cohort.
a61af66fc99e Initial load duke parents: diff changeset	1325 iter.make_referent_alive();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1326 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1327 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	1328 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	1329 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1330 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	1331 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	1332 }
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 356 diff changeset	1333 iter.move_to_next();
0 a61af66fc99e Initial load duke parents: diff changeset	1334 } else {
a61af66fc99e Initial load duke parents: diff changeset	1335 iter.next();
a61af66fc99e Initial load duke parents: diff changeset	1336 }
a61af66fc99e Initial load duke parents: diff changeset	1337 }
a61af66fc99e Initial load duke parents: diff changeset	1338 // Close the reachable set
a61af66fc99e Initial load duke parents: diff changeset	1339 complete_gc->do_void();
a61af66fc99e Initial load duke parents: diff changeset	1340
a61af66fc99e Initial load duke parents: diff changeset	1341 NOT_PRODUCT(
a61af66fc99e Initial load duke parents: diff changeset	1342 if (PrintGCDetails && PrintReferenceGC) {
a61af66fc99e Initial load duke parents: diff changeset	1343 gclog_or_tty->print(" Dropped %d Refs out of %d "
a61af66fc99e Initial load duke parents: diff changeset	1344 "Refs in discovered list ", iter.removed(), iter.processed());
a61af66fc99e Initial load duke parents: diff changeset	1345 }
a61af66fc99e Initial load duke parents: diff changeset	1346 )
a61af66fc99e Initial load duke parents: diff changeset	1347 }
a61af66fc99e Initial load duke parents: diff changeset	1348
a61af66fc99e Initial load duke parents: diff changeset	1349 const char* ReferenceProcessor::list_name(int i) {
a61af66fc99e Initial load duke parents: diff changeset	1350 assert(i >= 0 && i <= _num_q * subclasses_of_ref, "Out of bounds index");
a61af66fc99e Initial load duke parents: diff changeset	1351 int j = i / _num_q;
a61af66fc99e Initial load duke parents: diff changeset	1352 switch (j) {
a61af66fc99e Initial load duke parents: diff changeset	1353 case 0: return "SoftRef";
a61af66fc99e Initial load duke parents: diff changeset	1354 case 1: return "WeakRef";
a61af66fc99e Initial load duke parents: diff changeset	1355 case 2: return "FinalRef";
a61af66fc99e Initial load duke parents: diff changeset	1356 case 3: return "PhantomRef";
a61af66fc99e Initial load duke parents: diff changeset	1357 }
a61af66fc99e Initial load duke parents: diff changeset	1358 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1359 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1360 }
a61af66fc99e Initial load duke parents: diff changeset	1361
a61af66fc99e Initial load duke parents: diff changeset	1362 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1363 void ReferenceProcessor::verify_ok_to_handle_reflists() {
a61af66fc99e Initial load duke parents: diff changeset	1364 // empty for now
a61af66fc99e Initial load duke parents: diff changeset	1365 }
a61af66fc99e Initial load duke parents: diff changeset	1366 #endif
a61af66fc99e Initial load duke parents: diff changeset	1367
a61af66fc99e Initial load duke parents: diff changeset	1368 void ReferenceProcessor::verify() {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1369 guarantee(sentinel_ref() != NULL && sentinel_ref()->is_oop(), "Lost _sentinelRef");
0 a61af66fc99e Initial load duke parents: diff changeset	1370 }
a61af66fc99e Initial load duke parents: diff changeset	1371
a61af66fc99e Initial load duke parents: diff changeset	1372 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1373 void ReferenceProcessor::clear_discovered_references() {
a61af66fc99e Initial load duke parents: diff changeset	1374 guarantee(!_discovering_refs, "Discovering refs?");
a61af66fc99e Initial load duke parents: diff changeset	1375 for (int i = 0; i < _num_q * subclasses_of_ref; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1376 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	1377 while (obj != sentinel_ref()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1378 oop next = java_lang_ref_Reference::discovered(obj);
a61af66fc99e Initial load duke parents: diff changeset	1379 java_lang_ref_Reference::set_discovered(obj, (oop) NULL);
a61af66fc99e Initial load duke parents: diff changeset	1380 obj = next;
a61af66fc99e Initial load duke parents: diff changeset	1381 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 5 diff changeset	1382 _discoveredSoftRefs[i].set_head(sentinel_ref());
0 a61af66fc99e Initial load duke parents: diff changeset	1383 _discoveredSoftRefs[i].set_length(0);
a61af66fc99e Initial load duke parents: diff changeset	1384 }
a61af66fc99e Initial load duke parents: diff changeset	1385 }
a61af66fc99e Initial load duke parents: diff changeset	1386 #endif // PRODUCT

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/referenceProcessor.cpp @ 1721:413ad0331a0c