Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/referenceProcessor.hpp @ 453:c96030fff130
6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 16:56:09 -0800 |
| parents | 1ee8caae33af |
| children | 27a80744a83b |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2001-2008 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // ReferenceProcessor class encapsulates the per-"collector" processing | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
26 // of java.lang.Reference objects for GC. The interface is useful for supporting |
| 0 | 27 // a generational abstraction, in particular when there are multiple |
| 28 // generations that are being independently collected -- possibly | |
| 29 // concurrently and/or incrementally. Note, however, that the | |
| 30 // ReferenceProcessor class abstracts away from a generational setting | |
| 31 // by using only a heap interval (called "span" below), thus allowing | |
| 32 // its use in a straightforward manner in a general, non-generational | |
| 33 // setting. | |
| 34 // | |
| 35 // The basic idea is that each ReferenceProcessor object concerns | |
| 36 // itself with ("weak") reference processing in a specific "span" | |
| 37 // of the heap of interest to a specific collector. Currently, | |
| 38 // the span is a convex interval of the heap, but, efficiency | |
| 39 // apart, there seems to be no reason it couldn't be extended | |
| 40 // (with appropriate modifications) to any "non-convex interval". | |
| 41 | |
| 42 // forward references | |
| 43 class ReferencePolicy; | |
| 44 class AbstractRefProcTaskExecutor; | |
| 45 class DiscoveredList; | |
| 46 | |
| 47 class ReferenceProcessor : public CHeapObj { | |
| 48 protected: | |
| 49 // End of list marker | |
| 50 static oop _sentinelRef; | |
| 51 MemRegion _span; // (right-open) interval of heap | |
| 52 // subject to wkref discovery | |
| 53 bool _discovering_refs; // true when discovery enabled | |
| 54 bool _discovery_is_atomic; // if discovery is atomic wrt | |
| 55 // other collectors in configuration | |
| 56 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
|
57 // 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
|
58 // 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
|
59 // 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
|
60 // 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
|
61 // long-term concurrent marking phase that does weak reference |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
62 // discovery.) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
63 bool _discovered_list_needs_barrier; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
64 BarrierSet* _bs; // Cached copy of BarrierSet. |
| 0 | 65 bool _enqueuing_is_done; // true if all weak references enqueued |
| 66 bool _processing_is_mt; // true during phases when | |
| 67 // reference processing is MT. | |
| 68 int _next_id; // round-robin counter in | |
| 69 // support of work distribution | |
| 70 | |
| 71 // For collectors that do not keep GC marking information | |
| 72 // in the object header, this field holds a closure that | |
| 73 // helps the reference processor determine the reachability | |
| 74 // of an oop (the field is currently initialized to NULL for | |
| 75 // all collectors but the CMS collector). | |
| 76 BoolObjectClosure* _is_alive_non_header; | |
| 77 | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
78 // Soft ref clearing policies |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
79 // . the default policy |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
80 static ReferencePolicy* _default_soft_ref_policy; |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
81 // . the "clear all" policy |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
82 static ReferencePolicy* _always_clear_soft_ref_policy; |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
83 // . the current policy below is either one of the above |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
84 ReferencePolicy* _current_soft_ref_policy; |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
85 |
| 0 | 86 // 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
|
87 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
88 // The MT'ness degree of the queues below |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
89 int _num_q; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
90 // 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
|
91 DiscoveredList* _discoveredSoftRefs; |
| 0 | 92 DiscoveredList* _discoveredWeakRefs; |
| 93 DiscoveredList* _discoveredFinalRefs; | |
| 94 DiscoveredList* _discoveredPhantomRefs; | |
| 95 | |
| 96 public: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
97 int num_q() { return _num_q; } |
| 0 | 98 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
|
99 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
|
100 static oop* adr_sentinel_ref() { return &_sentinelRef; } |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
101 ReferencePolicy* snap_policy(bool always_clear) { |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
102 _current_soft_ref_policy = always_clear ? |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
103 _always_clear_soft_ref_policy : _default_soft_ref_policy; |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
104 _current_soft_ref_policy->snap(); // snapshot the policy threshold |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
105 return _current_soft_ref_policy; |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
106 } |
| 0 | 107 |
| 108 public: | |
| 109 // Process references with a certain reachability level. | |
| 110 void process_discovered_reflist(DiscoveredList refs_lists[], | |
| 111 ReferencePolicy* policy, | |
| 112 bool clear_referent, | |
| 113 BoolObjectClosure* is_alive, | |
| 114 OopClosure* keep_alive, | |
| 115 VoidClosure* complete_gc, | |
| 116 AbstractRefProcTaskExecutor* task_executor); | |
| 117 | |
| 118 void process_phaseJNI(BoolObjectClosure* is_alive, | |
| 119 OopClosure* keep_alive, | |
| 120 VoidClosure* complete_gc); | |
| 121 | |
| 122 // Work methods used by the method process_discovered_reflist | |
| 123 // Phase1: keep alive all those referents that are otherwise | |
| 124 // 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
|
125 void process_phase1(DiscoveredList& refs_list, |
| 0 | 126 ReferencePolicy* policy, |
| 127 BoolObjectClosure* is_alive, | |
| 128 OopClosure* keep_alive, | |
| 129 VoidClosure* complete_gc); | |
| 130 // Phase2: remove all those references whose referents are | |
| 131 // reachable. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
132 inline void process_phase2(DiscoveredList& refs_list, |
| 0 | 133 BoolObjectClosure* is_alive, |
| 134 OopClosure* keep_alive, | |
| 135 VoidClosure* complete_gc) { | |
| 136 if (discovery_is_atomic()) { | |
| 137 // 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
|
138 pp2_work(refs_list, is_alive, keep_alive); |
| 0 | 139 } else { |
| 140 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
|
141 pp2_work_concurrent_discovery(refs_list, is_alive, |
| 0 | 142 keep_alive, complete_gc); |
| 143 } | |
| 144 } | |
| 145 // 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
|
146 void pp2_work(DiscoveredList& refs_list, |
| 0 | 147 BoolObjectClosure* is_alive, |
| 148 OopClosure* keep_alive); | |
| 149 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
|
150 DiscoveredList& refs_list, |
| 0 | 151 BoolObjectClosure* is_alive, |
| 152 OopClosure* keep_alive, | |
| 153 VoidClosure* complete_gc); | |
| 154 // Phase3: process the referents by either clearing them | |
| 155 // 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
|
156 void process_phase3(DiscoveredList& refs_list, |
| 0 | 157 bool clear_referent, |
| 158 BoolObjectClosure* is_alive, | |
| 159 OopClosure* keep_alive, | |
| 160 VoidClosure* complete_gc); | |
| 161 | |
| 162 // 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
|
163 void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr); |
| 0 | 164 |
| 165 // "Preclean" all the discovered reference lists | |
| 166 // by removing references with strongly reachable referents. | |
| 167 // The first argument is a predicate on an oop that indicates | |
| 168 // its (strong) reachability and the second is a closure that | |
| 169 // may be used to incrementalize or abort the precleaning process. | |
| 170 // The caller is responsible for taking care of potential | |
| 171 // interference with concurrent operations on these lists | |
| 172 // (or predicates involved) by other threads. Currently | |
| 173 // only used by the CMS collector. | |
| 174 void preclean_discovered_references(BoolObjectClosure* is_alive, | |
| 175 OopClosure* keep_alive, | |
| 176 VoidClosure* complete_gc, | |
| 177 YieldClosure* yield); | |
| 178 | |
| 179 // Delete entries in the discovered lists that have | |
| 180 // either a null referent or are not active. Such | |
| 181 // Reference objects can result from the clearing | |
| 182 // or enqueueing of Reference objects concurrent | |
| 183 // with their discovery by a (concurrent) collector. | |
| 184 // For a definition of "active" see java.lang.ref.Reference; | |
| 185 // Refs are born active, become inactive when enqueued, | |
| 186 // and never become active again. The state of being | |
| 187 // active is encoded as follows: A Ref is active | |
| 188 // if and only if its "next" field is NULL. | |
| 189 void clean_up_discovered_references(); | |
| 190 void clean_up_discovered_reflist(DiscoveredList& refs_list); | |
| 191 | |
| 192 // Returns the name of the discovered reference list | |
| 193 // occupying the i / _num_q slot. | |
| 194 const char* list_name(int i); | |
| 195 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
196 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
|
197 |
| 0 | 198 protected: |
| 199 // "Preclean" the given discovered reference list | |
| 200 // by removing references with strongly reachable referents. | |
| 201 // Currently used in support of CMS only. | |
| 202 void preclean_discovered_reflist(DiscoveredList& refs_list, | |
| 203 BoolObjectClosure* is_alive, | |
| 204 OopClosure* keep_alive, | |
| 205 VoidClosure* complete_gc, | |
| 206 YieldClosure* yield); | |
| 207 | |
| 208 int next_id() { | |
| 209 int id = _next_id; | |
| 210 if (++_next_id == _num_q) { | |
| 211 _next_id = 0; | |
| 212 } | |
| 213 return id; | |
| 214 } | |
| 215 DiscoveredList* get_discovered_list(ReferenceType rt); | |
| 216 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
|
217 HeapWord* discovered_addr); |
| 0 | 218 void verify_ok_to_handle_reflists() PRODUCT_RETURN; |
| 219 | |
| 220 void abandon_partial_discovered_list(DiscoveredList& refs_list); | |
| 221 | |
| 222 // Calculate the number of jni handles. | |
| 223 unsigned int count_jni_refs(); | |
| 224 | |
| 225 // Balances reference queues. | |
| 226 void balance_queues(DiscoveredList ref_lists[]); | |
| 227 | |
| 228 // Update (advance) the soft ref master clock field. | |
| 229 void update_soft_ref_master_clock(); | |
| 230 | |
| 231 public: | |
| 232 // constructor | |
| 233 ReferenceProcessor(): | |
| 234 _span((HeapWord*)NULL, (HeapWord*)NULL), | |
| 235 _discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL), | |
| 236 _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL), | |
| 237 _discovering_refs(false), | |
| 238 _discovery_is_atomic(true), | |
| 239 _enqueuing_is_done(false), | |
| 240 _discovery_is_mt(false), | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
241 _discovered_list_needs_barrier(false), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
242 _bs(NULL), |
| 0 | 243 _is_alive_non_header(NULL), |
| 244 _num_q(0), | |
| 245 _processing_is_mt(false), | |
| 246 _next_id(0) | |
| 247 {} | |
| 248 | |
| 249 ReferenceProcessor(MemRegion span, bool atomic_discovery, | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
250 bool mt_discovery, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
251 int mt_degree = 1, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
252 bool mt_processing = false, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
253 bool discovered_list_needs_barrier = false); |
| 0 | 254 |
| 255 // Allocates and initializes a reference processor. | |
| 256 static ReferenceProcessor* create_ref_processor( | |
| 257 MemRegion span, | |
| 258 bool atomic_discovery, | |
| 259 bool mt_discovery, | |
| 260 BoolObjectClosure* is_alive_non_header = NULL, | |
| 261 int parallel_gc_threads = 1, | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
262 bool mt_processing = false, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
263 bool discovered_list_needs_barrier = false); |
| 0 | 264 // RefDiscoveryPolicy values |
| 265 enum { | |
| 266 ReferenceBasedDiscovery = 0, | |
| 267 ReferentBasedDiscovery = 1 | |
| 268 }; | |
| 269 | |
| 270 static void init_statics(); | |
| 271 | |
| 272 public: | |
| 273 // get and set "is_alive_non_header" field | |
| 274 BoolObjectClosure* is_alive_non_header() { | |
| 275 return _is_alive_non_header; | |
| 276 } | |
| 277 void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) { | |
| 278 _is_alive_non_header = is_alive_non_header; | |
| 279 } | |
| 280 | |
| 281 // get and set span | |
| 282 MemRegion span() { return _span; } | |
| 283 void set_span(MemRegion span) { _span = span; } | |
| 284 | |
| 285 // start and stop weak ref discovery | |
| 286 void enable_discovery() { _discovering_refs = true; } | |
| 287 void disable_discovery() { _discovering_refs = false; } | |
| 288 bool discovery_enabled() { return _discovering_refs; } | |
| 289 | |
| 290 // whether discovery is atomic wrt other collectors | |
| 291 bool discovery_is_atomic() const { return _discovery_is_atomic; } | |
| 292 void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; } | |
| 293 | |
| 294 // whether discovery is done by multiple threads same-old-timeously | |
| 295 bool discovery_is_mt() const { return _discovery_is_mt; } | |
| 296 void set_mt_discovery(bool mt) { _discovery_is_mt = mt; } | |
| 297 | |
| 298 // Whether we are in a phase when _processing_ is MT. | |
| 299 bool processing_is_mt() const { return _processing_is_mt; } | |
| 300 void set_mt_processing(bool mt) { _processing_is_mt = mt; } | |
| 301 | |
| 302 // whether all enqueuing of weak references is complete | |
| 303 bool enqueuing_is_done() { return _enqueuing_is_done; } | |
| 304 void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; } | |
| 305 | |
| 306 // iterate over oops | |
| 307 void weak_oops_do(OopClosure* f); // weak roots | |
| 308 static void oops_do(OopClosure* f); // strong root(s) | |
| 309 | |
| 310 // Discover a Reference object, using appropriate discovery criteria | |
| 311 bool discover_reference(oop obj, ReferenceType rt); | |
| 312 | |
| 313 // 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
|
314 void process_discovered_references(BoolObjectClosure* is_alive, |
| 0 | 315 OopClosure* keep_alive, |
| 316 VoidClosure* complete_gc, | |
| 317 AbstractRefProcTaskExecutor* task_executor); | |
| 318 | |
| 319 public: | |
| 320 // Enqueue references at end of GC (called by the garbage collector) | |
| 321 bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL); | |
| 322 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
323 // 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
|
324 // 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
|
325 // 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
|
326 void abandon_partial_discovery(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
327 |
| 0 | 328 // debugging |
| 329 void verify_no_references_recorded() PRODUCT_RETURN; | |
| 330 static void verify(); | |
| 331 | |
| 332 // clear the discovered lists (unlinking each entry). | |
| 333 void clear_discovered_references() PRODUCT_RETURN; | |
| 334 }; | |
| 335 | |
| 336 // A utility class to disable reference discovery in | |
| 337 // the scope which contains it, for given ReferenceProcessor. | |
| 338 class NoRefDiscovery: StackObj { | |
| 339 private: | |
| 340 ReferenceProcessor* _rp; | |
| 341 bool _was_discovering_refs; | |
| 342 public: | |
| 343 NoRefDiscovery(ReferenceProcessor* rp) : _rp(rp) { | |
| 344 if (_was_discovering_refs = _rp->discovery_enabled()) { | |
| 345 _rp->disable_discovery(); | |
| 346 } | |
| 347 } | |
| 348 | |
| 349 ~NoRefDiscovery() { | |
| 350 if (_was_discovering_refs) { | |
| 351 _rp->enable_discovery(); | |
| 352 } | |
| 353 } | |
| 354 }; | |
| 355 | |
| 356 | |
| 357 // A utility class to temporarily mutate the span of the | |
| 358 // given ReferenceProcessor in the scope that contains it. | |
| 359 class ReferenceProcessorSpanMutator: StackObj { | |
| 360 private: | |
| 361 ReferenceProcessor* _rp; | |
| 362 MemRegion _saved_span; | |
| 363 | |
| 364 public: | |
| 365 ReferenceProcessorSpanMutator(ReferenceProcessor* rp, | |
| 366 MemRegion span): | |
| 367 _rp(rp) { | |
| 368 _saved_span = _rp->span(); | |
| 369 _rp->set_span(span); | |
| 370 } | |
| 371 | |
| 372 ~ReferenceProcessorSpanMutator() { | |
| 373 _rp->set_span(_saved_span); | |
| 374 } | |
| 375 }; | |
| 376 | |
| 377 // A utility class to temporarily change the MT'ness of | |
| 378 // reference discovery for the given ReferenceProcessor | |
| 379 // in the scope that contains it. | |
| 380 class ReferenceProcessorMTMutator: StackObj { | |
| 381 private: | |
| 382 ReferenceProcessor* _rp; | |
| 383 bool _saved_mt; | |
| 384 | |
| 385 public: | |
| 386 ReferenceProcessorMTMutator(ReferenceProcessor* rp, | |
| 387 bool mt): | |
| 388 _rp(rp) { | |
| 389 _saved_mt = _rp->discovery_is_mt(); | |
| 390 _rp->set_mt_discovery(mt); | |
| 391 } | |
| 392 | |
| 393 ~ReferenceProcessorMTMutator() { | |
| 394 _rp->set_mt_discovery(_saved_mt); | |
| 395 } | |
| 396 }; | |
| 397 | |
| 398 | |
| 399 // A utility class to temporarily change the disposition | |
| 400 // of the "is_alive_non_header" closure field of the | |
| 401 // given ReferenceProcessor in the scope that contains it. | |
| 402 class ReferenceProcessorIsAliveMutator: StackObj { | |
| 403 private: | |
| 404 ReferenceProcessor* _rp; | |
| 405 BoolObjectClosure* _saved_cl; | |
| 406 | |
| 407 public: | |
| 408 ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp, | |
| 409 BoolObjectClosure* cl): | |
| 410 _rp(rp) { | |
| 411 _saved_cl = _rp->is_alive_non_header(); | |
| 412 _rp->set_is_alive_non_header(cl); | |
| 413 } | |
| 414 | |
| 415 ~ReferenceProcessorIsAliveMutator() { | |
| 416 _rp->set_is_alive_non_header(_saved_cl); | |
| 417 } | |
| 418 }; | |
| 419 | |
| 420 // A utility class to temporarily change the disposition | |
| 421 // of the "discovery_is_atomic" field of the | |
| 422 // given ReferenceProcessor in the scope that contains it. | |
| 423 class ReferenceProcessorAtomicMutator: StackObj { | |
| 424 private: | |
| 425 ReferenceProcessor* _rp; | |
| 426 bool _saved_atomic_discovery; | |
| 427 | |
| 428 public: | |
| 429 ReferenceProcessorAtomicMutator(ReferenceProcessor* rp, | |
| 430 bool atomic): | |
| 431 _rp(rp) { | |
| 432 _saved_atomic_discovery = _rp->discovery_is_atomic(); | |
| 433 _rp->set_atomic_discovery(atomic); | |
| 434 } | |
| 435 | |
| 436 ~ReferenceProcessorAtomicMutator() { | |
| 437 _rp->set_atomic_discovery(_saved_atomic_discovery); | |
| 438 } | |
| 439 }; | |
| 440 | |
| 441 | |
| 442 // A utility class to temporarily change the MT processing | |
| 443 // disposition of the given ReferenceProcessor instance | |
| 444 // in the scope that contains it. | |
| 445 class ReferenceProcessorMTProcMutator: StackObj { | |
| 446 private: | |
| 447 ReferenceProcessor* _rp; | |
| 448 bool _saved_mt; | |
| 449 | |
| 450 public: | |
| 451 ReferenceProcessorMTProcMutator(ReferenceProcessor* rp, | |
| 452 bool mt): | |
| 453 _rp(rp) { | |
| 454 _saved_mt = _rp->processing_is_mt(); | |
| 455 _rp->set_mt_processing(mt); | |
| 456 } | |
| 457 | |
| 458 ~ReferenceProcessorMTProcMutator() { | |
| 459 _rp->set_mt_processing(_saved_mt); | |
| 460 } | |
| 461 }; | |
| 462 | |
| 463 | |
| 464 // This class is an interface used to implement task execution for the | |
| 465 // reference processing. | |
| 466 class AbstractRefProcTaskExecutor { | |
| 467 public: | |
| 468 | |
| 469 // Abstract tasks to execute. | |
| 470 class ProcessTask; | |
| 471 class EnqueueTask; | |
| 472 | |
| 473 // Executes a task using worker threads. | |
| 474 virtual void execute(ProcessTask& task) = 0; | |
| 475 virtual void execute(EnqueueTask& task) = 0; | |
| 476 | |
| 477 // Switch to single threaded mode. | |
| 478 virtual void set_single_threaded_mode() { }; | |
| 479 }; | |
| 480 | |
| 481 // Abstract reference processing task to execute. | |
| 482 class AbstractRefProcTaskExecutor::ProcessTask { | |
| 483 protected: | |
| 484 ProcessTask(ReferenceProcessor& ref_processor, | |
| 485 DiscoveredList refs_lists[], | |
| 486 bool marks_oops_alive) | |
| 487 : _ref_processor(ref_processor), | |
| 488 _refs_lists(refs_lists), | |
| 489 _marks_oops_alive(marks_oops_alive) | |
| 490 { } | |
| 491 | |
| 492 public: | |
| 493 virtual void work(unsigned int work_id, BoolObjectClosure& is_alive, | |
| 494 OopClosure& keep_alive, | |
| 495 VoidClosure& complete_gc) = 0; | |
| 496 | |
| 497 // Returns true if a task marks some oops as alive. | |
| 498 bool marks_oops_alive() const | |
| 499 { return _marks_oops_alive; } | |
| 500 | |
| 501 protected: | |
| 502 ReferenceProcessor& _ref_processor; | |
| 503 DiscoveredList* _refs_lists; | |
| 504 const bool _marks_oops_alive; | |
| 505 }; | |
| 506 | |
| 507 // Abstract reference processing task to execute. | |
| 508 class AbstractRefProcTaskExecutor::EnqueueTask { | |
| 509 protected: | |
| 510 EnqueueTask(ReferenceProcessor& ref_processor, | |
| 511 DiscoveredList refs_lists[], | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
512 HeapWord* pending_list_addr, |
| 0 | 513 oop sentinel_ref, |
| 514 int n_queues) | |
| 515 : _ref_processor(ref_processor), | |
| 516 _refs_lists(refs_lists), | |
| 517 _pending_list_addr(pending_list_addr), | |
| 518 _sentinel_ref(sentinel_ref), | |
| 519 _n_queues(n_queues) | |
| 520 { } | |
| 521 | |
| 522 public: | |
| 523 virtual void work(unsigned int work_id) = 0; | |
| 524 | |
| 525 protected: | |
| 526 ReferenceProcessor& _ref_processor; | |
| 527 DiscoveredList* _refs_lists; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
528 HeapWord* _pending_list_addr; |
| 0 | 529 oop _sentinel_ref; |
| 530 int _n_queues; | |
| 531 }; |