graal-compiler: src/share/vm/memory/referenceProcessor.hpp annotate

annotate src/share/vm/memory/referenceProcessor.hpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	4dfb2df418f2
children	bf2d2b8b1726

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1244 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1244 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: 1244 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	25 #ifndef SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	26 #define SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	28 #include "memory/referencePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	29 #include "oops/instanceRefKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	30
0 a61af66fc99e Initial load duke parents: diff changeset	31 // ReferenceProcessor class encapsulates the per-"collector" processing
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	32 // of java.lang.Reference objects for GC. The interface is useful for supporting
0 a61af66fc99e Initial load duke parents: diff changeset	33 // a generational abstraction, in particular when there are multiple
a61af66fc99e Initial load duke parents: diff changeset	34 // generations that are being independently collected -- possibly
a61af66fc99e Initial load duke parents: diff changeset	35 // concurrently and/or incrementally. Note, however, that the
a61af66fc99e Initial load duke parents: diff changeset	36 // ReferenceProcessor class abstracts away from a generational setting
a61af66fc99e Initial load duke parents: diff changeset	37 // by using only a heap interval (called "span" below), thus allowing
a61af66fc99e Initial load duke parents: diff changeset	38 // its use in a straightforward manner in a general, non-generational
a61af66fc99e Initial load duke parents: diff changeset	39 // setting.
a61af66fc99e Initial load duke parents: diff changeset	40 //
a61af66fc99e Initial load duke parents: diff changeset	41 // The basic idea is that each ReferenceProcessor object concerns
a61af66fc99e Initial load duke parents: diff changeset	42 // itself with ("weak") reference processing in a specific "span"
a61af66fc99e Initial load duke parents: diff changeset	43 // of the heap of interest to a specific collector. Currently,
a61af66fc99e Initial load duke parents: diff changeset	44 // the span is a convex interval of the heap, but, efficiency
a61af66fc99e Initial load duke parents: diff changeset	45 // apart, there seems to be no reason it couldn't be extended
a61af66fc99e Initial load duke parents: diff changeset	46 // (with appropriate modifications) to any "non-convex interval".
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 // forward references
a61af66fc99e Initial load duke parents: diff changeset	49 class ReferencePolicy;
a61af66fc99e Initial load duke parents: diff changeset	50 class AbstractRefProcTaskExecutor;
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	51
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	52 // List of discovered references.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	53 class DiscoveredList {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	54 public:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	55 DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	56 oop head() const {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	57 return UseCompressedOops ? oopDesc::decode_heap_oop(_compressed_head) :
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	58 _oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	59 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	60 HeapWord* adr_head() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	61 return UseCompressedOops ? (HeapWord*)&_compressed_head :
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	62 (HeapWord*)&_oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	63 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	64 void set_head(oop o) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	65 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	66 // Must compress the head ptr.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	67 _compressed_head = oopDesc::encode_heap_oop(o);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	68 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	69 _oop_head = o;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	70 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	71 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	72 bool is_empty() const { return head() == NULL; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	73 size_t length() { return _len; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	74 void set_length(size_t len) { _len = len; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	75 void inc_length(size_t inc) { _len += inc; assert(_len > 0, "Error"); }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	76 void dec_length(size_t dec) { _len -= dec; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	77 private:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	78 // Set value depending on UseCompressedOops. This could be a template class
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	79 // but then we have to fix all the instantiations and declarations that use this class.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	80 oop _oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	81 narrowOop _compressed_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	82 size_t _len;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	83 };
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	84
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	85 // Iterator for the list of discovered references.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	86 class DiscoveredListIterator {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	87 private:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	88 DiscoveredList& _refs_list;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	89 HeapWord* _prev_next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	90 oop _prev;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	91 oop _ref;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	92 HeapWord* _discovered_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	93 oop _next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	94 HeapWord* _referent_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	95 oop _referent;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	96 OopClosure* _keep_alive;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	97 BoolObjectClosure* _is_alive;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	98
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	99 DEBUG_ONLY(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	100 oop _first_seen; // cyclic linked list check
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	101 )
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	102
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	103 NOT_PRODUCT(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	104 size_t _processed;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	105 size_t _removed;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	106 )
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	107
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	108 public:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	109 inline DiscoveredListIterator(DiscoveredList& refs_list,
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	110 OopClosure* keep_alive,
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	111 BoolObjectClosure* is_alive):
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	112 _refs_list(refs_list),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	113 _prev_next(refs_list.adr_head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	114 _prev(NULL),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	115 _ref(refs_list.head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	116 #ifdef ASSERT
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	117 _first_seen(refs_list.head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	118 #endif
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	119 #ifndef PRODUCT
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	120 _processed(0),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	121 _removed(0),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	122 #endif
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	123 _next(NULL),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	124 _keep_alive(keep_alive),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	125 _is_alive(is_alive)
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	126 { }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	127
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	128 // End Of List.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	129 inline bool has_next() const { return _ref != NULL; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	130
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	131 // Get oop to the Reference object.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	132 inline oop obj() const { return _ref; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	133
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	134 // Get oop to the referent object.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	135 inline oop referent() const { return _referent; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	136
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	137 // Returns true if referent is alive.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	138 inline bool is_referent_alive() const {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	139 return _is_alive->do_object_b(_referent);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	140 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	141
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	142 // Loads data for the current reference.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	143 // The "allow_null_referent" argument tells us to allow for the possibility
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	144 // of a NULL referent in the discovered Reference object. This typically
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	145 // happens in the case of concurrent collectors that may have done the
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	146 // discovery concurrently, or interleaved, with mutator execution.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	147 void load_ptrs(DEBUG_ONLY(bool allow_null_referent));
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	148
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	149 // Move to the next discovered reference.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	150 inline void next() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	151 _prev_next = _discovered_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	152 _prev = _ref;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	153 move_to_next();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	154 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	155
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	156 // Remove the current reference from the list
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	157 void remove();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	158
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	159 // Make the Reference object active again.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	160 void make_active();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	161
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	162 // Make the referent alive.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	163 inline void make_referent_alive() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	164 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	165 _keep_alive->do_oop((narrowOop*)_referent_addr);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	166 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	167 _keep_alive->do_oop((oop*)_referent_addr);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	168 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	169 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	170
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	171 // Update the discovered field.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	172 inline void update_discovered() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	173 // First _prev_next ref actually points into DiscoveredList (gross).
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	174 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	175 if (!oopDesc::is_null((narrowOop)_prev_next)) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	176 _keep_alive->do_oop((narrowOop*)_prev_next);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	177 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	178 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	179 if (!oopDesc::is_null((oop)_prev_next)) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	180 _keep_alive->do_oop((oop*)_prev_next);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	181 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	182 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	183 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	184
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	185 // NULL out referent pointer.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	186 void clear_referent();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	187
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	188 // Statistics
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	189 NOT_PRODUCT(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	190 inline size_t processed() const { return _processed; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	191 inline size_t removed() const { return _removed; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	192 )
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	193
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	194 inline void move_to_next() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	195 if (_ref == _next) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	196 // End of the list.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	197 _ref = NULL;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	198 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	199 _ref = _next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	200 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	201 assert(_ref != _first_seen, "cyclic ref_list found");
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	202 NOT_PRODUCT(_processed++);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	203 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	204 };
0 a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 class ReferenceProcessor : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	207 protected:
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	208 // Compatibility with pre-4965777 JDK's
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	209 static bool _pending_list_uses_discovered_field;
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	210
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	211 // The SoftReference master timestamp clock
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	212 static jlong _soft_ref_timestamp_clock;
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	213
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	214 MemRegion _span; // (right-open) interval of heap
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	215 // subject to wkref discovery
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	216
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	217 bool _discovering_refs; // true when discovery enabled
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	218 bool _discovery_is_atomic; // if discovery is atomic wrt
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	219 // other collectors in configuration
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	220 bool _discovery_is_mt; // true if reference discovery is MT.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	221
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	222 // If true, setting "next" field of a discovered refs list requires
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	223 // write barrier(s). (Must be true if used in a collector in which
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	224 // elements of a discovered list may be moved during discovery: for
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	225 // example, a collector like Garbage-First that moves objects during a
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	226 // long-term concurrent marking phase that does weak reference
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	227 // discovery.)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	228 bool _discovered_list_needs_barrier;
0 a61af66fc99e Initial load duke parents: diff changeset	229
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	230 BarrierSet* _bs; // Cached copy of BarrierSet.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	231 bool _enqueuing_is_done; // true if all weak references enqueued
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	232 bool _processing_is_mt; // true during phases when
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	233 // reference processing is MT.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	234 int _next_id; // round-robin mod _num_q counter in
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	235 // support of work distribution
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	236
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	237 // For collectors that do not keep GC liveness information
0 a61af66fc99e Initial load duke parents: diff changeset	238 // in the object header, this field holds a closure that
a61af66fc99e Initial load duke parents: diff changeset	239 // helps the reference processor determine the reachability
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	240 // of an oop. It is currently initialized to NULL for all
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	241 // collectors except for CMS and G1.
0 a61af66fc99e Initial load duke parents: diff changeset	242 BoolObjectClosure* _is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	243
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	244 // Soft ref clearing policies
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	245 // . the default policy
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	246 static ReferencePolicy* _default_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	247 // . the "clear all" policy
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	248 static ReferencePolicy* _always_clear_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	249 // . the current policy below is either one of the above
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	250 ReferencePolicy* _current_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	251
0 a61af66fc99e Initial load duke parents: diff changeset	252 // The discovered ref lists themselves
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	253
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	254 // The active MT'ness degree of the queues below
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	255 int _num_q;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	256 // The maximum MT'ness degree of the queues below
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	257 int _max_num_q;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	258 // Arrays of lists of oops, one per thread
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	259 DiscoveredList* _discoveredSoftRefs;
0 a61af66fc99e Initial load duke parents: diff changeset	260 DiscoveredList* _discoveredWeakRefs;
a61af66fc99e Initial load duke parents: diff changeset	261 DiscoveredList* _discoveredFinalRefs;
a61af66fc99e Initial load duke parents: diff changeset	262 DiscoveredList* _discoveredPhantomRefs;
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 public:
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	265 static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_OTHER); }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	266
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	267 int num_q() { return _num_q; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	268 int max_num_q() { return _max_num_q; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	269 void set_active_mt_degree(int v) { _num_q = v; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	270 DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	271
457 27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy() ysr parents: 453 diff changeset	272 ReferencePolicy* setup_policy(bool always_clear) {
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	273 _current_soft_ref_policy = always_clear ?
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	274 _always_clear_soft_ref_policy : _default_soft_ref_policy;
457 27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy() ysr parents: 453 diff changeset	275 _current_soft_ref_policy->setup(); // snapshot the policy threshold
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	276 return _current_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	277 }
0 a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 // Process references with a certain reachability level.
a61af66fc99e Initial load duke parents: diff changeset	280 void process_discovered_reflist(DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	281 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	282 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	283 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	284 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	285 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	286 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load duke parents: diff changeset	287
a61af66fc99e Initial load duke parents: diff changeset	288 void process_phaseJNI(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	289 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	290 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 // Work methods used by the method process_discovered_reflist
a61af66fc99e Initial load duke parents: diff changeset	293 // Phase1: keep alive all those referents that are otherwise
a61af66fc99e Initial load duke parents: diff changeset	294 // dead but which must be kept alive by policy (and their closure).
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	295 void process_phase1(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	296 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	297 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	298 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	299 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	300 // Phase2: remove all those references whose referents are
a61af66fc99e Initial load duke parents: diff changeset	301 // reachable.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	302 inline void process_phase2(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	303 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	304 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	305 VoidClosure* complete_gc) {
a61af66fc99e Initial load duke parents: diff changeset	306 if (discovery_is_atomic()) {
a61af66fc99e Initial load duke parents: diff changeset	307 // complete_gc is ignored in this case for this phase
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	308 pp2_work(refs_list, is_alive, keep_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	309 } else {
a61af66fc99e Initial load duke parents: diff changeset	310 assert(complete_gc != NULL, "Error");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	311 pp2_work_concurrent_discovery(refs_list, is_alive,
0 a61af66fc99e Initial load duke parents: diff changeset	312 keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315 // Work methods in support of process_phase2
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	316 void pp2_work(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	317 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	318 OopClosure* keep_alive);
a61af66fc99e Initial load duke parents: diff changeset	319 void pp2_work_concurrent_discovery(
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	320 DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	321 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	322 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	323 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	324 // Phase3: process the referents by either clearing them
a61af66fc99e Initial load duke parents: diff changeset	325 // or keeping them alive (and their closure)
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	326 void process_phase3(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	327 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	328 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	329 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	330 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 // Enqueue references with a certain reachability level
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	333 void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 // "Preclean" all the discovered reference lists
a61af66fc99e Initial load duke parents: diff changeset	336 // by removing references with strongly reachable referents.
a61af66fc99e Initial load duke parents: diff changeset	337 // The first argument is a predicate on an oop that indicates
a61af66fc99e Initial load duke parents: diff changeset	338 // its (strong) reachability and the second is a closure that
a61af66fc99e Initial load duke parents: diff changeset	339 // may be used to incrementalize or abort the precleaning process.
a61af66fc99e Initial load duke parents: diff changeset	340 // The caller is responsible for taking care of potential
a61af66fc99e Initial load duke parents: diff changeset	341 // interference with concurrent operations on these lists
a61af66fc99e Initial load duke parents: diff changeset	342 // (or predicates involved) by other threads. Currently
1190 4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 457 diff changeset	343 // only used by the CMS collector. should_unload_classes is
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 457 diff changeset	344 // used to aid assertion checking when classes are collected.
0 a61af66fc99e Initial load duke parents: diff changeset	345 void preclean_discovered_references(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	346 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	347 VoidClosure* complete_gc,
1190 4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 457 diff changeset	348 YieldClosure* yield,
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context") jmasa parents: 457 diff changeset	349 bool should_unload_classes);
0 a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 // Delete entries in the discovered lists that have
a61af66fc99e Initial load duke parents: diff changeset	352 // either a null referent or are not active. Such
a61af66fc99e Initial load duke parents: diff changeset	353 // Reference objects can result from the clearing
a61af66fc99e Initial load duke parents: diff changeset	354 // or enqueueing of Reference objects concurrent
a61af66fc99e Initial load duke parents: diff changeset	355 // with their discovery by a (concurrent) collector.
a61af66fc99e Initial load duke parents: diff changeset	356 // For a definition of "active" see java.lang.ref.Reference;
a61af66fc99e Initial load duke parents: diff changeset	357 // Refs are born active, become inactive when enqueued,
a61af66fc99e Initial load duke parents: diff changeset	358 // and never become active again. The state of being
a61af66fc99e Initial load duke parents: diff changeset	359 // active is encoded as follows: A Ref is active
a61af66fc99e Initial load duke parents: diff changeset	360 // if and only if its "next" field is NULL.
a61af66fc99e Initial load duke parents: diff changeset	361 void clean_up_discovered_references();
a61af66fc99e Initial load duke parents: diff changeset	362 void clean_up_discovered_reflist(DiscoveredList& refs_list);
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 // Returns the name of the discovered reference list
a61af66fc99e Initial load duke parents: diff changeset	365 // occupying the i / _num_q slot.
a61af66fc99e Initial load duke parents: diff changeset	366 const char* list_name(int i);
a61af66fc99e Initial load duke parents: diff changeset	367
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	368 void enqueue_discovered_reflists(HeapWord* pending_list_addr, AbstractRefProcTaskExecutor* task_executor);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	369
0 a61af66fc99e Initial load duke parents: diff changeset	370 protected:
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	371 // Set the 'discovered' field of the given reference to
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	372 // the given value - emitting barriers depending upon
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	373 // the value of _discovered_list_needs_barrier.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	374 void set_discovered(oop ref, oop value);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	375
0 a61af66fc99e Initial load duke parents: diff changeset	376 // "Preclean" the given discovered reference list
a61af66fc99e Initial load duke parents: diff changeset	377 // by removing references with strongly reachable referents.
a61af66fc99e Initial load duke parents: diff changeset	378 // Currently used in support of CMS only.
a61af66fc99e Initial load duke parents: diff changeset	379 void preclean_discovered_reflist(DiscoveredList& refs_list,
a61af66fc99e Initial load duke parents: diff changeset	380 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	381 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	382 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	383 YieldClosure* yield);
a61af66fc99e Initial load duke parents: diff changeset	384
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	385 // round-robin mod _num_q (not: _not_ mode _max_num_q)
0 a61af66fc99e Initial load duke parents: diff changeset	386 int next_id() {
a61af66fc99e Initial load duke parents: diff changeset	387 int id = _next_id;
a61af66fc99e Initial load duke parents: diff changeset	388 if (++_next_id == _num_q) {
a61af66fc99e Initial load duke parents: diff changeset	389 _next_id = 0;
a61af66fc99e Initial load duke parents: diff changeset	390 }
a61af66fc99e Initial load duke parents: diff changeset	391 return id;
a61af66fc99e Initial load duke parents: diff changeset	392 }
a61af66fc99e Initial load duke parents: diff changeset	393 DiscoveredList* get_discovered_list(ReferenceType rt);
a61af66fc99e Initial load duke parents: diff changeset	394 inline void add_to_discovered_list_mt(DiscoveredList& refs_list, oop obj,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	395 HeapWord* discovered_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	396 void verify_ok_to_handle_reflists() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	397
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	398 void clear_discovered_references(DiscoveredList& refs_list);
0 a61af66fc99e Initial load duke parents: diff changeset	399 void abandon_partial_discovered_list(DiscoveredList& refs_list);
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 // Calculate the number of jni handles.
a61af66fc99e Initial load duke parents: diff changeset	402 unsigned int count_jni_refs();
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 // Balances reference queues.
a61af66fc99e Initial load duke parents: diff changeset	405 void balance_queues(DiscoveredList ref_lists[]);
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // Update (advance) the soft ref master clock field.
a61af66fc99e Initial load duke parents: diff changeset	408 void update_soft_ref_master_clock();
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 public:
a61af66fc99e Initial load duke parents: diff changeset	411 // constructor
a61af66fc99e Initial load duke parents: diff changeset	412 ReferenceProcessor():
a61af66fc99e Initial load duke parents: diff changeset	413 _span((HeapWord)NULL, (HeapWord)NULL),
a61af66fc99e Initial load duke parents: diff changeset	414 _discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL),
a61af66fc99e Initial load duke parents: diff changeset	415 _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
a61af66fc99e Initial load duke parents: diff changeset	416 _discovering_refs(false),
a61af66fc99e Initial load duke parents: diff changeset	417 _discovery_is_atomic(true),
a61af66fc99e Initial load duke parents: diff changeset	418 _enqueuing_is_done(false),
a61af66fc99e Initial load duke parents: diff changeset	419 _discovery_is_mt(false),
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	420 _discovered_list_needs_barrier(false),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	421 _bs(NULL),
0 a61af66fc99e Initial load duke parents: diff changeset	422 _is_alive_non_header(NULL),
a61af66fc99e Initial load duke parents: diff changeset	423 _num_q(0),
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	424 _max_num_q(0),
0 a61af66fc99e Initial load duke parents: diff changeset	425 _processing_is_mt(false),
a61af66fc99e Initial load duke parents: diff changeset	426 _next_id(0)
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	427 { }
0 a61af66fc99e Initial load duke parents: diff changeset	428
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	429 // Default parameters give you a vanilla reference processor.
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	430 ReferenceProcessor(MemRegion span,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	431 bool mt_processing = false, int mt_processing_degree = 1,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	432 bool mt_discovery = false, int mt_discovery_degree = 1,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	433 bool atomic_discovery = true,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	434 BoolObjectClosure* is_alive_non_header = NULL,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	435 bool discovered_list_needs_barrier = false);
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	436
0 a61af66fc99e Initial load duke parents: diff changeset	437 // RefDiscoveryPolicy values
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	438 enum DiscoveryPolicy {
0 a61af66fc99e Initial load duke parents: diff changeset	439 ReferenceBasedDiscovery = 0,
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	440 ReferentBasedDiscovery = 1,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	441 DiscoveryPolicyMin = ReferenceBasedDiscovery,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	442 DiscoveryPolicyMax = ReferentBasedDiscovery
0 a61af66fc99e Initial load duke parents: diff changeset	443 };
a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 static void init_statics();
a61af66fc99e Initial load duke parents: diff changeset	446
a61af66fc99e Initial load duke parents: diff changeset	447 public:
a61af66fc99e Initial load duke parents: diff changeset	448 // get and set "is_alive_non_header" field
a61af66fc99e Initial load duke parents: diff changeset	449 BoolObjectClosure* is_alive_non_header() {
a61af66fc99e Initial load duke parents: diff changeset	450 return _is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
a61af66fc99e Initial load duke parents: diff changeset	453 _is_alive_non_header = is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455
a61af66fc99e Initial load duke parents: diff changeset	456 // get and set span
a61af66fc99e Initial load duke parents: diff changeset	457 MemRegion span() { return _span; }
a61af66fc99e Initial load duke parents: diff changeset	458 void set_span(MemRegion span) { _span = span; }
a61af66fc99e Initial load duke parents: diff changeset	459
a61af66fc99e Initial load duke parents: diff changeset	460 // start and stop weak ref discovery
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	461 void enable_discovery(bool verify_disabled, bool check_no_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	462 void disable_discovery() { _discovering_refs = false; }
a61af66fc99e Initial load duke parents: diff changeset	463 bool discovery_enabled() { return _discovering_refs; }
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // whether discovery is atomic wrt other collectors
a61af66fc99e Initial load duke parents: diff changeset	466 bool discovery_is_atomic() const { return _discovery_is_atomic; }
a61af66fc99e Initial load duke parents: diff changeset	467 void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
a61af66fc99e Initial load duke parents: diff changeset	468
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	469 // whether the JDK in which we are embedded is a pre-4965777 JDK,
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	470 // and thus whether or not it uses the discovered field to chain
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	471 // the entries in the pending list.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	472 static bool pending_list_uses_discovered_field() {
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	473 return _pending_list_uses_discovered_field;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	474 }
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	475
0 a61af66fc99e Initial load duke parents: diff changeset	476 // whether discovery is done by multiple threads same-old-timeously
a61af66fc99e Initial load duke parents: diff changeset	477 bool discovery_is_mt() const { return _discovery_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	478 void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	479
a61af66fc99e Initial load duke parents: diff changeset	480 // Whether we are in a phase when _processing_ is MT.
a61af66fc99e Initial load duke parents: diff changeset	481 bool processing_is_mt() const { return _processing_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	482 void set_mt_processing(bool mt) { _processing_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	484 // whether all enqueuing of weak references is complete
a61af66fc99e Initial load duke parents: diff changeset	485 bool enqueuing_is_done() { return _enqueuing_is_done; }
a61af66fc99e Initial load duke parents: diff changeset	486 void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // iterate over oops
a61af66fc99e Initial load duke parents: diff changeset	489 void weak_oops_do(OopClosure* f); // weak roots
a61af66fc99e Initial load duke parents: diff changeset	490
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	491 // Balance each of the discovered lists.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	492 void balance_all_queues();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	493
0 a61af66fc99e Initial load duke parents: diff changeset	494 // Discover a Reference object, using appropriate discovery criteria
a61af66fc99e Initial load duke parents: diff changeset	495 bool discover_reference(oop obj, ReferenceType rt);
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 // Process references found during GC (called by the garbage collector)
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	498 void process_discovered_references(BoolObjectClosure* is_alive,
0 a61af66fc99e Initial load duke parents: diff changeset	499 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	500 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	501 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 public:
a61af66fc99e Initial load duke parents: diff changeset	504 // Enqueue references at end of GC (called by the garbage collector)
a61af66fc99e Initial load duke parents: diff changeset	505 bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
a61af66fc99e Initial load duke parents: diff changeset	506
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	507 // If a discovery is in process that is being superceded, abandon it: all
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	508 // the discovered lists will be empty, and all the objects on them will
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	509 // have NULL discovered fields. Must be called only at a safepoint.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	510 void abandon_partial_discovery();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	511
0 a61af66fc99e Initial load duke parents: diff changeset	512 // debugging
a61af66fc99e Initial load duke parents: diff changeset	513 void verify_no_references_recorded() PRODUCT_RETURN;
1995 8df09fb45352 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent ysr parents: 1972 diff changeset	514 void verify_referent(oop obj) PRODUCT_RETURN;
0 a61af66fc99e Initial load duke parents: diff changeset	515
a61af66fc99e Initial load duke parents: diff changeset	516 // clear the discovered lists (unlinking each entry).
a61af66fc99e Initial load duke parents: diff changeset	517 void clear_discovered_references() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	518 };
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 // A utility class to disable reference discovery in
a61af66fc99e Initial load duke parents: diff changeset	521 // the scope which contains it, for given ReferenceProcessor.
a61af66fc99e Initial load duke parents: diff changeset	522 class NoRefDiscovery: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	523 private:
a61af66fc99e Initial load duke parents: diff changeset	524 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	525 bool _was_discovering_refs;
a61af66fc99e Initial load duke parents: diff changeset	526 public:
a61af66fc99e Initial load duke parents: diff changeset	527 NoRefDiscovery(ReferenceProcessor* rp) : _rp(rp) {
1789 a83b0246bb77 6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall twisti parents: 1552 diff changeset	528 _was_discovering_refs = _rp->discovery_enabled();
a83b0246bb77 6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall twisti parents: 1552 diff changeset	529 if (_was_discovering_refs) {
0 a61af66fc99e Initial load duke parents: diff changeset	530 _rp->disable_discovery();
a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532 }
a61af66fc99e Initial load duke parents: diff changeset	533
a61af66fc99e Initial load duke parents: diff changeset	534 ~NoRefDiscovery() {
a61af66fc99e Initial load duke parents: diff changeset	535 if (_was_discovering_refs) {
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	536 _rp->enable_discovery(true /verify_disabled/, false /check_no_refs/);
0 a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538 }
a61af66fc99e Initial load duke parents: diff changeset	539 };
a61af66fc99e Initial load duke parents: diff changeset	540
a61af66fc99e Initial load duke parents: diff changeset	541
a61af66fc99e Initial load duke parents: diff changeset	542 // A utility class to temporarily mutate the span of the
a61af66fc99e Initial load duke parents: diff changeset	543 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	544 class ReferenceProcessorSpanMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	545 private:
a61af66fc99e Initial load duke parents: diff changeset	546 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	547 MemRegion _saved_span;
a61af66fc99e Initial load duke parents: diff changeset	548
a61af66fc99e Initial load duke parents: diff changeset	549 public:
a61af66fc99e Initial load duke parents: diff changeset	550 ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	551 MemRegion span):
a61af66fc99e Initial load duke parents: diff changeset	552 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	553 _saved_span = _rp->span();
a61af66fc99e Initial load duke parents: diff changeset	554 _rp->set_span(span);
a61af66fc99e Initial load duke parents: diff changeset	555 }
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 ~ReferenceProcessorSpanMutator() {
a61af66fc99e Initial load duke parents: diff changeset	558 _rp->set_span(_saved_span);
a61af66fc99e Initial load duke parents: diff changeset	559 }
a61af66fc99e Initial load duke parents: diff changeset	560 };
a61af66fc99e Initial load duke parents: diff changeset	561
a61af66fc99e Initial load duke parents: diff changeset	562 // A utility class to temporarily change the MT'ness of
a61af66fc99e Initial load duke parents: diff changeset	563 // reference discovery for the given ReferenceProcessor
a61af66fc99e Initial load duke parents: diff changeset	564 // in the scope that contains it.
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	565 class ReferenceProcessorMTDiscoveryMutator: StackObj {
0 a61af66fc99e Initial load duke parents: diff changeset	566 private:
a61af66fc99e Initial load duke parents: diff changeset	567 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	568 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	569
a61af66fc99e Initial load duke parents: diff changeset	570 public:
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	571 ReferenceProcessorMTDiscoveryMutator(ReferenceProcessor* rp,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	572 bool mt):
0 a61af66fc99e Initial load duke parents: diff changeset	573 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	574 _saved_mt = _rp->discovery_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	575 _rp->set_mt_discovery(mt);
a61af66fc99e Initial load duke parents: diff changeset	576 }
a61af66fc99e Initial load duke parents: diff changeset	577
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	578 ~ReferenceProcessorMTDiscoveryMutator() {
0 a61af66fc99e Initial load duke parents: diff changeset	579 _rp->set_mt_discovery(_saved_mt);
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581 };
a61af66fc99e Initial load duke parents: diff changeset	582
a61af66fc99e Initial load duke parents: diff changeset	583
a61af66fc99e Initial load duke parents: diff changeset	584 // A utility class to temporarily change the disposition
a61af66fc99e Initial load duke parents: diff changeset	585 // of the "is_alive_non_header" closure field of the
a61af66fc99e Initial load duke parents: diff changeset	586 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	587 class ReferenceProcessorIsAliveMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	588 private:
a61af66fc99e Initial load duke parents: diff changeset	589 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	590 BoolObjectClosure* _saved_cl;
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 public:
a61af66fc99e Initial load duke parents: diff changeset	593 ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	594 BoolObjectClosure* cl):
a61af66fc99e Initial load duke parents: diff changeset	595 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	596 _saved_cl = _rp->is_alive_non_header();
a61af66fc99e Initial load duke parents: diff changeset	597 _rp->set_is_alive_non_header(cl);
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599
a61af66fc99e Initial load duke parents: diff changeset	600 ~ReferenceProcessorIsAliveMutator() {
a61af66fc99e Initial load duke parents: diff changeset	601 _rp->set_is_alive_non_header(_saved_cl);
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603 };
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 // A utility class to temporarily change the disposition
a61af66fc99e Initial load duke parents: diff changeset	606 // of the "discovery_is_atomic" field of the
a61af66fc99e Initial load duke parents: diff changeset	607 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	608 class ReferenceProcessorAtomicMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	609 private:
a61af66fc99e Initial load duke parents: diff changeset	610 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	611 bool _saved_atomic_discovery;
a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 public:
a61af66fc99e Initial load duke parents: diff changeset	614 ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	615 bool atomic):
a61af66fc99e Initial load duke parents: diff changeset	616 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	617 _saved_atomic_discovery = _rp->discovery_is_atomic();
a61af66fc99e Initial load duke parents: diff changeset	618 _rp->set_atomic_discovery(atomic);
a61af66fc99e Initial load duke parents: diff changeset	619 }
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621 ~ReferenceProcessorAtomicMutator() {
a61af66fc99e Initial load duke parents: diff changeset	622 _rp->set_atomic_discovery(_saved_atomic_discovery);
a61af66fc99e Initial load duke parents: diff changeset	623 }
a61af66fc99e Initial load duke parents: diff changeset	624 };
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 // A utility class to temporarily change the MT processing
a61af66fc99e Initial load duke parents: diff changeset	628 // disposition of the given ReferenceProcessor instance
a61af66fc99e Initial load duke parents: diff changeset	629 // in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	630 class ReferenceProcessorMTProcMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	631 private:
a61af66fc99e Initial load duke parents: diff changeset	632 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	633 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	634
a61af66fc99e Initial load duke parents: diff changeset	635 public:
a61af66fc99e Initial load duke parents: diff changeset	636 ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	637 bool mt):
a61af66fc99e Initial load duke parents: diff changeset	638 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	639 _saved_mt = _rp->processing_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	640 _rp->set_mt_processing(mt);
a61af66fc99e Initial load duke parents: diff changeset	641 }
a61af66fc99e Initial load duke parents: diff changeset	642
a61af66fc99e Initial load duke parents: diff changeset	643 ~ReferenceProcessorMTProcMutator() {
a61af66fc99e Initial load duke parents: diff changeset	644 _rp->set_mt_processing(_saved_mt);
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646 };
a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648
a61af66fc99e Initial load duke parents: diff changeset	649 // This class is an interface used to implement task execution for the
a61af66fc99e Initial load duke parents: diff changeset	650 // reference processing.
a61af66fc99e Initial load duke parents: diff changeset	651 class AbstractRefProcTaskExecutor {
a61af66fc99e Initial load duke parents: diff changeset	652 public:
a61af66fc99e Initial load duke parents: diff changeset	653
a61af66fc99e Initial load duke parents: diff changeset	654 // Abstract tasks to execute.
a61af66fc99e Initial load duke parents: diff changeset	655 class ProcessTask;
a61af66fc99e Initial load duke parents: diff changeset	656 class EnqueueTask;
a61af66fc99e Initial load duke parents: diff changeset	657
a61af66fc99e Initial load duke parents: diff changeset	658 // Executes a task using worker threads.
a61af66fc99e Initial load duke parents: diff changeset	659 virtual void execute(ProcessTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	660 virtual void execute(EnqueueTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	661
a61af66fc99e Initial load duke parents: diff changeset	662 // Switch to single threaded mode.
a61af66fc99e Initial load duke parents: diff changeset	663 virtual void set_single_threaded_mode() { };
a61af66fc99e Initial load duke parents: diff changeset	664 };
a61af66fc99e Initial load duke parents: diff changeset	665
a61af66fc99e Initial load duke parents: diff changeset	666 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	667 class AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	668 protected:
a61af66fc99e Initial load duke parents: diff changeset	669 ProcessTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	670 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	671 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	672 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	673 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	674 _marks_oops_alive(marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	675 { }
a61af66fc99e Initial load duke parents: diff changeset	676
a61af66fc99e Initial load duke parents: diff changeset	677 public:
a61af66fc99e Initial load duke parents: diff changeset	678 virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	679 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	680 VoidClosure& complete_gc) = 0;
a61af66fc99e Initial load duke parents: diff changeset	681
a61af66fc99e Initial load duke parents: diff changeset	682 // Returns true if a task marks some oops as alive.
a61af66fc99e Initial load duke parents: diff changeset	683 bool marks_oops_alive() const
a61af66fc99e Initial load duke parents: diff changeset	684 { return _marks_oops_alive; }
a61af66fc99e Initial load duke parents: diff changeset	685
a61af66fc99e Initial load duke parents: diff changeset	686 protected:
a61af66fc99e Initial load duke parents: diff changeset	687 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	688 DiscoveredList* _refs_lists;
a61af66fc99e Initial load duke parents: diff changeset	689 const bool _marks_oops_alive;
a61af66fc99e Initial load duke parents: diff changeset	690 };
a61af66fc99e Initial load duke parents: diff changeset	691
a61af66fc99e Initial load duke parents: diff changeset	692 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	693 class AbstractRefProcTaskExecutor::EnqueueTask {
a61af66fc99e Initial load duke parents: diff changeset	694 protected:
a61af66fc99e Initial load duke parents: diff changeset	695 EnqueueTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	696 DiscoveredList refs_lists[],
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	697 HeapWord* pending_list_addr,
0 a61af66fc99e Initial load duke parents: diff changeset	698 int n_queues)
a61af66fc99e Initial load duke parents: diff changeset	699 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	700 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	701 _pending_list_addr(pending_list_addr),
a61af66fc99e Initial load duke parents: diff changeset	702 _n_queues(n_queues)
a61af66fc99e Initial load duke parents: diff changeset	703 { }
a61af66fc99e Initial load duke parents: diff changeset	704
a61af66fc99e Initial load duke parents: diff changeset	705 public:
a61af66fc99e Initial load duke parents: diff changeset	706 virtual void work(unsigned int work_id) = 0;
a61af66fc99e Initial load duke parents: diff changeset	707
a61af66fc99e Initial load duke parents: diff changeset	708 protected:
a61af66fc99e Initial load duke parents: diff changeset	709 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	710 DiscoveredList* _refs_lists;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	711 HeapWord* _pending_list_addr;
0 a61af66fc99e Initial load duke parents: diff changeset	712 int _n_queues;
a61af66fc99e Initial load duke parents: diff changeset	713 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	714
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	715 #endif // SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/memory/referenceProcessor.hpp @ 3992:d1bdeef3e3e2