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

annotate src/share/vm/memory/referenceProcessor.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	0982ec23da03
children	c2844108a708

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	2 * Copyright (c) 2001, 2013, 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
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	28 #include "gc_implementation/shared/gcTrace.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	29 #include "memory/referencePolicy.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	30 #include "memory/referenceProcessorStats.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	31 #include "memory/referenceType.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	32 #include "oops/instanceRefKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	33
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	34 class GCTimer;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	35
0 a61af66fc99e Initial load duke parents: diff changeset	36 // ReferenceProcessor class encapsulates the per-"collector" processing
453 c96030fff130 6684579: SoftReference processing can be made more efficient ysr parents: 356 diff changeset	37 // of java.lang.Reference objects for GC. The interface is useful for supporting
0 a61af66fc99e Initial load duke parents: diff changeset	38 // a generational abstraction, in particular when there are multiple
a61af66fc99e Initial load duke parents: diff changeset	39 // generations that are being independently collected -- possibly
a61af66fc99e Initial load duke parents: diff changeset	40 // concurrently and/or incrementally. Note, however, that the
a61af66fc99e Initial load duke parents: diff changeset	41 // ReferenceProcessor class abstracts away from a generational setting
a61af66fc99e Initial load duke parents: diff changeset	42 // by using only a heap interval (called "span" below), thus allowing
a61af66fc99e Initial load duke parents: diff changeset	43 // its use in a straightforward manner in a general, non-generational
a61af66fc99e Initial load duke parents: diff changeset	44 // setting.
a61af66fc99e Initial load duke parents: diff changeset	45 //
a61af66fc99e Initial load duke parents: diff changeset	46 // The basic idea is that each ReferenceProcessor object concerns
a61af66fc99e Initial load duke parents: diff changeset	47 // itself with ("weak") reference processing in a specific "span"
a61af66fc99e Initial load duke parents: diff changeset	48 // of the heap of interest to a specific collector. Currently,
a61af66fc99e Initial load duke parents: diff changeset	49 // the span is a convex interval of the heap, but, efficiency
a61af66fc99e Initial load duke parents: diff changeset	50 // apart, there seems to be no reason it couldn't be extended
a61af66fc99e Initial load duke parents: diff changeset	51 // (with appropriate modifications) to any "non-convex interval".
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 // forward references
a61af66fc99e Initial load duke parents: diff changeset	54 class ReferencePolicy;
a61af66fc99e Initial load duke parents: diff changeset	55 class AbstractRefProcTaskExecutor;
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	56
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	57 // List of discovered references.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	58 class DiscoveredList {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	59 public:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	60 DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	61 oop head() const {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	62 return UseCompressedOops ? oopDesc::decode_heap_oop(_compressed_head) :
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	63 _oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	64 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	65 HeapWord* adr_head() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	66 return UseCompressedOops ? (HeapWord*)&_compressed_head :
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	67 (HeapWord*)&_oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	68 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	69 void set_head(oop o) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	70 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	71 // Must compress the head ptr.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	72 _compressed_head = oopDesc::encode_heap_oop(o);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	73 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	74 _oop_head = o;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	75 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	76 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	77 bool is_empty() const { return head() == NULL; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	78 size_t length() { return _len; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	79 void set_length(size_t len) { _len = len; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	80 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	81 void dec_length(size_t dec) { _len -= dec; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	82 private:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	83 // Set value depending on UseCompressedOops. This could be a template class
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	84 // 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	85 oop _oop_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	86 narrowOop _compressed_head;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	87 size_t _len;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	88 };
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	89
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	90 // Iterator for the list of discovered references.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	91 class DiscoveredListIterator {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	92 private:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	93 DiscoveredList& _refs_list;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	94 HeapWord* _prev_next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	95 oop _prev;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	96 oop _ref;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	97 HeapWord* _discovered_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	98 oop _next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	99 HeapWord* _referent_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	100 oop _referent;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	101 OopClosure* _keep_alive;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	102 BoolObjectClosure* _is_alive;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	103
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	104 DEBUG_ONLY(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	105 oop _first_seen; // cyclic linked list check
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 NOT_PRODUCT(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	109 size_t _processed;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	110 size_t _removed;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	111 )
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	112
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	113 public:
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	114 inline DiscoveredListIterator(DiscoveredList& refs_list,
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	115 OopClosure* keep_alive,
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17748 diff changeset	116 BoolObjectClosure* is_alive):
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	117 _refs_list(refs_list),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	118 _prev_next(refs_list.adr_head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	119 _prev(NULL),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	120 _ref(refs_list.head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	121 #ifdef ASSERT
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	122 _first_seen(refs_list.head()),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	123 #endif
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	124 #ifndef PRODUCT
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	125 _processed(0),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	126 _removed(0),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	127 #endif
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	128 _next(NULL),
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	129 _keep_alive(keep_alive),
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17748 diff changeset	130 _is_alive(is_alive)
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	131 { }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	132
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	133 // End Of List.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	134 inline bool has_next() const { return _ref != NULL; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	135
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	136 // Get oop to the Reference object.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	137 inline oop obj() const { return _ref; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	138
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	139 // Get oop to the referent object.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	140 inline oop referent() const { return _referent; }
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 // Returns true if referent is alive.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	143 inline bool is_referent_alive() const {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	144 return _is_alive->do_object_b(_referent);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	145 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	146
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	147 // Loads data for the current reference.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	148 // 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	149 // of a NULL referent in the discovered Reference object. This typically
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	150 // 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	151 // discovery concurrently, or interleaved, with mutator execution.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	152 void load_ptrs(DEBUG_ONLY(bool allow_null_referent));
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	153
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	154 // Move to the next discovered reference.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	155 inline void next() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	156 _prev_next = _discovered_addr;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	157 _prev = _ref;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	158 move_to_next();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	159 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	160
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	161 // Remove the current reference from the list
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	162 void remove();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	163
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	164 // Make the Reference object active again.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	165 void make_active();
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	166
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	167 // Make the referent alive.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	168 inline void make_referent_alive() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	169 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	170 _keep_alive->do_oop((narrowOop*)_referent_addr);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	171 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	172 _keep_alive->do_oop((oop*)_referent_addr);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	173 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	174 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	175
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	176 // Update the discovered field.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	177 inline void update_discovered() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	178 // First _prev_next ref actually points into DiscoveredList (gross).
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	179 if (UseCompressedOops) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	180 if (!oopDesc::is_null((narrowOop)_prev_next)) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	181 _keep_alive->do_oop((narrowOop*)_prev_next);
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 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	184 if (!oopDesc::is_null((oop)_prev_next)) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	185 _keep_alive->do_oop((oop*)_prev_next);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	186 }
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 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	189
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	190 // NULL out referent pointer.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	191 void clear_referent();
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 // Statistics
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	194 NOT_PRODUCT(
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	195 inline size_t processed() const { return _processed; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	196 inline size_t removed() const { return _removed; }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	197 )
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	198
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	199 inline void move_to_next() {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	200 if (_ref == _next) {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	201 // End of the list.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	202 _ref = NULL;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	203 } else {
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	204 _ref = _next;
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	205 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	206 assert(_ref != _first_seen, "cyclic ref_list found");
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	207 NOT_PRODUCT(_processed++);
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	208 }
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	209 };
0 a61af66fc99e Initial load duke parents: diff changeset	210
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	211 class ReferenceProcessor : public CHeapObj<mtGC> {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	212
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	213 private:
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	214 size_t total_count(DiscoveredList lists[]);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	215
0 a61af66fc99e Initial load duke parents: diff changeset	216 protected:
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	217 // Compatibility with pre-4965777 JDK's
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	218 static bool _pending_list_uses_discovered_field;
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	219
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	220 // The SoftReference master timestamp clock
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	221 static jlong _soft_ref_timestamp_clock;
d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	222
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	223 MemRegion _span; // (right-open) interval of heap
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	224 // subject to wkref discovery
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	225
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	226 bool _discovering_refs; // true when discovery enabled
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	227 bool _discovery_is_atomic; // if discovery is atomic wrt
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	228 // other collectors in configuration
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	229 bool _discovery_is_mt; // true if reference discovery is MT.
4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	230
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.
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	285 size_t process_discovered_reflist(DiscoveredList refs_lists[],
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	286 ReferencePolicy* policy,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	287 bool clear_referent,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	288 BoolObjectClosure* is_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	289 OopClosure* keep_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	290 VoidClosure* complete_gc,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	291 AbstractRefProcTaskExecutor* task_executor);
0 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,
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	352 YieldClosure* yield,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	353 GCTimer* gc_timer,
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	354 GCId gc_id);
0 a61af66fc99e Initial load duke parents: diff changeset	355
a61af66fc99e Initial load duke parents: diff changeset	356 // Delete entries in the discovered lists that have
a61af66fc99e Initial load duke parents: diff changeset	357 // either a null referent or are not active. Such
a61af66fc99e Initial load duke parents: diff changeset	358 // Reference objects can result from the clearing
a61af66fc99e Initial load duke parents: diff changeset	359 // or enqueueing of Reference objects concurrent
a61af66fc99e Initial load duke parents: diff changeset	360 // with their discovery by a (concurrent) collector.
a61af66fc99e Initial load duke parents: diff changeset	361 // For a definition of "active" see java.lang.ref.Reference;
a61af66fc99e Initial load duke parents: diff changeset	362 // Refs are born active, become inactive when enqueued,
a61af66fc99e Initial load duke parents: diff changeset	363 // and never become active again. The state of being
a61af66fc99e Initial load duke parents: diff changeset	364 // active is encoded as follows: A Ref is active
a61af66fc99e Initial load duke parents: diff changeset	365 // if and only if its "next" field is NULL.
a61af66fc99e Initial load duke parents: diff changeset	366 void clean_up_discovered_references();
a61af66fc99e Initial load duke parents: diff changeset	367 void clean_up_discovered_reflist(DiscoveredList& refs_list);
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369 // Returns the name of the discovered reference list
a61af66fc99e Initial load duke parents: diff changeset	370 // occupying the i / _num_q slot.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	371 const char* list_name(uint i);
0 a61af66fc99e Initial load duke parents: diff changeset	372
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	373 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	374
0 a61af66fc99e Initial load duke parents: diff changeset	375 protected:
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)
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	386 uint next_id() {
441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	387 uint id = _next_id;
0 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:
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	411 // Default parameters give you a vanilla reference processor.
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	412 ReferenceProcessor(MemRegion span,
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4014 diff changeset	413 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	414 bool mt_discovery = false, uint mt_discovery_degree = 1,
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	415 bool atomic_discovery = true,
17976 8e20ef014b08 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects brutisso parents: 17748 diff changeset	416 BoolObjectClosure* is_alive_non_header = NULL);
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	417
0 a61af66fc99e Initial load duke parents: diff changeset	418 // RefDiscoveryPolicy values
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	419 enum DiscoveryPolicy {
0 a61af66fc99e Initial load duke parents: diff changeset	420 ReferenceBasedDiscovery = 0,
1244 745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	421 ReferentBasedDiscovery = 1,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	422 DiscoveryPolicyMin = ReferenceBasedDiscovery,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash johnc parents: 1190 diff changeset	423 DiscoveryPolicyMax = ReferentBasedDiscovery
0 a61af66fc99e Initial load duke parents: diff changeset	424 };
a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 static void init_statics();
a61af66fc99e Initial load duke parents: diff changeset	427
a61af66fc99e Initial load duke parents: diff changeset	428 public:
a61af66fc99e Initial load duke parents: diff changeset	429 // get and set "is_alive_non_header" field
a61af66fc99e Initial load duke parents: diff changeset	430 BoolObjectClosure* is_alive_non_header() {
a61af66fc99e Initial load duke parents: diff changeset	431 return _is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	432 }
a61af66fc99e Initial load duke parents: diff changeset	433 void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
a61af66fc99e Initial load duke parents: diff changeset	434 _is_alive_non_header = is_alive_non_header;
a61af66fc99e Initial load duke parents: diff changeset	435 }
a61af66fc99e Initial load duke parents: diff changeset	436
a61af66fc99e Initial load duke parents: diff changeset	437 // get and set span
a61af66fc99e Initial load duke parents: diff changeset	438 MemRegion span() { return _span; }
a61af66fc99e Initial load duke parents: diff changeset	439 void set_span(MemRegion span) { _span = span; }
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 // start and stop weak ref discovery
3992 d1bdeef3e3e2 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 johnc parents: 3979 diff changeset	442 void enable_discovery(bool verify_disabled, bool check_no_refs);
0 a61af66fc99e Initial load duke parents: diff changeset	443 void disable_discovery() { _discovering_refs = false; }
a61af66fc99e Initial load duke parents: diff changeset	444 bool discovery_enabled() { return _discovering_refs; }
a61af66fc99e Initial load duke parents: diff changeset	445
a61af66fc99e Initial load duke parents: diff changeset	446 // whether discovery is atomic wrt other collectors
a61af66fc99e Initial load duke parents: diff changeset	447 bool discovery_is_atomic() const { return _discovery_is_atomic; }
a61af66fc99e Initial load duke parents: diff changeset	448 void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
a61af66fc99e Initial load duke parents: diff changeset	449
3917 eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	450 // 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	451 // 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	452 // the entries in the pending list.
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	453 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	454 return _pending_list_uses_discovered_field;
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	455 }
eca1193ca245 4965777: GC changes to support use of discovered field for pending references ysr parents: 3915 diff changeset	456
0 a61af66fc99e Initial load duke parents: diff changeset	457 // whether discovery is done by multiple threads same-old-timeously
a61af66fc99e Initial load duke parents: diff changeset	458 bool discovery_is_mt() const { return _discovery_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	459 void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	460
a61af66fc99e Initial load duke parents: diff changeset	461 // Whether we are in a phase when _processing_ is MT.
a61af66fc99e Initial load duke parents: diff changeset	462 bool processing_is_mt() const { return _processing_is_mt; }
a61af66fc99e Initial load duke parents: diff changeset	463 void set_mt_processing(bool mt) { _processing_is_mt = mt; }
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // whether all enqueuing of weak references is complete
a61af66fc99e Initial load duke parents: diff changeset	466 bool enqueuing_is_done() { return _enqueuing_is_done; }
a61af66fc99e Initial load duke parents: diff changeset	467 void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 // iterate over oops
a61af66fc99e Initial load duke parents: diff changeset	470 void weak_oops_do(OopClosure* f); // weak roots
a61af66fc99e Initial load duke parents: diff changeset	471
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	472 // Balance each of the discovered lists.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	473 void balance_all_queues();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	474 void verify_list(DiscoveredList& ref_list);
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	475
0 a61af66fc99e Initial load duke parents: diff changeset	476 // Discover a Reference object, using appropriate discovery criteria
a61af66fc99e Initial load duke parents: diff changeset	477 bool discover_reference(oop obj, ReferenceType rt);
a61af66fc99e Initial load duke parents: diff changeset	478
a61af66fc99e Initial load duke parents: diff changeset	479 // Process references found during GC (called by the garbage collector)
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	480 ReferenceProcessorStats
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	481 process_discovered_references(BoolObjectClosure* is_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	482 OopClosure* keep_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	483 VoidClosure* complete_gc,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6725 diff changeset	484 AbstractRefProcTaskExecutor* task_executor,
20190 0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	485 GCTimer *gc_timer,
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps brutisso parents: 17976 diff changeset	486 GCId gc_id);
0 a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // Enqueue references at end of GC (called by the garbage collector)
a61af66fc99e Initial load duke parents: diff changeset	489 bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
a61af66fc99e Initial load duke parents: diff changeset	490
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	491 // 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	492 // 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	493 // 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	494 void abandon_partial_discovery();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	495
0 a61af66fc99e Initial load duke parents: diff changeset	496 // debugging
a61af66fc99e Initial load duke parents: diff changeset	497 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	498 void verify_referent(oop obj) PRODUCT_RETURN;
0 a61af66fc99e Initial load duke parents: diff changeset	499
a61af66fc99e Initial load duke parents: diff changeset	500 // clear the discovered lists (unlinking each entry).
a61af66fc99e Initial load duke parents: diff changeset	501 void clear_discovered_references() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	502 };
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 // A utility class to disable reference discovery in
a61af66fc99e Initial load duke parents: diff changeset	505 // the scope which contains it, for given ReferenceProcessor.
a61af66fc99e Initial load duke parents: diff changeset	506 class NoRefDiscovery: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	507 private:
a61af66fc99e Initial load duke parents: diff changeset	508 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	509 bool _was_discovering_refs;
a61af66fc99e Initial load duke parents: diff changeset	510 public:
a61af66fc99e Initial load duke parents: diff changeset	511 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	512 _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	513 if (_was_discovering_refs) {
0 a61af66fc99e Initial load duke parents: diff changeset	514 _rp->disable_discovery();
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 ~NoRefDiscovery() {
a61af66fc99e Initial load duke parents: diff changeset	519 if (_was_discovering_refs) {
3979 4dfb2df418f2 6484982: G1: process references during evacuation pauses johnc parents: 3917 diff changeset	520 _rp->enable_discovery(true /verify_disabled/, false /check_no_refs/);
0 a61af66fc99e Initial load duke parents: diff changeset	521 }
a61af66fc99e Initial load duke parents: diff changeset	522 }
a61af66fc99e Initial load duke parents: diff changeset	523 };
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 // A utility class to temporarily mutate the span of the
a61af66fc99e Initial load duke parents: diff changeset	527 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	528 class ReferenceProcessorSpanMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	529 private:
a61af66fc99e Initial load duke parents: diff changeset	530 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	531 MemRegion _saved_span;
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 public:
a61af66fc99e Initial load duke parents: diff changeset	534 ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	535 MemRegion span):
a61af66fc99e Initial load duke parents: diff changeset	536 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	537 _saved_span = _rp->span();
a61af66fc99e Initial load duke parents: diff changeset	538 _rp->set_span(span);
a61af66fc99e Initial load duke parents: diff changeset	539 }
a61af66fc99e Initial load duke parents: diff changeset	540
a61af66fc99e Initial load duke parents: diff changeset	541 ~ReferenceProcessorSpanMutator() {
a61af66fc99e Initial load duke parents: diff changeset	542 _rp->set_span(_saved_span);
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 // A utility class to temporarily change the MT'ness of
a61af66fc99e Initial load duke parents: diff changeset	547 // reference discovery for the given ReferenceProcessor
a61af66fc99e Initial load duke parents: diff changeset	548 // in the scope that contains it.
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	549 class ReferenceProcessorMTDiscoveryMutator: StackObj {
0 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 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 public:
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	555 ReferenceProcessorMTDiscoveryMutator(ReferenceProcessor* rp,
92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	556 bool mt):
0 a61af66fc99e Initial load duke parents: diff changeset	557 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	558 _saved_mt = _rp->discovery_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	559 _rp->set_mt_discovery(mt);
a61af66fc99e Initial load duke parents: diff changeset	560 }
a61af66fc99e Initial load duke parents: diff changeset	561
2369 92da084fefc9 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads ysr parents: 1995 diff changeset	562 ~ReferenceProcessorMTDiscoveryMutator() {
0 a61af66fc99e Initial load duke parents: diff changeset	563 _rp->set_mt_discovery(_saved_mt);
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
a61af66fc99e Initial load duke parents: diff changeset	568 // A utility class to temporarily change the disposition
a61af66fc99e Initial load duke parents: diff changeset	569 // of the "is_alive_non_header" closure field of the
a61af66fc99e Initial load duke parents: diff changeset	570 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	571 class ReferenceProcessorIsAliveMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	572 private:
a61af66fc99e Initial load duke parents: diff changeset	573 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	574 BoolObjectClosure* _saved_cl;
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576 public:
a61af66fc99e Initial load duke parents: diff changeset	577 ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	578 BoolObjectClosure* cl):
a61af66fc99e Initial load duke parents: diff changeset	579 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	580 _saved_cl = _rp->is_alive_non_header();
a61af66fc99e Initial load duke parents: diff changeset	581 _rp->set_is_alive_non_header(cl);
a61af66fc99e Initial load duke parents: diff changeset	582 }
a61af66fc99e Initial load duke parents: diff changeset	583
a61af66fc99e Initial load duke parents: diff changeset	584 ~ReferenceProcessorIsAliveMutator() {
a61af66fc99e Initial load duke parents: diff changeset	585 _rp->set_is_alive_non_header(_saved_cl);
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 "discovery_is_atomic" 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 ReferenceProcessorAtomicMutator: 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 bool _saved_atomic_discovery;
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 ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	599 bool atomic):
a61af66fc99e Initial load duke parents: diff changeset	600 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	601 _saved_atomic_discovery = _rp->discovery_is_atomic();
a61af66fc99e Initial load duke parents: diff changeset	602 _rp->set_atomic_discovery(atomic);
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 ~ReferenceProcessorAtomicMutator() {
a61af66fc99e Initial load duke parents: diff changeset	606 _rp->set_atomic_discovery(_saved_atomic_discovery);
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
a61af66fc99e Initial load duke parents: diff changeset	611 // A utility class to temporarily change the MT processing
a61af66fc99e Initial load duke parents: diff changeset	612 // disposition of the given ReferenceProcessor instance
a61af66fc99e Initial load duke parents: diff changeset	613 // in the scope that contains it.
a61af66fc99e Initial load duke parents: diff changeset	614 class ReferenceProcessorMTProcMutator: StackObj {
a61af66fc99e Initial load duke parents: diff changeset	615 private:
a61af66fc99e Initial load duke parents: diff changeset	616 ReferenceProcessor* _rp;
a61af66fc99e Initial load duke parents: diff changeset	617 bool _saved_mt;
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 public:
a61af66fc99e Initial load duke parents: diff changeset	620 ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	621 bool mt):
a61af66fc99e Initial load duke parents: diff changeset	622 _rp(rp) {
a61af66fc99e Initial load duke parents: diff changeset	623 _saved_mt = _rp->processing_is_mt();
a61af66fc99e Initial load duke parents: diff changeset	624 _rp->set_mt_processing(mt);
a61af66fc99e Initial load duke parents: diff changeset	625 }
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 ~ReferenceProcessorMTProcMutator() {
a61af66fc99e Initial load duke parents: diff changeset	628 _rp->set_mt_processing(_saved_mt);
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
a61af66fc99e Initial load duke parents: diff changeset	633 // This class is an interface used to implement task execution for the
a61af66fc99e Initial load duke parents: diff changeset	634 // reference processing.
a61af66fc99e Initial load duke parents: diff changeset	635 class AbstractRefProcTaskExecutor {
a61af66fc99e Initial load duke parents: diff changeset	636 public:
a61af66fc99e Initial load duke parents: diff changeset	637
a61af66fc99e Initial load duke parents: diff changeset	638 // Abstract tasks to execute.
a61af66fc99e Initial load duke parents: diff changeset	639 class ProcessTask;
a61af66fc99e Initial load duke parents: diff changeset	640 class EnqueueTask;
a61af66fc99e Initial load duke parents: diff changeset	641
a61af66fc99e Initial load duke parents: diff changeset	642 // Executes a task using worker threads.
a61af66fc99e Initial load duke parents: diff changeset	643 virtual void execute(ProcessTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	644 virtual void execute(EnqueueTask& task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 // Switch to single threaded mode.
a61af66fc99e Initial load duke parents: diff changeset	647 virtual void set_single_threaded_mode() { };
a61af66fc99e Initial load duke parents: diff changeset	648 };
a61af66fc99e Initial load duke parents: diff changeset	649
a61af66fc99e Initial load duke parents: diff changeset	650 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	651 class AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load duke parents: diff changeset	652 protected:
a61af66fc99e Initial load duke parents: diff changeset	653 ProcessTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	654 DiscoveredList refs_lists[],
a61af66fc99e Initial load duke parents: diff changeset	655 bool marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	656 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	657 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	658 _marks_oops_alive(marks_oops_alive)
a61af66fc99e Initial load duke parents: diff changeset	659 { }
a61af66fc99e Initial load duke parents: diff changeset	660
a61af66fc99e Initial load duke parents: diff changeset	661 public:
a61af66fc99e Initial load duke parents: diff changeset	662 virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
a61af66fc99e Initial load duke parents: diff changeset	663 OopClosure& keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	664 VoidClosure& complete_gc) = 0;
a61af66fc99e Initial load duke parents: diff changeset	665
a61af66fc99e Initial load duke parents: diff changeset	666 // Returns true if a task marks some oops as alive.
a61af66fc99e Initial load duke parents: diff changeset	667 bool marks_oops_alive() const
a61af66fc99e Initial load duke parents: diff changeset	668 { return _marks_oops_alive; }
a61af66fc99e Initial load duke parents: diff changeset	669
a61af66fc99e Initial load duke parents: diff changeset	670 protected:
a61af66fc99e Initial load duke parents: diff changeset	671 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	672 DiscoveredList* _refs_lists;
a61af66fc99e Initial load duke parents: diff changeset	673 const bool _marks_oops_alive;
a61af66fc99e Initial load duke parents: diff changeset	674 };
a61af66fc99e Initial load duke parents: diff changeset	675
a61af66fc99e Initial load duke parents: diff changeset	676 // Abstract reference processing task to execute.
a61af66fc99e Initial load duke parents: diff changeset	677 class AbstractRefProcTaskExecutor::EnqueueTask {
a61af66fc99e Initial load duke parents: diff changeset	678 protected:
a61af66fc99e Initial load duke parents: diff changeset	679 EnqueueTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load duke parents: diff changeset	680 DiscoveredList refs_lists[],
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	681 HeapWord* pending_list_addr,
0 a61af66fc99e Initial load duke parents: diff changeset	682 int n_queues)
a61af66fc99e Initial load duke parents: diff changeset	683 : _ref_processor(ref_processor),
a61af66fc99e Initial load duke parents: diff changeset	684 _refs_lists(refs_lists),
a61af66fc99e Initial load duke parents: diff changeset	685 _pending_list_addr(pending_list_addr),
a61af66fc99e Initial load duke parents: diff changeset	686 _n_queues(n_queues)
a61af66fc99e Initial load duke parents: diff changeset	687 { }
a61af66fc99e Initial load duke parents: diff changeset	688
a61af66fc99e Initial load duke parents: diff changeset	689 public:
a61af66fc99e Initial load duke parents: diff changeset	690 virtual void work(unsigned int work_id) = 0;
a61af66fc99e Initial load duke parents: diff changeset	691
a61af66fc99e Initial load duke parents: diff changeset	692 protected:
a61af66fc99e Initial load duke parents: diff changeset	693 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load duke parents: diff changeset	694 DiscoveredList* _refs_lists;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	695 HeapWord* _pending_list_addr;
0 a61af66fc99e Initial load duke parents: diff changeset	696 int _n_queues;
a61af66fc99e Initial load duke parents: diff changeset	697 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	698
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1843 diff changeset	699 #endif // SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP

Mercurial > hg > truffle

annotate src/share/vm/memory/referenceProcessor.hpp @ 20543:e7d0505c8a30