Mercurial > hg > graal-compiler
annotate src/share/vm/memory/genCollectedHeap.hpp @ 1941:79d04223b8a5
Added caching for resolved types and resolved fields.
This is crucial, because the local load elimination will lead to wrong results, if field equality (of two RiField objects with the same object and the same RiType) is not given. The caching makes sure that the default equals implementation is sufficient.
| author | Thomas Wuerthinger <wuerthinger@ssw.jku.at> |
|---|---|
| date | Tue, 28 Dec 2010 18:33:26 +0100 |
| parents | a7214d79fcf1 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
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:
1166
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 class SubTasksDone; | |
| 26 | |
| 27 // A "GenCollectedHeap" is a SharedHeap that uses generational | |
| 28 // collection. It is represented with a sequence of Generation's. | |
| 29 class GenCollectedHeap : public SharedHeap { | |
| 30 friend class GenCollectorPolicy; | |
| 31 friend class Generation; | |
| 32 friend class DefNewGeneration; | |
| 33 friend class TenuredGeneration; | |
| 34 friend class ConcurrentMarkSweepGeneration; | |
| 35 friend class CMSCollector; | |
| 36 friend class GenMarkSweep; | |
| 37 friend class VM_GenCollectForAllocation; | |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
38 friend class VM_GenCollectForPermanentAllocation; |
| 0 | 39 friend class VM_GenCollectFull; |
| 40 friend class VM_GenCollectFullConcurrent; | |
| 41 friend class VM_GC_HeapInspection; | |
| 42 friend class VM_HeapDumper; | |
| 43 friend class HeapInspection; | |
| 44 friend class GCCauseSetter; | |
| 45 friend class VMStructs; | |
| 46 public: | |
| 47 enum SomeConstants { | |
| 48 max_gens = 10 | |
| 49 }; | |
| 50 | |
| 51 friend class VM_PopulateDumpSharedSpace; | |
| 52 | |
| 53 protected: | |
| 54 // Fields: | |
| 55 static GenCollectedHeap* _gch; | |
| 56 | |
| 57 private: | |
| 58 int _n_gens; | |
| 59 Generation* _gens[max_gens]; | |
| 60 GenerationSpec** _gen_specs; | |
| 61 | |
| 62 // The generational collector policy. | |
| 63 GenCollectorPolicy* _gen_policy; | |
| 64 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
65 // Indicates that the most recent previous incremental collection failed. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
66 // The flag is cleared when an action is taken that might clear the |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
67 // condition that caused that incremental collection to fail. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
68 bool _incremental_collection_failed; |
| 0 | 69 |
| 70 // In support of ExplicitGCInvokesConcurrent functionality | |
| 71 unsigned int _full_collections_completed; | |
| 72 | |
| 73 // Data structure for claiming the (potentially) parallel tasks in | |
| 74 // (gen-specific) strong roots processing. | |
| 75 SubTasksDone* _gen_process_strong_tasks; | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
76 SubTasksDone* gen_process_strong_tasks() { return _gen_process_strong_tasks; } |
| 0 | 77 |
| 78 // In block contents verification, the number of header words to skip | |
| 79 NOT_PRODUCT(static size_t _skip_header_HeapWords;) | |
| 80 | |
| 81 // GC is not allowed during the dump of the shared classes. Keep track | |
| 82 // of this in order to provide an reasonable error message when terminating. | |
| 83 bool _preloading_shared_classes; | |
| 84 | |
| 85 protected: | |
| 86 // Directs each generation up to and including "collectedGen" to recompute | |
| 87 // its desired size. | |
| 88 void compute_new_generation_sizes(int collectedGen); | |
| 89 | |
| 90 // Helper functions for allocation | |
| 91 HeapWord* attempt_allocation(size_t size, | |
| 92 bool is_tlab, | |
| 93 bool first_only); | |
| 94 | |
| 95 // Helper function for two callbacks below. | |
| 96 // Considers collection of the first max_level+1 generations. | |
| 97 void do_collection(bool full, | |
| 98 bool clear_all_soft_refs, | |
| 99 size_t size, | |
| 100 bool is_tlab, | |
| 101 int max_level); | |
| 102 | |
| 103 // Callback from VM_GenCollectForAllocation operation. | |
| 104 // This function does everything necessary/possible to satisfy an | |
| 105 // allocation request that failed in the youngest generation that should | |
| 106 // have handled it (including collection, expansion, etc.) | |
| 107 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); | |
| 108 | |
| 109 // Callback from VM_GenCollectFull operation. | |
| 110 // Perform a full collection of the first max_level+1 generations. | |
| 111 void do_full_collection(bool clear_all_soft_refs, int max_level); | |
| 112 | |
| 113 // Does the "cause" of GC indicate that | |
| 114 // we absolutely __must__ clear soft refs? | |
| 115 bool must_clear_all_soft_refs(); | |
| 116 | |
| 117 public: | |
| 118 GenCollectedHeap(GenCollectorPolicy *policy); | |
| 119 | |
| 120 GCStats* gc_stats(int level) const; | |
| 121 | |
| 122 // Returns JNI_OK on success | |
| 123 virtual jint initialize(); | |
| 124 char* allocate(size_t alignment, PermanentGenerationSpec* perm_gen_spec, | |
| 125 size_t* _total_reserved, int* _n_covered_regions, | |
| 126 ReservedSpace* heap_rs); | |
| 127 | |
| 128 // Does operations required after initialization has been done. | |
| 129 void post_initialize(); | |
| 130 | |
| 131 // Initialize ("weak") refs processing support | |
| 132 virtual void ref_processing_init(); | |
| 133 | |
| 134 virtual CollectedHeap::Name kind() const { | |
| 135 return CollectedHeap::GenCollectedHeap; | |
| 136 } | |
| 137 | |
| 138 // The generational collector policy. | |
| 139 GenCollectorPolicy* gen_policy() const { return _gen_policy; } | |
| 140 | |
| 141 // Adaptive size policy | |
| 142 virtual AdaptiveSizePolicy* size_policy() { | |
| 143 return gen_policy()->size_policy(); | |
| 144 } | |
| 145 | |
| 146 size_t capacity() const; | |
| 147 size_t used() const; | |
| 148 | |
| 149 // Save the "used_region" for generations level and lower, | |
| 150 // and, if perm is true, for perm gen. | |
| 151 void save_used_regions(int level, bool perm); | |
| 152 | |
| 153 size_t max_capacity() const; | |
| 154 | |
| 155 HeapWord* mem_allocate(size_t size, | |
| 156 bool is_large_noref, | |
| 157 bool is_tlab, | |
| 158 bool* gc_overhead_limit_was_exceeded); | |
| 159 | |
| 160 // We may support a shared contiguous allocation area, if the youngest | |
| 161 // generation does. | |
| 162 bool supports_inline_contig_alloc() const; | |
| 163 HeapWord** top_addr() const; | |
| 164 HeapWord** end_addr() const; | |
| 165 | |
| 166 // Return an estimate of the maximum allocation that could be performed | |
| 167 // without triggering any collection activity. In a generational | |
| 168 // collector, for example, this is probably the largest allocation that | |
| 169 // could be supported in the youngest generation. It is "unsafe" because | |
| 170 // no locks are taken; the result should be treated as an approximation, | |
| 171 // not a guarantee. | |
| 172 size_t unsafe_max_alloc(); | |
| 173 | |
| 174 // Does this heap support heap inspection? (+PrintClassHistogram) | |
| 175 virtual bool supports_heap_inspection() const { return true; } | |
| 176 | |
| 177 // Perform a full collection of the heap; intended for use in implementing | |
| 178 // "System.gc". This implies as full a collection as the CollectedHeap | |
| 179 // supports. Caller does not hold the Heap_lock on entry. | |
| 180 void collect(GCCause::Cause cause); | |
| 181 | |
| 182 // This interface assumes that it's being called by the | |
| 183 // vm thread. It collects the heap assuming that the | |
| 184 // heap lock is already held and that we are executing in | |
| 185 // the context of the vm thread. | |
| 186 void collect_as_vm_thread(GCCause::Cause cause); | |
| 187 | |
| 188 // The same as above but assume that the caller holds the Heap_lock. | |
| 189 void collect_locked(GCCause::Cause cause); | |
| 190 | |
| 191 // Perform a full collection of the first max_level+1 generations. | |
| 192 // Mostly used for testing purposes. Caller does not hold the Heap_lock on entry. | |
| 193 void collect(GCCause::Cause cause, int max_level); | |
| 194 | |
| 195 // Returns "TRUE" iff "p" points into the allocated area of the heap. | |
| 196 // The methods is_in(), is_in_closed_subset() and is_in_youngest() may | |
| 197 // be expensive to compute in general, so, to prevent | |
| 198 // their inadvertent use in product jvm's, we restrict their use to | |
| 199 // assertion checking or verification only. | |
| 200 bool is_in(const void* p) const; | |
| 201 | |
| 202 // override | |
| 203 bool is_in_closed_subset(const void* p) const { | |
| 204 if (UseConcMarkSweepGC) { | |
| 205 return is_in_reserved(p); | |
| 206 } else { | |
| 207 return is_in(p); | |
| 208 } | |
| 209 } | |
| 210 | |
| 211 // Returns "TRUE" iff "p" points into the youngest generation. | |
| 212 bool is_in_youngest(void* p); | |
| 213 | |
| 214 // Iteration functions. | |
| 215 void oop_iterate(OopClosure* cl); | |
| 216 void oop_iterate(MemRegion mr, OopClosure* cl); | |
| 217 void object_iterate(ObjectClosure* cl); | |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
218 void safe_object_iterate(ObjectClosure* cl); |
| 0 | 219 void object_iterate_since_last_GC(ObjectClosure* cl); |
| 220 Space* space_containing(const void* addr) const; | |
| 221 | |
| 222 // A CollectedHeap is divided into a dense sequence of "blocks"; that is, | |
| 223 // each address in the (reserved) heap is a member of exactly | |
| 224 // one block. The defining characteristic of a block is that it is | |
| 225 // possible to find its size, and thus to progress forward to the next | |
| 226 // block. (Blocks may be of different sizes.) Thus, blocks may | |
| 227 // represent Java objects, or they might be free blocks in a | |
| 228 // free-list-based heap (or subheap), as long as the two kinds are | |
| 229 // distinguishable and the size of each is determinable. | |
| 230 | |
| 231 // Returns the address of the start of the "block" that contains the | |
| 232 // address "addr". We say "blocks" instead of "object" since some heaps | |
| 233 // may not pack objects densely; a chunk may either be an object or a | |
| 234 // non-object. | |
| 235 virtual HeapWord* block_start(const void* addr) const; | |
| 236 | |
| 237 // Requires "addr" to be the start of a chunk, and returns its size. | |
| 238 // "addr + size" is required to be the start of a new chunk, or the end | |
| 239 // of the active area of the heap. Assumes (and verifies in non-product | |
| 240 // builds) that addr is in the allocated part of the heap and is | |
| 241 // the start of a chunk. | |
| 242 virtual size_t block_size(const HeapWord* addr) const; | |
| 243 | |
| 244 // Requires "addr" to be the start of a block, and returns "TRUE" iff | |
| 245 // the block is an object. Assumes (and verifies in non-product | |
| 246 // builds) that addr is in the allocated part of the heap and is | |
| 247 // the start of a chunk. | |
| 248 virtual bool block_is_obj(const HeapWord* addr) const; | |
| 249 | |
| 250 // Section on TLAB's. | |
| 251 virtual bool supports_tlab_allocation() const; | |
| 252 virtual size_t tlab_capacity(Thread* thr) const; | |
| 253 virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; | |
| 254 virtual HeapWord* allocate_new_tlab(size_t size); | |
| 255 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
256 // Can a compiler initialize a new object without store barriers? |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
257 // This permission only extends from the creation of a new object |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
258 // via a TLAB up to the first subsequent safepoint. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
259 virtual bool can_elide_tlab_store_barriers() const { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
260 return true; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
261 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
262 |
| 1166 | 263 virtual bool card_mark_must_follow_store() const { |
| 264 return UseConcMarkSweepGC; | |
| 265 } | |
| 266 | |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
267 // We don't need barriers for stores to objects in the |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
268 // young gen and, a fortiori, for initializing stores to |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
269 // objects therein. This applies to {DefNew,ParNew}+{Tenured,CMS} |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
270 // only and may need to be re-examined in case other |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
271 // kinds of collectors are implemented in the future. |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
272 virtual bool can_elide_initializing_store_barrier(oop new_obj) { |
|
1028
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
273 // We wanted to assert that:- |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
274 // assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
275 // "Check can_elide_initializing_store_barrier() for this collector"); |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
276 // but unfortunately the flag UseSerialGC need not necessarily always |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
277 // be set when DefNew+Tenured are being used. |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
278 return is_in_youngest((void*)new_obj); |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
279 } |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
280 |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
281 // Can a compiler elide a store barrier when it writes |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
282 // a permanent oop into the heap? Applies when the compiler |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
283 // is storing x to the heap, where x->is_perm() is true. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
284 virtual bool can_elide_permanent_oop_store_barriers() const { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
285 // CMS needs to see all, even intra-generational, ref updates. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
286 return !UseConcMarkSweepGC; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
287 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
288 |
| 0 | 289 // The "requestor" generation is performing some garbage collection |
| 290 // action for which it would be useful to have scratch space. The | |
| 291 // requestor promises to allocate no more than "max_alloc_words" in any | |
| 292 // older generation (via promotion say.) Any blocks of space that can | |
| 293 // be provided are returned as a list of ScratchBlocks, sorted by | |
| 294 // decreasing size. | |
| 295 ScratchBlock* gather_scratch(Generation* requestor, size_t max_alloc_words); | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
296 // Allow each generation to reset any scratch space that it has |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
297 // contributed as it needs. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
298 void release_scratch(); |
| 0 | 299 |
| 300 size_t large_typearray_limit(); | |
| 301 | |
| 302 // Ensure parsability: override | |
| 303 virtual void ensure_parsability(bool retire_tlabs); | |
| 304 | |
| 305 // Time in ms since the longest time a collector ran in | |
| 306 // in any generation. | |
| 307 virtual jlong millis_since_last_gc(); | |
| 308 | |
| 309 // Total number of full collections completed. | |
| 310 unsigned int total_full_collections_completed() { | |
| 311 assert(_full_collections_completed <= _total_full_collections, | |
| 312 "Can't complete more collections than were started"); | |
| 313 return _full_collections_completed; | |
| 314 } | |
| 315 | |
| 316 // Update above counter, as appropriate, at the end of a stop-world GC cycle | |
| 317 unsigned int update_full_collections_completed(); | |
| 318 // Update above counter, as appropriate, at the end of a concurrent GC cycle | |
| 319 unsigned int update_full_collections_completed(unsigned int count); | |
| 320 | |
| 321 // Update "time of last gc" for all constituent generations | |
| 322 // to "now". | |
| 323 void update_time_of_last_gc(jlong now) { | |
| 324 for (int i = 0; i < _n_gens; i++) { | |
| 325 _gens[i]->update_time_of_last_gc(now); | |
| 326 } | |
| 327 perm_gen()->update_time_of_last_gc(now); | |
| 328 } | |
| 329 | |
| 330 // Update the gc statistics for each generation. | |
| 331 // "level" is the level of the lastest collection | |
| 332 void update_gc_stats(int current_level, bool full) { | |
| 333 for (int i = 0; i < _n_gens; i++) { | |
| 334 _gens[i]->update_gc_stats(current_level, full); | |
| 335 } | |
| 336 perm_gen()->update_gc_stats(current_level, full); | |
| 337 } | |
| 338 | |
| 339 // Override. | |
| 340 bool no_gc_in_progress() { return !is_gc_active(); } | |
| 341 | |
| 342 // Override. | |
| 343 void prepare_for_verify(); | |
| 344 | |
| 345 // Override. | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
346 void verify(bool allow_dirty, bool silent, bool /* option */); |
| 0 | 347 |
| 348 // Override. | |
| 349 void print() const; | |
| 350 void print_on(outputStream* st) const; | |
| 351 virtual void print_gc_threads_on(outputStream* st) const; | |
| 352 virtual void gc_threads_do(ThreadClosure* tc) const; | |
| 353 virtual void print_tracing_info() const; | |
| 354 | |
| 355 // PrintGC, PrintGCDetails support | |
| 356 void print_heap_change(size_t prev_used) const; | |
| 357 void print_perm_heap_change(size_t perm_prev_used) const; | |
| 358 | |
| 359 // The functions below are helper functions that a subclass of | |
| 360 // "CollectedHeap" can use in the implementation of its virtual | |
| 361 // functions. | |
| 362 | |
| 363 class GenClosure : public StackObj { | |
| 364 public: | |
| 365 virtual void do_generation(Generation* gen) = 0; | |
| 366 }; | |
| 367 | |
| 368 // Apply "cl.do_generation" to all generations in the heap (not including | |
| 369 // the permanent generation). If "old_to_young" determines the order. | |
| 370 void generation_iterate(GenClosure* cl, bool old_to_young); | |
| 371 | |
| 372 void space_iterate(SpaceClosure* cl); | |
| 373 | |
| 374 // Return "true" if all generations (but perm) have reached the | |
| 375 // maximal committed limit that they can reach, without a garbage | |
| 376 // collection. | |
| 377 virtual bool is_maximal_no_gc() const; | |
| 378 | |
| 379 // Return the generation before "gen", or else NULL. | |
| 380 Generation* prev_gen(Generation* gen) const { | |
| 381 int l = gen->level(); | |
| 382 if (l == 0) return NULL; | |
| 383 else return _gens[l-1]; | |
| 384 } | |
| 385 | |
| 386 // Return the generation after "gen", or else NULL. | |
| 387 Generation* next_gen(Generation* gen) const { | |
| 388 int l = gen->level() + 1; | |
| 389 if (l == _n_gens) return NULL; | |
| 390 else return _gens[l]; | |
| 391 } | |
| 392 | |
| 393 Generation* get_gen(int i) const { | |
| 394 if (i >= 0 && i < _n_gens) | |
| 395 return _gens[i]; | |
| 396 else | |
| 397 return NULL; | |
| 398 } | |
| 399 | |
| 400 int n_gens() const { | |
| 401 assert(_n_gens == gen_policy()->number_of_generations(), "Sanity"); | |
| 402 return _n_gens; | |
| 403 } | |
| 404 | |
| 405 // Convenience function to be used in situations where the heap type can be | |
| 406 // asserted to be this type. | |
| 407 static GenCollectedHeap* heap(); | |
| 408 | |
| 409 void set_par_threads(int t); | |
| 410 | |
| 411 | |
| 412 // Invoke the "do_oop" method of one of the closures "not_older_gens" | |
| 413 // or "older_gens" on root locations for the generation at | |
| 414 // "level". (The "older_gens" closure is used for scanning references | |
| 415 // from older generations; "not_older_gens" is used everywhere else.) | |
| 416 // If "younger_gens_as_roots" is false, younger generations are | |
| 417 // not scanned as roots; in this case, the caller must be arranging to | |
| 418 // scan the younger generations itself. (For example, a generation might | |
| 419 // explicitly mark reachable objects in younger generations, to avoid | |
| 420 // excess storage retention.) If "collecting_perm_gen" is false, then | |
| 421 // roots that may only contain references to permGen objects are not | |
| 422 // scanned. The "so" argument determines which of the roots | |
| 423 // the closure is applied to: | |
| 424 // "SO_None" does none; | |
| 425 // "SO_AllClasses" applies the closure to all entries in the SystemDictionary; | |
| 426 // "SO_SystemClasses" to all the "system" classes and loaders; | |
| 427 // "SO_Symbols_and_Strings" applies the closure to all entries in | |
| 428 // SymbolsTable and StringTable. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
429 void gen_process_strong_roots(int level, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
430 bool younger_gens_as_roots, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
431 // The remaining arguments are in an order |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
432 // consistent with SharedHeap::process_strong_roots: |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
433 bool activate_scope, |
| 0 | 434 bool collecting_perm_gen, |
| 435 SharedHeap::ScanningOption so, | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
436 OopsInGenClosure* not_older_gens, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
437 bool do_code_roots, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
438 OopsInGenClosure* older_gens); |
| 0 | 439 |
| 440 // Apply "blk" to all the weak roots of the system. These include | |
| 441 // JNI weak roots, the code cache, system dictionary, symbol table, | |
| 442 // string table, and referents of reachable weak refs. | |
| 443 void gen_process_weak_roots(OopClosure* root_closure, | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
845
diff
changeset
|
444 CodeBlobClosure* code_roots, |
| 0 | 445 OopClosure* non_root_closure); |
| 446 | |
| 447 // Set the saved marks of generations, if that makes sense. | |
| 448 // In particular, if any generation might iterate over the oops | |
| 449 // in other generations, it should call this method. | |
| 450 void save_marks(); | |
| 451 | |
| 452 // Apply "cur->do_oop" or "older->do_oop" to all the oops in objects | |
| 453 // allocated since the last call to save_marks in generations at or above | |
| 454 // "level" (including the permanent generation.) The "cur" closure is | |
| 455 // applied to references in the generation at "level", and the "older" | |
| 456 // closure to older (and permanent) generations. | |
| 457 #define GCH_SINCE_SAVE_MARKS_ITERATE_DECL(OopClosureType, nv_suffix) \ | |
| 458 void oop_since_save_marks_iterate(int level, \ | |
| 459 OopClosureType* cur, \ | |
| 460 OopClosureType* older); | |
| 461 | |
| 462 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL) | |
| 463 | |
| 464 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL | |
| 465 | |
| 466 // Returns "true" iff no allocations have occurred in any generation at | |
| 467 // "level" or above (including the permanent generation) since the last | |
| 468 // call to "save_marks". | |
| 469 bool no_allocs_since_save_marks(int level); | |
| 470 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
471 // Returns true if an incremental collection is likely to fail. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
472 bool incremental_collection_will_fail() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
473 // Assumes a 2-generation system; the first disjunct remembers if an |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
474 // incremental collection failed, even when we thought (second disjunct) |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
475 // that it would not. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
476 assert(heap()->collector_policy()->is_two_generation_policy(), |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
477 "the following definition may not be suitable for an n(>2)-generation system"); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
478 return incremental_collection_failed() || !get_gen(0)->collection_attempt_is_safe(); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
479 } |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
480 |
| 0 | 481 // If a generation bails out of an incremental collection, |
| 482 // it sets this flag. | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
483 bool incremental_collection_failed() const { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
484 return _incremental_collection_failed; |
| 0 | 485 } |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
486 void set_incremental_collection_failed() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
487 _incremental_collection_failed = true; |
| 0 | 488 } |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
489 void clear_incremental_collection_failed() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
490 _incremental_collection_failed = false; |
| 0 | 491 } |
| 492 | |
| 493 // Promotion of obj into gen failed. Try to promote obj to higher non-perm | |
| 494 // gens in ascending order; return the new location of obj if successful. | |
| 495 // Otherwise, try expand-and-allocate for obj in each generation starting at | |
| 496 // gen; return the new location of obj if successful. Otherwise, return NULL. | |
| 497 oop handle_failed_promotion(Generation* gen, | |
| 498 oop obj, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
499 size_t obj_size); |
| 0 | 500 |
| 501 private: | |
| 502 // Accessor for memory state verification support | |
| 503 NOT_PRODUCT( | |
| 504 static size_t skip_header_HeapWords() { return _skip_header_HeapWords; } | |
| 505 ) | |
| 506 | |
| 507 // Override | |
| 508 void check_for_non_bad_heap_word_value(HeapWord* addr, | |
| 509 size_t size) PRODUCT_RETURN; | |
| 510 | |
| 511 // For use by mark-sweep. As implemented, mark-sweep-compact is global | |
| 512 // in an essential way: compaction is performed across generations, by | |
| 513 // iterating over spaces. | |
| 514 void prepare_for_compaction(); | |
| 515 | |
| 516 // Perform a full collection of the first max_level+1 generations. | |
| 517 // This is the low level interface used by the public versions of | |
| 518 // collect() and collect_locked(). Caller holds the Heap_lock on entry. | |
| 519 void collect_locked(GCCause::Cause cause, int max_level); | |
| 520 | |
| 521 // Returns success or failure. | |
| 522 bool create_cms_collector(); | |
| 523 | |
| 524 // In support of ExplicitGCInvokesConcurrent functionality | |
| 525 bool should_do_concurrent_full_gc(GCCause::Cause cause); | |
| 526 void collect_mostly_concurrent(GCCause::Cause cause); | |
| 527 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
528 // Save the tops of the spaces in all generations |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
529 void record_gen_tops_before_GC() PRODUCT_RETURN; |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
530 |
| 0 | 531 protected: |
| 532 virtual void gc_prologue(bool full); | |
| 533 virtual void gc_epilogue(bool full); | |
| 534 | |
| 535 public: | |
| 536 virtual void preload_and_dump(TRAPS) KERNEL_RETURN; | |
| 537 }; |