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

annotate src/share/vm/memory/referenceProcessor.hpp @ 8804:91bf0bdae37b

8008217: CDS: Class data sharing limits the malloc heap on Solaris Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address. Reviewed-by: kvn, dcubed, zgu, hseigel

author	coleenp
date	Wed, 20 Mar 2013 08:04:54 -0400
parents	da91efe96a93
children	ebb32c4589f3 f2110083203d

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	2 * Copyright (c) 2001, 2012, 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
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	206 class ReferenceProcessor : public CHeapObj<mtGC> {
0 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.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	234 uint _next_id; // round-robin mod _num_q counter in
3979 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
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	255 uint _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
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	257 uint _max_num_q;
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	258
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	259 // Master array of discovered oops
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	260 DiscoveredList* _discovered_refs;
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	261
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	262 // Arrays of lists of oops, one per thread (pointers into master array above)
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	263 DiscoveredList* _discoveredSoftRefs;
0 a61af66fc99e Initial load duke parents: diff changeset	264 DiscoveredList* _discoveredWeakRefs;
a61af66fc99e Initial load duke parents: diff changeset	265 DiscoveredList* _discoveredFinalRefs;
a61af66fc99e Initial load duke parents: diff changeset	266 DiscoveredList* _discoveredPhantomRefs;
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 public:
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	269 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	270
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	271 uint num_q() { return _num_q; }
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	272 uint max_num_q() { return _max_num_q; }
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	273 void set_active_mt_degree(uint v) { _num_q = v; }
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	274
bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	275 DiscoveredList* discovered_refs() { return _discovered_refs; }
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	276
457 27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy() ysr parents: 453 diff changeset	277 ReferencePolicy* setup_policy(bool always_clear) {
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	278 _current_soft_ref_policy = always_clear ?
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	279 _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	280 _current_soft_ref_policy->setup(); // snapshot the policy threshold
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	281 return _current_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	282 }
0 a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 // Process references with a certain reachability level.
a61af66fc99e Initial load duke parents: diff changeset	285 void process_discovered_reflist(DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	286 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	287 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	288 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 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 void process_phaseJNI(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	294 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	295 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // Work methods used by the method process_discovered_reflist
a61af66fc99e Initial load duke parents: diff changeset	298 // Phase1: keep alive all those referents that are otherwise
a61af66fc99e Initial load duke parents: diff changeset	299 // 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	300 void process_phase1(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	301 ReferencePolicy* policy,
a61af66fc99e Initial load duke parents: diff changeset	302 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	303 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	304 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	305 // Phase2: remove all those references whose referents are
a61af66fc99e Initial load duke parents: diff changeset	306 // reachable.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	307 inline void process_phase2(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	308 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	309 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	310 VoidClosure* complete_gc) {
a61af66fc99e Initial load duke parents: diff changeset	311 if (discovery_is_atomic()) {
a61af66fc99e Initial load duke parents: diff changeset	312 // 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	313 pp2_work(refs_list, is_alive, keep_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	314 } else {
a61af66fc99e Initial load duke parents: diff changeset	315 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	316 pp2_work_concurrent_discovery(refs_list, is_alive,
0 a61af66fc99e Initial load duke parents: diff changeset	317 keep_alive, complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	318 }
a61af66fc99e Initial load duke parents: diff changeset	319 }
a61af66fc99e Initial load duke parents: diff changeset	320 // 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	321 void pp2_work(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	322 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	323 OopClosure* keep_alive);
a61af66fc99e Initial load duke parents: diff changeset	324 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	325 DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	326 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	327 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	328 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	329 // Phase3: process the referents by either clearing them
a61af66fc99e Initial load duke parents: diff changeset	330 // 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	331 void process_phase3(DiscoveredList& refs_list,
0 a61af66fc99e Initial load duke parents: diff changeset	332 bool clear_referent,
a61af66fc99e Initial load duke parents: diff changeset	333 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	334 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	335 VoidClosure* complete_gc);
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 // 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	338 void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 // "Preclean" all the discovered reference lists
a61af66fc99e Initial load duke parents: diff changeset	341 // by removing references with strongly reachable referents.
a61af66fc99e Initial load duke parents: diff changeset	342 // The first argument is a predicate on an oop that indicates
a61af66fc99e Initial load duke parents: diff changeset	343 // its (strong) reachability and the second is a closure that
a61af66fc99e Initial load duke parents: diff changeset	344 // may be used to incrementalize or abort the precleaning process.
a61af66fc99e Initial load duke parents: diff changeset	345 // The caller is responsible for taking care of potential
a61af66fc99e Initial load duke parents: diff changeset	346 // interference with concurrent operations on these lists
a61af66fc99e Initial load duke parents: diff changeset	347 // (or predicates involved) by other threads. Currently
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	348 // only used by the CMS collector.
0 a61af66fc99e Initial load duke parents: diff changeset	349 void preclean_discovered_references(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	350 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	351 VoidClosure* complete_gc,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	352 YieldClosure* yield);
0 a61af66fc99e Initial load duke parents: diff changeset	353
a61af66fc99e Initial load duke parents: diff changeset	354 // Delete entries in the discovered lists that have
a61af66fc99e Initial load duke parents: diff changeset	355 // either a null referent or are not active. Such
a61af66fc99e Initial load duke parents: diff changeset	356 // Reference objects can result from the clearing
a61af66fc99e Initial load duke parents: diff changeset	357 // or enqueueing of Reference objects concurrent
a61af66fc99e Initial load duke parents: diff changeset	358 // with their discovery by a (concurrent) collector.
a61af66fc99e Initial load duke parents: diff changeset	359 // For a definition of "active" see java.lang.ref.Reference;
a61af66fc99e Initial load duke parents: diff changeset	360 // Refs are born active, become inactive when enqueued,
a61af66fc99e Initial load duke parents: diff changeset	361 // and never become active again. The state of being
a61af66fc99e Initial load duke parents: diff changeset	362 // active is encoded as follows: A Ref is active
a61af66fc99e Initial load duke parents: diff changeset	363 // if and only if its "next" field is NULL.
a61af66fc99e Initial load duke parents: diff changeset	364 void clean_up_discovered_references();
a61af66fc99e Initial load duke parents: diff changeset	365 void clean_up_discovered_reflist(DiscoveredList& refs_list);
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 // Returns the name of the discovered reference list
a61af66fc99e Initial load duke parents: diff changeset	368 // occupying the i / _num_q slot.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	369 const char* list_name(uint i);
0 a61af66fc99e Initial load duke parents: diff changeset	370
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	371 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	372
0 a61af66fc99e Initial load duke parents: diff changeset	373 protected:
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	374 // Set the 'discovered' field of the given reference to
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	375 // the given value - emitting barriers depending upon
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	376 // the value of _discovered_list_needs_barrier.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	377 void set_discovered(oop ref, oop value);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	378
0 a61af66fc99e Initial load duke parents: diff changeset	379 // "Preclean" the given discovered reference list
a61af66fc99e Initial load duke parents: diff changeset	380 // by removing references with strongly reachable referents.
a61af66fc99e Initial load duke parents: diff changeset	381 // Currently used in support of CMS only.
a61af66fc99e Initial load duke parents: diff changeset	382 void preclean_discovered_reflist(DiscoveredList& refs_list,
a61af66fc99e Initial load duke parents: diff changeset	383 BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	384 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	385 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	386 YieldClosure* yield);
a61af66fc99e Initial load duke parents: diff changeset	387
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	388 // round-robin mod _num_q (not: _not_ mode _max_num_q)
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	389 uint next_id() {
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	390 uint id = _next_id;
0 a61af66fc99e Initial load duke parents: diff changeset	391 if (++_next_id == _num_q) {
a61af66fc99e Initial load duke parents: diff changeset	392 _next_id = 0;
a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394 return id;
a61af66fc99e Initial load duke parents: diff changeset	395 }
a61af66fc99e Initial load duke parents: diff changeset	396 DiscoveredList* get_discovered_list(ReferenceType rt);
a61af66fc99e Initial load duke parents: diff changeset	397 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	398 HeapWord* discovered_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	399 void verify_ok_to_handle_reflists() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	400
3915 c2bf0120ee5d 7085906: Replace the permgen allocated sentinelRef with a self-looped end stefank parents: 2369 diff changeset	401 void clear_discovered_references(DiscoveredList& refs_list);
0 a61af66fc99e Initial load duke parents: diff changeset	402 void abandon_partial_discovered_list(DiscoveredList& refs_list);
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 // Calculate the number of jni handles.
a61af66fc99e Initial load duke parents: diff changeset	405 unsigned int count_jni_refs();
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // Balances reference queues.
a61af66fc99e Initial load duke parents: diff changeset	408 void balance_queues(DiscoveredList ref_lists[]);
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 // Update (advance) the soft ref master clock field.
a61af66fc99e Initial load duke parents: diff changeset	411 void update_soft_ref_master_clock();
a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 public:
a61af66fc99e Initial load duke parents: diff changeset	414 // constructor
a61af66fc99e Initial load duke parents: diff changeset	415 ReferenceProcessor():
a61af66fc99e Initial load duke parents: diff changeset	416 _span((HeapWord)NULL, (HeapWord)NULL),
4014 bf2d2b8b1726 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs johnc parents: 3992 diff changeset	417 _discovered_refs(NULL),
0 a61af66fc99e Initial load duke parents: diff changeset	418 _discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL),
a61af66fc99e Initial load duke parents: diff changeset	419 _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
a61af66fc99e Initial load duke parents: diff changeset	420 _discovering_refs(false),
a61af66fc99e Initial load duke parents: diff changeset	421 _discovery_is_atomic(true),
a61af66fc99e Initial load duke parents: diff changeset	422 _enqueuing_is_done(false),
a61af66fc99e Initial load duke parents: diff changeset	423 _discovery_is_mt(false),
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	424 _discovered_list_needs_barrier(false),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	425 _bs(NULL),
0 a61af66fc99e Initial load duke parents: diff changeset	426 _is_alive_non_header(NULL),
a61af66fc99e Initial load duke parents: diff changeset	427 _num_q(0),
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	428 _max_num_q(0),
0 a61af66fc99e Initial load duke parents: diff changeset	429 _processing_is_mt(false),
a61af66fc99e Initial load duke parents: diff changeset	430 _next_id(0)
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	431 { }
0 a61af66fc99e Initial load duke parents: diff changeset	432
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	433 // Default parameters give you a vanilla reference processor.
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	434 ReferenceProcessor(MemRegion span,
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	435 bool mt_processing = false, uint mt_processing_degree = 1,
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	436 bool mt_discovery = false, uint mt_discovery_degree = 1,
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	437 bool atomic_discovery = true,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	438 BoolObjectClosure* is_alive_non_header = NULL,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	439 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	440
0 a61af66fc99e Initial load duke parents: diff changeset	441 // RefDiscoveryPolicy values
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	442 enum DiscoveryPolicy {
0 a61af66fc99e Initial load duke parents: diff changeset	443 ReferenceBasedDiscovery = 0,
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	444 ReferentBasedDiscovery = 1,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	445 DiscoveryPolicyMin = ReferenceBasedDiscovery,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	446 DiscoveryPolicyMax = ReferentBasedDiscovery
0 a61af66fc99e Initial load duke parents: diff changeset	447 };
a61af66fc99e Initial load duke parents: diff changeset	448
a61af66fc99e Initial load duke parents: diff changeset	449 static void init_statics();
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 public:
a61af66fc99e Initial load duke parents: diff changeset	452 // get and set "is_alive_non_header" field
a61af66fc99e Initial load duke parents: diff changeset	453 BoolObjectClosure* is_alive_non_header() {
a61af66fc99e Initial load duke parents: diff changeset	454 return _is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456 void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
a61af66fc99e Initial load duke parents: diff changeset	457 _is_alive_non_header = is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459
a61af66fc99e Initial load duke parents: diff changeset	460 // get and set span
a61af66fc99e Initial load duke parents: diff changeset	461 MemRegion span() { return _span; }
a61af66fc99e Initial load duke parents: diff changeset	462 void set_span(MemRegion span) { _span = span; }
a61af66fc99e Initial load duke parents: diff changeset	463
a61af66fc99e Initial load duke parents: diff changeset	464 // start and stop weak ref discovery
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	465 void enable_discovery(bool verify_disabled, bool check_no_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	466 void disable_discovery() { _discovering_refs = false; }
a61af66fc99e Initial load duke parents: diff changeset	467 bool discovery_enabled() { return _discovering_refs; }
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 // whether discovery is atomic wrt other collectors
a61af66fc99e Initial load duke parents: diff changeset	470 bool discovery_is_atomic() const { return _discovery_is_atomic; }
a61af66fc99e Initial load duke parents: diff changeset	471 void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
a61af66fc99e Initial load duke parents: diff changeset	472
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	473 // 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	474 // 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	475 // the entries in the pending list.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	476 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	477 return _pending_list_uses_discovered_field;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	478 }
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	479
0 a61af66fc99e Initial load duke parents: diff changeset	480 // whether discovery is done by multiple threads same-old-timeously
a61af66fc99e Initial load duke parents: diff changeset	481 bool discovery_is_mt() const { return _discovery_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	482 void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	484 // Whether we are in a phase when _processing_ is MT.
a61af66fc99e Initial load duke parents: diff changeset	485 bool processing_is_mt() const { return _processing_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	486 void set_mt_processing(bool mt) { _processing_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // whether all enqueuing of weak references is complete
a61af66fc99e Initial load duke parents: diff changeset	489 bool enqueuing_is_done() { return _enqueuing_is_done; }
a61af66fc99e Initial load duke parents: diff changeset	490 void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
a61af66fc99e Initial load duke parents: diff changeset	491
a61af66fc99e Initial load duke parents: diff changeset	492 // iterate over oops
a61af66fc99e Initial load duke parents: diff changeset	493 void weak_oops_do(OopClosure* f); // weak roots
a61af66fc99e Initial load duke parents: diff changeset	494
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	495 // Balance each of the discovered lists.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	496 void balance_all_queues();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	497 void verify_list(DiscoveredList& ref_list);
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	498
0 a61af66fc99e Initial load duke parents: diff changeset	499 // Discover a Reference object, using appropriate discovery criteria
a61af66fc99e Initial load duke parents: diff changeset	500 bool discover_reference(oop obj, ReferenceType rt);
a61af66fc99e Initial load duke parents: diff changeset	501
a61af66fc99e Initial load duke parents: diff changeset	502 // 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	503 void process_discovered_references(BoolObjectClosure* is_alive,
0 a61af66fc99e Initial load duke parents: diff changeset	504 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	505 VoidClosure* complete_gc,
a61af66fc99e Initial load duke parents: diff changeset	506 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 public:
a61af66fc99e Initial load duke parents: diff changeset	509 // Enqueue references at end of GC (called by the garbage collector)
a61af66fc99e Initial load duke parents: diff changeset	510 bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
a61af66fc99e Initial load duke parents: diff changeset	511
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	512 // 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	513 // 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	514 // 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	515 void abandon_partial_discovery();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	516
0 a61af66fc99e Initial load duke parents: diff changeset	517 // debugging
a61af66fc99e Initial load duke parents: diff changeset	518 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	519 void verify_referent(oop obj) PRODUCT_RETURN;
0 a61af66fc99e Initial load duke parents: diff changeset	520
a61af66fc99e Initial load duke parents: diff changeset	521 // clear the discovered lists (unlinking each entry).
a61af66fc99e Initial load duke parents: diff changeset	522 void clear_discovered_references() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	523 };
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 // A utility class to disable reference discovery in
a61af66fc99e Initial load duke parents: diff changeset	526 // the scope which contains it, for given ReferenceProcessor.
a61af66fc99e Initial load duke parents: diff changeset	527 class NoRefDiscovery: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	528 private:
a61af66fc99e Initial load duke parents: diff changeset	529 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	530 bool _was_discovering_refs;
a61af66fc99e Initial load duke parents: diff changeset	531 public:
a61af66fc99e Initial load duke parents: diff changeset	532 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	533 _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	534 if (_was_discovering_refs) {
0 a61af66fc99e Initial load duke parents: diff changeset	535 _rp->disable_discovery();
a61af66fc99e Initial load duke parents: diff changeset	536 }
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 ~NoRefDiscovery() {
a61af66fc99e Initial load duke parents: diff changeset	540 if (_was_discovering_refs) {
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	541 _rp->enable_discovery(true /verify_disabled/, false /check_no_refs/);
0 a61af66fc99e Initial load duke parents: diff changeset	542 }
a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544 };
a61af66fc99e Initial load duke parents: diff changeset	545
a61af66fc99e Initial load duke parents: diff changeset	546
a61af66fc99e Initial load duke parents: diff changeset	547 // A utility class to temporarily mutate the span of the
a61af66fc99e Initial load duke parents: diff changeset	548 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	549 class ReferenceProcessorSpanMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	550 private:
a61af66fc99e Initial load duke parents: diff changeset	551 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	552 MemRegion _saved_span;
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 public:
a61af66fc99e Initial load duke parents: diff changeset	555 ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	556 MemRegion span):
a61af66fc99e Initial load duke parents: diff changeset	557 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	558 _saved_span = _rp->span();
a61af66fc99e Initial load duke parents: diff changeset	559 _rp->set_span(span);
a61af66fc99e Initial load duke parents: diff changeset	560 }
a61af66fc99e Initial load duke parents: diff changeset	561
a61af66fc99e Initial load duke parents: diff changeset	562 ~ReferenceProcessorSpanMutator() {
a61af66fc99e Initial load duke parents: diff changeset	563 _rp->set_span(_saved_span);
a61af66fc99e Initial load duke parents: diff changeset	564 }
a61af66fc99e Initial load duke parents: diff changeset	565 };
a61af66fc99e Initial load duke parents: diff changeset	566
a61af66fc99e Initial load duke parents: diff changeset	567 // A utility class to temporarily change the MT'ness of
a61af66fc99e Initial load duke parents: diff changeset	568 // reference discovery for the given ReferenceProcessor
a61af66fc99e Initial load duke parents: diff changeset	569 // in the scope that contains it.
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	570 class ReferenceProcessorMTDiscoveryMutator: StackObj {
0 a61af66fc99e Initial load duke parents: diff changeset	571 private:
a61af66fc99e Initial load duke parents: diff changeset	572 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	573 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	574
a61af66fc99e Initial load duke parents: diff changeset	575 public:
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	576 ReferenceProcessorMTDiscoveryMutator(ReferenceProcessor* rp,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	577 bool mt):
0 a61af66fc99e Initial load duke parents: diff changeset	578 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	579 _saved_mt = _rp->discovery_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	580 _rp->set_mt_discovery(mt);
a61af66fc99e Initial load duke parents: diff changeset	581 }
a61af66fc99e Initial load duke parents: diff changeset	582
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	583 ~ReferenceProcessorMTDiscoveryMutator() {
0 a61af66fc99e Initial load duke parents: diff changeset	584 _rp->set_mt_discovery(_saved_mt);
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586 };
a61af66fc99e Initial load duke parents: diff changeset	587
a61af66fc99e Initial load duke parents: diff changeset	588
a61af66fc99e Initial load duke parents: diff changeset	589 // A utility class to temporarily change the disposition
a61af66fc99e Initial load duke parents: diff changeset	590 // of the "is_alive_non_header" closure field of the
a61af66fc99e Initial load duke parents: diff changeset	591 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	592 class ReferenceProcessorIsAliveMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	593 private:
a61af66fc99e Initial load duke parents: diff changeset	594 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	595 BoolObjectClosure* _saved_cl;
a61af66fc99e Initial load duke parents: diff changeset	596
a61af66fc99e Initial load duke parents: diff changeset	597 public:
a61af66fc99e Initial load duke parents: diff changeset	598 ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	599 BoolObjectClosure* cl):
a61af66fc99e Initial load duke parents: diff changeset	600 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	601 _saved_cl = _rp->is_alive_non_header();
a61af66fc99e Initial load duke parents: diff changeset	602 _rp->set_is_alive_non_header(cl);
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 ~ReferenceProcessorIsAliveMutator() {
a61af66fc99e Initial load duke parents: diff changeset	606 _rp->set_is_alive_non_header(_saved_cl);
a61af66fc99e Initial load duke parents: diff changeset	607 }
a61af66fc99e Initial load duke parents: diff changeset	608 };
a61af66fc99e Initial load duke parents: diff changeset	609
a61af66fc99e Initial load duke parents: diff changeset	610 // A utility class to temporarily change the disposition
a61af66fc99e Initial load duke parents: diff changeset	611 // of the "discovery_is_atomic" field of the
a61af66fc99e Initial load duke parents: diff changeset	612 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	613 class ReferenceProcessorAtomicMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	614 private:
a61af66fc99e Initial load duke parents: diff changeset	615 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	616 bool _saved_atomic_discovery;
a61af66fc99e Initial load duke parents: diff changeset	617
a61af66fc99e Initial load duke parents: diff changeset	618 public:
a61af66fc99e Initial load duke parents: diff changeset	619 ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	620 bool atomic):
a61af66fc99e Initial load duke parents: diff changeset	621 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	622 _saved_atomic_discovery = _rp->discovery_is_atomic();
a61af66fc99e Initial load duke parents: diff changeset	623 _rp->set_atomic_discovery(atomic);
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626 ~ReferenceProcessorAtomicMutator() {
a61af66fc99e Initial load duke parents: diff changeset	627 _rp->set_atomic_discovery(_saved_atomic_discovery);
a61af66fc99e Initial load duke parents: diff changeset	628 }
a61af66fc99e Initial load duke parents: diff changeset	629 };
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631
a61af66fc99e Initial load duke parents: diff changeset	632 // A utility class to temporarily change the MT processing
a61af66fc99e Initial load duke parents: diff changeset	633 // disposition of the given ReferenceProcessor instance
a61af66fc99e Initial load duke parents: diff changeset	634 // in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	635 class ReferenceProcessorMTProcMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	636 private:
a61af66fc99e Initial load duke parents: diff changeset	637 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	638 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	639
a61af66fc99e Initial load duke parents: diff changeset	640 public:
a61af66fc99e Initial load duke parents: diff changeset	641 ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	642 bool mt):
a61af66fc99e Initial load duke parents: diff changeset	643 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	644 _saved_mt = _rp->processing_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	645 _rp->set_mt_processing(mt);
a61af66fc99e Initial load duke parents: diff changeset	646 }
a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648 ~ReferenceProcessorMTProcMutator() {
a61af66fc99e Initial load duke parents: diff changeset	649 _rp->set_mt_processing(_saved_mt);
a61af66fc99e Initial load duke parents: diff changeset	650 }
a61af66fc99e Initial load duke parents: diff changeset	651 };
a61af66fc99e Initial load duke parents: diff changeset	652
a61af66fc99e Initial load duke parents: diff changeset	653
a61af66fc99e Initial load duke parents: diff changeset	654 // This class is an interface used to implement task execution for the
a61af66fc99e Initial load duke parents: diff changeset	655 // reference processing.
a61af66fc99e Initial load duke parents: diff changeset	656 class AbstractRefProcTaskExecutor {
a61af66fc99e Initial load duke parents: diff changeset	657 public:
a61af66fc99e Initial load duke parents: diff changeset	658
a61af66fc99e Initial load duke parents: diff changeset	659 // Abstract tasks to execute.
a61af66fc99e Initial load duke parents: diff changeset	660 class ProcessTask;
a61af66fc99e Initial load duke parents: diff changeset	661 class EnqueueTask;
a61af66fc99e Initial load duke parents: diff changeset	662
a61af66fc99e Initial load duke parents: diff changeset	663 // Executes a task using worker threads.
a61af66fc99e Initial load duke parents: diff changeset	664 virtual void execute(ProcessTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	665 virtual void execute(EnqueueTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667 // Switch to single threaded mode.
a61af66fc99e Initial load duke parents: diff changeset	668 virtual void set_single_threaded_mode() { };
a61af66fc99e Initial load duke parents: diff changeset	669 };
a61af66fc99e Initial load duke parents: diff changeset	670
a61af66fc99e Initial load duke parents: diff changeset	671 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	672 class AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	673 protected:
a61af66fc99e Initial load duke parents: diff changeset	674 ProcessTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	675 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	676 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	677 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	678 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	679 _marks_oops_alive(marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	680 { }
a61af66fc99e Initial load duke parents: diff changeset	681
a61af66fc99e Initial load duke parents: diff changeset	682 public:
a61af66fc99e Initial load duke parents: diff changeset	683 virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	684 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	685 VoidClosure& complete_gc) = 0;
a61af66fc99e Initial load duke parents: diff changeset	686
a61af66fc99e Initial load duke parents: diff changeset	687 // Returns true if a task marks some oops as alive.
a61af66fc99e Initial load duke parents: diff changeset	688 bool marks_oops_alive() const
a61af66fc99e Initial load duke parents: diff changeset	689 { return _marks_oops_alive; }
a61af66fc99e Initial load duke parents: diff changeset	690
a61af66fc99e Initial load duke parents: diff changeset	691 protected:
a61af66fc99e Initial load duke parents: diff changeset	692 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	693 DiscoveredList* _refs_lists;
a61af66fc99e Initial load duke parents: diff changeset	694 const bool _marks_oops_alive;
a61af66fc99e Initial load duke parents: diff changeset	695 };
a61af66fc99e Initial load duke parents: diff changeset	696
a61af66fc99e Initial load duke parents: diff changeset	697 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	698 class AbstractRefProcTaskExecutor::EnqueueTask {
a61af66fc99e Initial load duke parents: diff changeset	699 protected:
a61af66fc99e Initial load duke parents: diff changeset	700 EnqueueTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	701 DiscoveredList refs_lists[],
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	702 HeapWord* pending_list_addr,
0 a61af66fc99e Initial load duke parents: diff changeset	703 int n_queues)
a61af66fc99e Initial load duke parents: diff changeset	704 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	705 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	706 _pending_list_addr(pending_list_addr),
a61af66fc99e Initial load duke parents: diff changeset	707 _n_queues(n_queues)
a61af66fc99e Initial load duke parents: diff changeset	708 { }
a61af66fc99e Initial load duke parents: diff changeset	709
a61af66fc99e Initial load duke parents: diff changeset	710 public:
a61af66fc99e Initial load duke parents: diff changeset	711 virtual void work(unsigned int work_id) = 0;
a61af66fc99e Initial load duke parents: diff changeset	712
a61af66fc99e Initial load duke parents: diff changeset	713 protected:
a61af66fc99e Initial load duke parents: diff changeset	714 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	715 DiscoveredList* _refs_lists;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	716 HeapWord* _pending_list_addr;
0 a61af66fc99e Initial load duke parents: diff changeset	717 int _n_queues;
a61af66fc99e Initial load duke parents: diff changeset	718 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	719
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	720 #endif // SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/referenceProcessor.hpp @ 8804:91bf0bdae37b