annotate src/share/vm/memory/referenceProcessor.hpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children 8df09fb45352
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
2 * Copyright (c) 2001, 2010, 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;
a61af66fc99e Initial load
duke
parents:
diff changeset
51 class DiscoveredList;
a61af66fc99e Initial load
duke
parents:
diff changeset
52
a61af66fc99e Initial load
duke
parents:
diff changeset
53 class ReferenceProcessor : public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
54 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
55 // End of list marker
a61af66fc99e Initial load
duke
parents:
diff changeset
56 static oop _sentinelRef;
a61af66fc99e Initial load
duke
parents:
diff changeset
57 MemRegion _span; // (right-open) interval of heap
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // subject to wkref discovery
a61af66fc99e Initial load
duke
parents:
diff changeset
59 bool _discovering_refs; // true when discovery enabled
a61af66fc99e Initial load
duke
parents:
diff changeset
60 bool _discovery_is_atomic; // if discovery is atomic wrt
a61af66fc99e Initial load
duke
parents:
diff changeset
61 // other collectors in configuration
a61af66fc99e Initial load
duke
parents:
diff changeset
62 bool _discovery_is_mt; // true if reference discovery is MT.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
63 // 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
64 // 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
65 // 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
66 // 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
67 // long-term concurrent marking phase that does weak reference
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
68 // discovery.)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
69 bool _discovered_list_needs_barrier;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
70 BarrierSet* _bs; // Cached copy of BarrierSet.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
71 bool _enqueuing_is_done; // true if all weak references enqueued
a61af66fc99e Initial load
duke
parents:
diff changeset
72 bool _processing_is_mt; // true during phases when
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // reference processing is MT.
a61af66fc99e Initial load
duke
parents:
diff changeset
74 int _next_id; // round-robin counter in
a61af66fc99e Initial load
duke
parents:
diff changeset
75 // support of work distribution
a61af66fc99e Initial load
duke
parents:
diff changeset
76
a61af66fc99e Initial load
duke
parents:
diff changeset
77 // For collectors that do not keep GC marking information
a61af66fc99e Initial load
duke
parents:
diff changeset
78 // in the object header, this field holds a closure that
a61af66fc99e Initial load
duke
parents:
diff changeset
79 // helps the reference processor determine the reachability
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // of an oop (the field is currently initialized to NULL for
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // all collectors but the CMS collector).
a61af66fc99e Initial load
duke
parents:
diff changeset
82 BoolObjectClosure* _is_alive_non_header;
a61af66fc99e Initial load
duke
parents:
diff changeset
83
453
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
84 // Soft ref clearing policies
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
85 // . the default policy
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
86 static ReferencePolicy* _default_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
87 // . the "clear all" policy
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
88 static ReferencePolicy* _always_clear_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
89 // . the current policy below is either one of the above
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
90 ReferencePolicy* _current_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
91
0
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // 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
93
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
94 // The active MT'ness degree of the queues below
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
95 int _num_q;
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
96 // The maximum MT'ness degree of the queues below
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
97 int _max_num_q;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
98 // Arrays of lists of oops, one per thread
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
99 DiscoveredList* _discoveredSoftRefs;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
100 DiscoveredList* _discoveredWeakRefs;
a61af66fc99e Initial load
duke
parents:
diff changeset
101 DiscoveredList* _discoveredFinalRefs;
a61af66fc99e Initial load
duke
parents:
diff changeset
102 DiscoveredList* _discoveredPhantomRefs;
a61af66fc99e Initial load
duke
parents:
diff changeset
103
a61af66fc99e Initial load
duke
parents:
diff changeset
104 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
105 int num_q() { return _num_q; }
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
106 void set_mt_degree(int v) { _num_q = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
107 DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
108 static oop sentinel_ref() { return _sentinelRef; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
109 static oop* adr_sentinel_ref() { return &_sentinelRef; }
457
27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 453
diff changeset
110 ReferencePolicy* setup_policy(bool always_clear) {
453
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
111 _current_soft_ref_policy = always_clear ?
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
112 _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
113 _current_soft_ref_policy->setup(); // snapshot the policy threshold
453
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
114 return _current_soft_ref_policy;
c96030fff130 6684579: SoftReference processing can be made more efficient
ysr
parents: 356
diff changeset
115 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
116
a61af66fc99e Initial load
duke
parents:
diff changeset
117 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // Process references with a certain reachability level.
a61af66fc99e Initial load
duke
parents:
diff changeset
119 void process_discovered_reflist(DiscoveredList refs_lists[],
a61af66fc99e Initial load
duke
parents:
diff changeset
120 ReferencePolicy* policy,
a61af66fc99e Initial load
duke
parents:
diff changeset
121 bool clear_referent,
a61af66fc99e Initial load
duke
parents:
diff changeset
122 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
123 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
124 VoidClosure* complete_gc,
a61af66fc99e Initial load
duke
parents:
diff changeset
125 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load
duke
parents:
diff changeset
126
a61af66fc99e Initial load
duke
parents:
diff changeset
127 void process_phaseJNI(BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
128 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
129 VoidClosure* complete_gc);
a61af66fc99e Initial load
duke
parents:
diff changeset
130
a61af66fc99e Initial load
duke
parents:
diff changeset
131 // Work methods used by the method process_discovered_reflist
a61af66fc99e Initial load
duke
parents:
diff changeset
132 // Phase1: keep alive all those referents that are otherwise
a61af66fc99e Initial load
duke
parents:
diff changeset
133 // 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
134 void process_phase1(DiscoveredList& refs_list,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
135 ReferencePolicy* policy,
a61af66fc99e Initial load
duke
parents:
diff changeset
136 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
137 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
138 VoidClosure* complete_gc);
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // Phase2: remove all those references whose referents are
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // reachable.
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
141 inline void process_phase2(DiscoveredList& refs_list,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
142 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
143 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
144 VoidClosure* complete_gc) {
a61af66fc99e Initial load
duke
parents:
diff changeset
145 if (discovery_is_atomic()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
146 // 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
147 pp2_work(refs_list, is_alive, keep_alive);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
148 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
149 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
150 pp2_work_concurrent_discovery(refs_list, is_alive,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
151 keep_alive, complete_gc);
a61af66fc99e Initial load
duke
parents:
diff changeset
152 }
a61af66fc99e Initial load
duke
parents:
diff changeset
153 }
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // 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
155 void pp2_work(DiscoveredList& refs_list,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
156 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
157 OopClosure* keep_alive);
a61af66fc99e Initial load
duke
parents:
diff changeset
158 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
159 DiscoveredList& refs_list,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
160 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
161 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
162 VoidClosure* complete_gc);
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // Phase3: process the referents by either clearing them
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // 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
165 void process_phase3(DiscoveredList& refs_list,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
166 bool clear_referent,
a61af66fc99e Initial load
duke
parents:
diff changeset
167 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
168 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
169 VoidClosure* complete_gc);
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // 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
172 void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
173
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // "Preclean" all the discovered reference lists
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // by removing references with strongly reachable referents.
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // The first argument is a predicate on an oop that indicates
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // its (strong) reachability and the second is a closure that
a61af66fc99e Initial load
duke
parents:
diff changeset
178 // may be used to incrementalize or abort the precleaning process.
a61af66fc99e Initial load
duke
parents:
diff changeset
179 // The caller is responsible for taking care of potential
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // interference with concurrent operations on these lists
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // (or predicates involved) by other threads. Currently
1190
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 457
diff changeset
182 // only used by the CMS collector. should_unload_classes is
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 457
diff changeset
183 // used to aid assertion checking when classes are collected.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
184 void preclean_discovered_references(BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
185 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
186 VoidClosure* complete_gc,
1190
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 457
diff changeset
187 YieldClosure* yield,
4788266644c1 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 457
diff changeset
188 bool should_unload_classes);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
189
a61af66fc99e Initial load
duke
parents:
diff changeset
190 // Delete entries in the discovered lists that have
a61af66fc99e Initial load
duke
parents:
diff changeset
191 // either a null referent or are not active. Such
a61af66fc99e Initial load
duke
parents:
diff changeset
192 // Reference objects can result from the clearing
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // or enqueueing of Reference objects concurrent
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // with their discovery by a (concurrent) collector.
a61af66fc99e Initial load
duke
parents:
diff changeset
195 // For a definition of "active" see java.lang.ref.Reference;
a61af66fc99e Initial load
duke
parents:
diff changeset
196 // Refs are born active, become inactive when enqueued,
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // and never become active again. The state of being
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // active is encoded as follows: A Ref is active
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // if and only if its "next" field is NULL.
a61af66fc99e Initial load
duke
parents:
diff changeset
200 void clean_up_discovered_references();
a61af66fc99e Initial load
duke
parents:
diff changeset
201 void clean_up_discovered_reflist(DiscoveredList& refs_list);
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 // Returns the name of the discovered reference list
a61af66fc99e Initial load
duke
parents:
diff changeset
204 // occupying the i / _num_q slot.
a61af66fc99e Initial load
duke
parents:
diff changeset
205 const char* list_name(int i);
a61af66fc99e Initial load
duke
parents:
diff changeset
206
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
207 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
208
0
a61af66fc99e Initial load
duke
parents:
diff changeset
209 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // "Preclean" the given discovered reference list
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // by removing references with strongly reachable referents.
a61af66fc99e Initial load
duke
parents:
diff changeset
212 // Currently used in support of CMS only.
a61af66fc99e Initial load
duke
parents:
diff changeset
213 void preclean_discovered_reflist(DiscoveredList& refs_list,
a61af66fc99e Initial load
duke
parents:
diff changeset
214 BoolObjectClosure* is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
215 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
216 VoidClosure* complete_gc,
a61af66fc99e Initial load
duke
parents:
diff changeset
217 YieldClosure* yield);
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 int next_id() {
a61af66fc99e Initial load
duke
parents:
diff changeset
220 int id = _next_id;
a61af66fc99e Initial load
duke
parents:
diff changeset
221 if (++_next_id == _num_q) {
a61af66fc99e Initial load
duke
parents:
diff changeset
222 _next_id = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
223 }
a61af66fc99e Initial load
duke
parents:
diff changeset
224 return id;
a61af66fc99e Initial load
duke
parents:
diff changeset
225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
226 DiscoveredList* get_discovered_list(ReferenceType rt);
a61af66fc99e Initial load
duke
parents:
diff changeset
227 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
228 HeapWord* discovered_addr);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
229 void verify_ok_to_handle_reflists() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
230
a61af66fc99e Initial load
duke
parents:
diff changeset
231 void abandon_partial_discovered_list(DiscoveredList& refs_list);
a61af66fc99e Initial load
duke
parents:
diff changeset
232
a61af66fc99e Initial load
duke
parents:
diff changeset
233 // Calculate the number of jni handles.
a61af66fc99e Initial load
duke
parents:
diff changeset
234 unsigned int count_jni_refs();
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 // Balances reference queues.
a61af66fc99e Initial load
duke
parents:
diff changeset
237 void balance_queues(DiscoveredList ref_lists[]);
a61af66fc99e Initial load
duke
parents:
diff changeset
238
a61af66fc99e Initial load
duke
parents:
diff changeset
239 // Update (advance) the soft ref master clock field.
a61af66fc99e Initial load
duke
parents:
diff changeset
240 void update_soft_ref_master_clock();
a61af66fc99e Initial load
duke
parents:
diff changeset
241
a61af66fc99e Initial load
duke
parents:
diff changeset
242 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
243 // constructor
a61af66fc99e Initial load
duke
parents:
diff changeset
244 ReferenceProcessor():
a61af66fc99e Initial load
duke
parents:
diff changeset
245 _span((HeapWord*)NULL, (HeapWord*)NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
246 _discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
247 _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
248 _discovering_refs(false),
a61af66fc99e Initial load
duke
parents:
diff changeset
249 _discovery_is_atomic(true),
a61af66fc99e Initial load
duke
parents:
diff changeset
250 _enqueuing_is_done(false),
a61af66fc99e Initial load
duke
parents:
diff changeset
251 _discovery_is_mt(false),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
252 _discovered_list_needs_barrier(false),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
253 _bs(NULL),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
254 _is_alive_non_header(NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
255 _num_q(0),
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
256 _max_num_q(0),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
257 _processing_is_mt(false),
a61af66fc99e Initial load
duke
parents:
diff changeset
258 _next_id(0)
a61af66fc99e Initial load
duke
parents:
diff changeset
259 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
260
a61af66fc99e Initial load
duke
parents:
diff changeset
261 ReferenceProcessor(MemRegion span, bool atomic_discovery,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
262 bool mt_discovery,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
263 int mt_degree = 1,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
264 bool mt_processing = false,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
265 bool discovered_list_needs_barrier = false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
266
a61af66fc99e Initial load
duke
parents:
diff changeset
267 // Allocates and initializes a reference processor.
a61af66fc99e Initial load
duke
parents:
diff changeset
268 static ReferenceProcessor* create_ref_processor(
a61af66fc99e Initial load
duke
parents:
diff changeset
269 MemRegion span,
a61af66fc99e Initial load
duke
parents:
diff changeset
270 bool atomic_discovery,
a61af66fc99e Initial load
duke
parents:
diff changeset
271 bool mt_discovery,
a61af66fc99e Initial load
duke
parents:
diff changeset
272 BoolObjectClosure* is_alive_non_header = NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
273 int parallel_gc_threads = 1,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
274 bool mt_processing = false,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
275 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
276
0
a61af66fc99e Initial load
duke
parents:
diff changeset
277 // RefDiscoveryPolicy values
1244
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 1190
diff changeset
278 enum DiscoveryPolicy {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
279 ReferenceBasedDiscovery = 0,
1244
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 1190
diff changeset
280 ReferentBasedDiscovery = 1,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 1190
diff changeset
281 DiscoveryPolicyMin = ReferenceBasedDiscovery,
745c853ee57f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 1190
diff changeset
282 DiscoveryPolicyMax = ReferentBasedDiscovery
0
a61af66fc99e Initial load
duke
parents:
diff changeset
283 };
a61af66fc99e Initial load
duke
parents:
diff changeset
284
a61af66fc99e Initial load
duke
parents:
diff changeset
285 static void init_statics();
a61af66fc99e Initial load
duke
parents:
diff changeset
286
a61af66fc99e Initial load
duke
parents:
diff changeset
287 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
288 // get and set "is_alive_non_header" field
a61af66fc99e Initial load
duke
parents:
diff changeset
289 BoolObjectClosure* is_alive_non_header() {
a61af66fc99e Initial load
duke
parents:
diff changeset
290 return _is_alive_non_header;
a61af66fc99e Initial load
duke
parents:
diff changeset
291 }
a61af66fc99e Initial load
duke
parents:
diff changeset
292 void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
a61af66fc99e Initial load
duke
parents:
diff changeset
293 _is_alive_non_header = is_alive_non_header;
a61af66fc99e Initial load
duke
parents:
diff changeset
294 }
a61af66fc99e Initial load
duke
parents:
diff changeset
295
a61af66fc99e Initial load
duke
parents:
diff changeset
296 // get and set span
a61af66fc99e Initial load
duke
parents:
diff changeset
297 MemRegion span() { return _span; }
a61af66fc99e Initial load
duke
parents:
diff changeset
298 void set_span(MemRegion span) { _span = span; }
a61af66fc99e Initial load
duke
parents:
diff changeset
299
a61af66fc99e Initial load
duke
parents:
diff changeset
300 // start and stop weak ref discovery
a61af66fc99e Initial load
duke
parents:
diff changeset
301 void enable_discovery() { _discovering_refs = true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
302 void disable_discovery() { _discovering_refs = false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
303 bool discovery_enabled() { return _discovering_refs; }
a61af66fc99e Initial load
duke
parents:
diff changeset
304
a61af66fc99e Initial load
duke
parents:
diff changeset
305 // whether discovery is atomic wrt other collectors
a61af66fc99e Initial load
duke
parents:
diff changeset
306 bool discovery_is_atomic() const { return _discovery_is_atomic; }
a61af66fc99e Initial load
duke
parents:
diff changeset
307 void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
a61af66fc99e Initial load
duke
parents:
diff changeset
308
a61af66fc99e Initial load
duke
parents:
diff changeset
309 // whether discovery is done by multiple threads same-old-timeously
a61af66fc99e Initial load
duke
parents:
diff changeset
310 bool discovery_is_mt() const { return _discovery_is_mt; }
a61af66fc99e Initial load
duke
parents:
diff changeset
311 void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
a61af66fc99e Initial load
duke
parents:
diff changeset
312
a61af66fc99e Initial load
duke
parents:
diff changeset
313 // Whether we are in a phase when _processing_ is MT.
a61af66fc99e Initial load
duke
parents:
diff changeset
314 bool processing_is_mt() const { return _processing_is_mt; }
a61af66fc99e Initial load
duke
parents:
diff changeset
315 void set_mt_processing(bool mt) { _processing_is_mt = mt; }
a61af66fc99e Initial load
duke
parents:
diff changeset
316
a61af66fc99e Initial load
duke
parents:
diff changeset
317 // whether all enqueuing of weak references is complete
a61af66fc99e Initial load
duke
parents:
diff changeset
318 bool enqueuing_is_done() { return _enqueuing_is_done; }
a61af66fc99e Initial load
duke
parents:
diff changeset
319 void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
a61af66fc99e Initial load
duke
parents:
diff changeset
320
a61af66fc99e Initial load
duke
parents:
diff changeset
321 // iterate over oops
a61af66fc99e Initial load
duke
parents:
diff changeset
322 void weak_oops_do(OopClosure* f); // weak roots
a61af66fc99e Initial load
duke
parents:
diff changeset
323 static void oops_do(OopClosure* f); // strong root(s)
a61af66fc99e Initial load
duke
parents:
diff changeset
324
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
325 // Balance each of the discovered lists.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
326 void balance_all_queues();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
327
0
a61af66fc99e Initial load
duke
parents:
diff changeset
328 // Discover a Reference object, using appropriate discovery criteria
a61af66fc99e Initial load
duke
parents:
diff changeset
329 bool discover_reference(oop obj, ReferenceType rt);
a61af66fc99e Initial load
duke
parents:
diff changeset
330
a61af66fc99e Initial load
duke
parents:
diff changeset
331 // 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
332 void process_discovered_references(BoolObjectClosure* is_alive,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
333 OopClosure* keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
334 VoidClosure* complete_gc,
a61af66fc99e Initial load
duke
parents:
diff changeset
335 AbstractRefProcTaskExecutor* task_executor);
a61af66fc99e Initial load
duke
parents:
diff changeset
336
a61af66fc99e Initial load
duke
parents:
diff changeset
337 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
338 // Enqueue references at end of GC (called by the garbage collector)
a61af66fc99e Initial load
duke
parents:
diff changeset
339 bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
340
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
341 // 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
342 // 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
343 // 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
344 void abandon_partial_discovery();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
345
0
a61af66fc99e Initial load
duke
parents:
diff changeset
346 // debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
347 void verify_no_references_recorded() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
348 static void verify();
a61af66fc99e Initial load
duke
parents:
diff changeset
349
a61af66fc99e Initial load
duke
parents:
diff changeset
350 // clear the discovered lists (unlinking each entry).
a61af66fc99e Initial load
duke
parents:
diff changeset
351 void clear_discovered_references() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
352 };
a61af66fc99e Initial load
duke
parents:
diff changeset
353
a61af66fc99e Initial load
duke
parents:
diff changeset
354 // A utility class to disable reference discovery in
a61af66fc99e Initial load
duke
parents:
diff changeset
355 // the scope which contains it, for given ReferenceProcessor.
a61af66fc99e Initial load
duke
parents:
diff changeset
356 class NoRefDiscovery: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
357 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
358 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
359 bool _was_discovering_refs;
a61af66fc99e Initial load
duke
parents:
diff changeset
360 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
361 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
362 _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
363 if (_was_discovering_refs) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
364 _rp->disable_discovery();
a61af66fc99e Initial load
duke
parents:
diff changeset
365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
366 }
a61af66fc99e Initial load
duke
parents:
diff changeset
367
a61af66fc99e Initial load
duke
parents:
diff changeset
368 ~NoRefDiscovery() {
a61af66fc99e Initial load
duke
parents:
diff changeset
369 if (_was_discovering_refs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
370 _rp->enable_discovery();
a61af66fc99e Initial load
duke
parents:
diff changeset
371 }
a61af66fc99e Initial load
duke
parents:
diff changeset
372 }
a61af66fc99e Initial load
duke
parents:
diff changeset
373 };
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // A utility class to temporarily mutate the span of the
a61af66fc99e Initial load
duke
parents:
diff changeset
377 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load
duke
parents:
diff changeset
378 class ReferenceProcessorSpanMutator: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
379 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
380 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
381 MemRegion _saved_span;
a61af66fc99e Initial load
duke
parents:
diff changeset
382
a61af66fc99e Initial load
duke
parents:
diff changeset
383 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
384 ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load
duke
parents:
diff changeset
385 MemRegion span):
a61af66fc99e Initial load
duke
parents:
diff changeset
386 _rp(rp) {
a61af66fc99e Initial load
duke
parents:
diff changeset
387 _saved_span = _rp->span();
a61af66fc99e Initial load
duke
parents:
diff changeset
388 _rp->set_span(span);
a61af66fc99e Initial load
duke
parents:
diff changeset
389 }
a61af66fc99e Initial load
duke
parents:
diff changeset
390
a61af66fc99e Initial load
duke
parents:
diff changeset
391 ~ReferenceProcessorSpanMutator() {
a61af66fc99e Initial load
duke
parents:
diff changeset
392 _rp->set_span(_saved_span);
a61af66fc99e Initial load
duke
parents:
diff changeset
393 }
a61af66fc99e Initial load
duke
parents:
diff changeset
394 };
a61af66fc99e Initial load
duke
parents:
diff changeset
395
a61af66fc99e Initial load
duke
parents:
diff changeset
396 // A utility class to temporarily change the MT'ness of
a61af66fc99e Initial load
duke
parents:
diff changeset
397 // reference discovery for the given ReferenceProcessor
a61af66fc99e Initial load
duke
parents:
diff changeset
398 // in the scope that contains it.
a61af66fc99e Initial load
duke
parents:
diff changeset
399 class ReferenceProcessorMTMutator: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
400 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
401 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
402 bool _saved_mt;
a61af66fc99e Initial load
duke
parents:
diff changeset
403
a61af66fc99e Initial load
duke
parents:
diff changeset
404 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
405 ReferenceProcessorMTMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load
duke
parents:
diff changeset
406 bool mt):
a61af66fc99e Initial load
duke
parents:
diff changeset
407 _rp(rp) {
a61af66fc99e Initial load
duke
parents:
diff changeset
408 _saved_mt = _rp->discovery_is_mt();
a61af66fc99e Initial load
duke
parents:
diff changeset
409 _rp->set_mt_discovery(mt);
a61af66fc99e Initial load
duke
parents:
diff changeset
410 }
a61af66fc99e Initial load
duke
parents:
diff changeset
411
a61af66fc99e Initial load
duke
parents:
diff changeset
412 ~ReferenceProcessorMTMutator() {
a61af66fc99e Initial load
duke
parents:
diff changeset
413 _rp->set_mt_discovery(_saved_mt);
a61af66fc99e Initial load
duke
parents:
diff changeset
414 }
a61af66fc99e Initial load
duke
parents:
diff changeset
415 };
a61af66fc99e Initial load
duke
parents:
diff changeset
416
a61af66fc99e Initial load
duke
parents:
diff changeset
417
a61af66fc99e Initial load
duke
parents:
diff changeset
418 // A utility class to temporarily change the disposition
a61af66fc99e Initial load
duke
parents:
diff changeset
419 // of the "is_alive_non_header" closure field of the
a61af66fc99e Initial load
duke
parents:
diff changeset
420 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load
duke
parents:
diff changeset
421 class ReferenceProcessorIsAliveMutator: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
422 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
423 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
424 BoolObjectClosure* _saved_cl;
a61af66fc99e Initial load
duke
parents:
diff changeset
425
a61af66fc99e Initial load
duke
parents:
diff changeset
426 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
427 ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load
duke
parents:
diff changeset
428 BoolObjectClosure* cl):
a61af66fc99e Initial load
duke
parents:
diff changeset
429 _rp(rp) {
a61af66fc99e Initial load
duke
parents:
diff changeset
430 _saved_cl = _rp->is_alive_non_header();
a61af66fc99e Initial load
duke
parents:
diff changeset
431 _rp->set_is_alive_non_header(cl);
a61af66fc99e Initial load
duke
parents:
diff changeset
432 }
a61af66fc99e Initial load
duke
parents:
diff changeset
433
a61af66fc99e Initial load
duke
parents:
diff changeset
434 ~ReferenceProcessorIsAliveMutator() {
a61af66fc99e Initial load
duke
parents:
diff changeset
435 _rp->set_is_alive_non_header(_saved_cl);
a61af66fc99e Initial load
duke
parents:
diff changeset
436 }
a61af66fc99e Initial load
duke
parents:
diff changeset
437 };
a61af66fc99e Initial load
duke
parents:
diff changeset
438
a61af66fc99e Initial load
duke
parents:
diff changeset
439 // A utility class to temporarily change the disposition
a61af66fc99e Initial load
duke
parents:
diff changeset
440 // of the "discovery_is_atomic" field of the
a61af66fc99e Initial load
duke
parents:
diff changeset
441 // given ReferenceProcessor in the scope that contains it.
a61af66fc99e Initial load
duke
parents:
diff changeset
442 class ReferenceProcessorAtomicMutator: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
443 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
444 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
445 bool _saved_atomic_discovery;
a61af66fc99e Initial load
duke
parents:
diff changeset
446
a61af66fc99e Initial load
duke
parents:
diff changeset
447 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
448 ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load
duke
parents:
diff changeset
449 bool atomic):
a61af66fc99e Initial load
duke
parents:
diff changeset
450 _rp(rp) {
a61af66fc99e Initial load
duke
parents:
diff changeset
451 _saved_atomic_discovery = _rp->discovery_is_atomic();
a61af66fc99e Initial load
duke
parents:
diff changeset
452 _rp->set_atomic_discovery(atomic);
a61af66fc99e Initial load
duke
parents:
diff changeset
453 }
a61af66fc99e Initial load
duke
parents:
diff changeset
454
a61af66fc99e Initial load
duke
parents:
diff changeset
455 ~ReferenceProcessorAtomicMutator() {
a61af66fc99e Initial load
duke
parents:
diff changeset
456 _rp->set_atomic_discovery(_saved_atomic_discovery);
a61af66fc99e Initial load
duke
parents:
diff changeset
457 }
a61af66fc99e Initial load
duke
parents:
diff changeset
458 };
a61af66fc99e Initial load
duke
parents:
diff changeset
459
a61af66fc99e Initial load
duke
parents:
diff changeset
460
a61af66fc99e Initial load
duke
parents:
diff changeset
461 // A utility class to temporarily change the MT processing
a61af66fc99e Initial load
duke
parents:
diff changeset
462 // disposition of the given ReferenceProcessor instance
a61af66fc99e Initial load
duke
parents:
diff changeset
463 // in the scope that contains it.
a61af66fc99e Initial load
duke
parents:
diff changeset
464 class ReferenceProcessorMTProcMutator: StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
465 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
466 ReferenceProcessor* _rp;
a61af66fc99e Initial load
duke
parents:
diff changeset
467 bool _saved_mt;
a61af66fc99e Initial load
duke
parents:
diff changeset
468
a61af66fc99e Initial load
duke
parents:
diff changeset
469 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
470 ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
a61af66fc99e Initial load
duke
parents:
diff changeset
471 bool mt):
a61af66fc99e Initial load
duke
parents:
diff changeset
472 _rp(rp) {
a61af66fc99e Initial load
duke
parents:
diff changeset
473 _saved_mt = _rp->processing_is_mt();
a61af66fc99e Initial load
duke
parents:
diff changeset
474 _rp->set_mt_processing(mt);
a61af66fc99e Initial load
duke
parents:
diff changeset
475 }
a61af66fc99e Initial load
duke
parents:
diff changeset
476
a61af66fc99e Initial load
duke
parents:
diff changeset
477 ~ReferenceProcessorMTProcMutator() {
a61af66fc99e Initial load
duke
parents:
diff changeset
478 _rp->set_mt_processing(_saved_mt);
a61af66fc99e Initial load
duke
parents:
diff changeset
479 }
a61af66fc99e Initial load
duke
parents:
diff changeset
480 };
a61af66fc99e Initial load
duke
parents:
diff changeset
481
a61af66fc99e Initial load
duke
parents:
diff changeset
482
a61af66fc99e Initial load
duke
parents:
diff changeset
483 // This class is an interface used to implement task execution for the
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // reference processing.
a61af66fc99e Initial load
duke
parents:
diff changeset
485 class AbstractRefProcTaskExecutor {
a61af66fc99e Initial load
duke
parents:
diff changeset
486 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
487
a61af66fc99e Initial load
duke
parents:
diff changeset
488 // Abstract tasks to execute.
a61af66fc99e Initial load
duke
parents:
diff changeset
489 class ProcessTask;
a61af66fc99e Initial load
duke
parents:
diff changeset
490 class EnqueueTask;
a61af66fc99e Initial load
duke
parents:
diff changeset
491
a61af66fc99e Initial load
duke
parents:
diff changeset
492 // Executes a task using worker threads.
a61af66fc99e Initial load
duke
parents:
diff changeset
493 virtual void execute(ProcessTask& task) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
494 virtual void execute(EnqueueTask& task) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
495
a61af66fc99e Initial load
duke
parents:
diff changeset
496 // Switch to single threaded mode.
a61af66fc99e Initial load
duke
parents:
diff changeset
497 virtual void set_single_threaded_mode() { };
a61af66fc99e Initial load
duke
parents:
diff changeset
498 };
a61af66fc99e Initial load
duke
parents:
diff changeset
499
a61af66fc99e Initial load
duke
parents:
diff changeset
500 // Abstract reference processing task to execute.
a61af66fc99e Initial load
duke
parents:
diff changeset
501 class AbstractRefProcTaskExecutor::ProcessTask {
a61af66fc99e Initial load
duke
parents:
diff changeset
502 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
503 ProcessTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load
duke
parents:
diff changeset
504 DiscoveredList refs_lists[],
a61af66fc99e Initial load
duke
parents:
diff changeset
505 bool marks_oops_alive)
a61af66fc99e Initial load
duke
parents:
diff changeset
506 : _ref_processor(ref_processor),
a61af66fc99e Initial load
duke
parents:
diff changeset
507 _refs_lists(refs_lists),
a61af66fc99e Initial load
duke
parents:
diff changeset
508 _marks_oops_alive(marks_oops_alive)
a61af66fc99e Initial load
duke
parents:
diff changeset
509 { }
a61af66fc99e Initial load
duke
parents:
diff changeset
510
a61af66fc99e Initial load
duke
parents:
diff changeset
511 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
512 virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
513 OopClosure& keep_alive,
a61af66fc99e Initial load
duke
parents:
diff changeset
514 VoidClosure& complete_gc) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
515
a61af66fc99e Initial load
duke
parents:
diff changeset
516 // Returns true if a task marks some oops as alive.
a61af66fc99e Initial load
duke
parents:
diff changeset
517 bool marks_oops_alive() const
a61af66fc99e Initial load
duke
parents:
diff changeset
518 { return _marks_oops_alive; }
a61af66fc99e Initial load
duke
parents:
diff changeset
519
a61af66fc99e Initial load
duke
parents:
diff changeset
520 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
521 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load
duke
parents:
diff changeset
522 DiscoveredList* _refs_lists;
a61af66fc99e Initial load
duke
parents:
diff changeset
523 const bool _marks_oops_alive;
a61af66fc99e Initial load
duke
parents:
diff changeset
524 };
a61af66fc99e Initial load
duke
parents:
diff changeset
525
a61af66fc99e Initial load
duke
parents:
diff changeset
526 // Abstract reference processing task to execute.
a61af66fc99e Initial load
duke
parents:
diff changeset
527 class AbstractRefProcTaskExecutor::EnqueueTask {
a61af66fc99e Initial load
duke
parents:
diff changeset
528 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
529 EnqueueTask(ReferenceProcessor& ref_processor,
a61af66fc99e Initial load
duke
parents:
diff changeset
530 DiscoveredList refs_lists[],
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
531 HeapWord* pending_list_addr,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
532 oop sentinel_ref,
a61af66fc99e Initial load
duke
parents:
diff changeset
533 int n_queues)
a61af66fc99e Initial load
duke
parents:
diff changeset
534 : _ref_processor(ref_processor),
a61af66fc99e Initial load
duke
parents:
diff changeset
535 _refs_lists(refs_lists),
a61af66fc99e Initial load
duke
parents:
diff changeset
536 _pending_list_addr(pending_list_addr),
a61af66fc99e Initial load
duke
parents:
diff changeset
537 _sentinel_ref(sentinel_ref),
a61af66fc99e Initial load
duke
parents:
diff changeset
538 _n_queues(n_queues)
a61af66fc99e Initial load
duke
parents:
diff changeset
539 { }
a61af66fc99e Initial load
duke
parents:
diff changeset
540
a61af66fc99e Initial load
duke
parents:
diff changeset
541 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
542 virtual void work(unsigned int work_id) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
543
a61af66fc99e Initial load
duke
parents:
diff changeset
544 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
545 ReferenceProcessor& _ref_processor;
a61af66fc99e Initial load
duke
parents:
diff changeset
546 DiscoveredList* _refs_lists;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
547 HeapWord* _pending_list_addr;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
548 oop _sentinel_ref;
a61af66fc99e Initial load
duke
parents:
diff changeset
549 int _n_queues;
a61af66fc99e Initial load
duke
parents:
diff changeset
550 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1843
diff changeset
551
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1843
diff changeset
552 #endif // SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP