Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/defNewGeneration.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 | 74ee0db180fa |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2001, 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:
269
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
269
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:
269
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_DEFNEWGENERATION_HPP |
| 26 #define SHARE_VM_MEMORY_DEFNEWGENERATION_HPP | |
| 27 | |
| 28 #include "gc_implementation/shared/ageTable.hpp" | |
| 29 #include "gc_implementation/shared/cSpaceCounters.hpp" | |
| 30 #include "gc_implementation/shared/generationCounters.hpp" | |
| 31 #include "memory/generation.inline.hpp" | |
| 32 #include "utilities/stack.hpp" | |
| 33 | |
| 0 | 34 class EdenSpace; |
| 35 class ContiguousSpace; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
36 class ScanClosure; |
| 0 | 37 |
| 38 // DefNewGeneration is a young generation containing eden, from- and | |
| 39 // to-space. | |
| 40 | |
| 41 class DefNewGeneration: public Generation { | |
| 42 friend class VMStructs; | |
| 43 | |
| 44 protected: | |
| 45 Generation* _next_gen; | |
| 46 int _tenuring_threshold; // Tenuring threshold for next collection. | |
| 47 ageTable _age_table; | |
| 48 // Size of object to pretenure in words; command line provides bytes | |
| 49 size_t _pretenure_size_threshold_words; | |
| 50 | |
| 51 ageTable* age_table() { return &_age_table; } | |
| 52 // Initialize state to optimistically assume no promotion failure will | |
| 53 // happen. | |
| 54 void init_assuming_no_promotion_failure(); | |
| 55 // True iff a promotion has failed in the current collection. | |
| 56 bool _promotion_failed; | |
| 57 bool promotion_failed() { return _promotion_failed; } | |
| 58 | |
| 59 // Handling promotion failure. A young generation collection | |
| 60 // can fail if a live object cannot be copied out of its | |
| 61 // location in eden or from-space during the collection. If | |
| 62 // a collection fails, the young generation is left in a | |
| 63 // consistent state such that it can be collected by a | |
| 64 // full collection. | |
| 65 // Before the collection | |
| 66 // Objects are in eden or from-space | |
| 67 // All roots into the young generation point into eden or from-space. | |
| 68 // | |
| 69 // After a failed collection | |
| 70 // Objects may be in eden, from-space, or to-space | |
| 71 // An object A in eden or from-space may have a copy B | |
| 72 // in to-space. If B exists, all roots that once pointed | |
| 73 // to A must now point to B. | |
| 74 // All objects in the young generation are unmarked. | |
| 75 // Eden, from-space, and to-space will all be collected by | |
| 76 // the full collection. | |
| 77 void handle_promotion_failure(oop); | |
| 78 | |
| 79 // In the absence of promotion failure, we wouldn't look at "from-space" | |
| 80 // objects after a young-gen collection. When promotion fails, however, | |
| 81 // the subsequent full collection will look at from-space objects: | |
| 82 // therefore we must remove their forwarding pointers. | |
| 83 void remove_forwarding_pointers(); | |
| 84 | |
| 85 // Preserve the mark of "obj", if necessary, in preparation for its mark | |
| 86 // word being overwritten with a self-forwarding-pointer. | |
| 87 void preserve_mark_if_necessary(oop obj, markOop m); | |
| 88 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
89 // Together, these keep <object with a preserved mark, mark value> pairs. |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
90 // They should always contain the same number of elements. |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
91 Stack<oop> _objs_with_preserved_marks; |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
92 Stack<markOop> _preserved_marks_of_objs; |
| 0 | 93 |
| 94 // Promotion failure handling | |
| 95 OopClosure *_promo_failure_scan_stack_closure; | |
| 96 void set_promo_failure_scan_stack_closure(OopClosure *scan_stack_closure) { | |
| 97 _promo_failure_scan_stack_closure = scan_stack_closure; | |
| 98 } | |
| 99 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
100 Stack<oop> _promo_failure_scan_stack; |
| 0 | 101 void drain_promo_failure_scan_stack(void); |
| 102 bool _promo_failure_drain_in_progress; | |
| 103 | |
| 104 // Performance Counters | |
| 105 GenerationCounters* _gen_counters; | |
| 106 CSpaceCounters* _eden_counters; | |
| 107 CSpaceCounters* _from_counters; | |
| 108 CSpaceCounters* _to_counters; | |
| 109 | |
| 110 // sizing information | |
| 111 size_t _max_eden_size; | |
| 112 size_t _max_survivor_size; | |
| 113 | |
| 114 // Allocation support | |
| 115 bool _should_allocate_from_space; | |
| 116 bool should_allocate_from_space() const { | |
| 117 return _should_allocate_from_space; | |
| 118 } | |
| 119 void clear_should_allocate_from_space() { | |
| 120 _should_allocate_from_space = false; | |
| 121 } | |
| 122 void set_should_allocate_from_space() { | |
| 123 _should_allocate_from_space = true; | |
| 124 } | |
| 125 | |
| 126 protected: | |
| 127 // Spaces | |
| 128 EdenSpace* _eden_space; | |
| 129 ContiguousSpace* _from_space; | |
| 130 ContiguousSpace* _to_space; | |
| 131 | |
| 132 enum SomeProtectedConstants { | |
| 133 // Generations are GenGrain-aligned and have size that are multiples of | |
| 134 // GenGrain. | |
| 135 MinFreeScratchWords = 100 | |
| 136 }; | |
| 137 | |
| 138 // Return the size of a survivor space if this generation were of size | |
| 139 // gen_size. | |
| 140 size_t compute_survivor_size(size_t gen_size, size_t alignment) const { | |
| 141 size_t n = gen_size / (SurvivorRatio + 2); | |
| 142 return n > alignment ? align_size_down(n, alignment) : alignment; | |
| 143 } | |
| 144 | |
| 145 public: // was "protected" but caused compile error on win32 | |
| 146 class IsAliveClosure: public BoolObjectClosure { | |
| 147 Generation* _g; | |
| 148 public: | |
| 149 IsAliveClosure(Generation* g); | |
| 150 void do_object(oop p); | |
| 151 bool do_object_b(oop p); | |
| 152 }; | |
| 153 | |
| 154 class KeepAliveClosure: public OopClosure { | |
| 155 protected: | |
| 156 ScanWeakRefClosure* _cl; | |
| 157 CardTableRS* _rs; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
158 template <class T> void do_oop_work(T* p); |
| 0 | 159 public: |
| 160 KeepAliveClosure(ScanWeakRefClosure* cl); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
161 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
162 virtual void do_oop(narrowOop* p); |
| 0 | 163 }; |
| 164 | |
| 165 class FastKeepAliveClosure: public KeepAliveClosure { | |
| 166 protected: | |
| 167 HeapWord* _boundary; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
168 template <class T> void do_oop_work(T* p); |
| 0 | 169 public: |
| 170 FastKeepAliveClosure(DefNewGeneration* g, ScanWeakRefClosure* cl); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
171 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
172 virtual void do_oop(narrowOop* p); |
| 0 | 173 }; |
| 174 | |
| 175 class EvacuateFollowersClosure: public VoidClosure { | |
| 176 GenCollectedHeap* _gch; | |
| 177 int _level; | |
| 178 ScanClosure* _scan_cur_or_nonheap; | |
| 179 ScanClosure* _scan_older; | |
| 180 public: | |
| 181 EvacuateFollowersClosure(GenCollectedHeap* gch, int level, | |
| 182 ScanClosure* cur, ScanClosure* older); | |
| 183 void do_void(); | |
| 184 }; | |
| 185 | |
| 186 class FastEvacuateFollowersClosure: public VoidClosure { | |
| 187 GenCollectedHeap* _gch; | |
| 188 int _level; | |
| 189 DefNewGeneration* _gen; | |
| 190 FastScanClosure* _scan_cur_or_nonheap; | |
| 191 FastScanClosure* _scan_older; | |
| 192 public: | |
| 193 FastEvacuateFollowersClosure(GenCollectedHeap* gch, int level, | |
| 194 DefNewGeneration* gen, | |
| 195 FastScanClosure* cur, | |
| 196 FastScanClosure* older); | |
| 197 void do_void(); | |
| 198 }; | |
| 199 | |
| 200 public: | |
| 201 DefNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level, | |
| 202 const char* policy="Copy"); | |
| 203 | |
| 204 virtual Generation::Name kind() { return Generation::DefNew; } | |
| 205 | |
| 206 // Accessing spaces | |
| 207 EdenSpace* eden() const { return _eden_space; } | |
| 208 ContiguousSpace* from() const { return _from_space; } | |
| 209 ContiguousSpace* to() const { return _to_space; } | |
| 210 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
211 virtual CompactibleSpace* first_compaction_space() const; |
| 0 | 212 |
| 213 // Space enquiries | |
| 214 size_t capacity() const; | |
| 215 size_t used() const; | |
| 216 size_t free() const; | |
| 217 size_t max_capacity() const; | |
| 218 size_t capacity_before_gc() const; | |
| 219 size_t unsafe_max_alloc_nogc() const; | |
| 220 size_t contiguous_available() const; | |
| 221 | |
| 222 size_t max_eden_size() const { return _max_eden_size; } | |
| 223 size_t max_survivor_size() const { return _max_survivor_size; } | |
| 224 | |
| 225 bool supports_inline_contig_alloc() const { return true; } | |
| 226 HeapWord** top_addr() const; | |
| 227 HeapWord** end_addr() const; | |
| 228 | |
| 229 // Thread-local allocation buffers | |
| 230 bool supports_tlab_allocation() const { return true; } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
231 size_t tlab_capacity() const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
232 size_t unsafe_max_tlab_alloc() const; |
| 0 | 233 |
| 234 // Grow the generation by the specified number of bytes. | |
| 235 // The size of bytes is assumed to be properly aligned. | |
| 236 // Return true if the expansion was successful. | |
| 237 bool expand(size_t bytes); | |
| 238 | |
| 239 // DefNewGeneration cannot currently expand except at | |
| 240 // a GC. | |
| 241 virtual bool is_maximal_no_gc() const { return true; } | |
| 242 | |
| 243 // Iteration | |
| 244 void object_iterate(ObjectClosure* blk); | |
| 245 void object_iterate_since_last_GC(ObjectClosure* cl); | |
| 246 | |
| 247 void younger_refs_iterate(OopsInGenClosure* cl); | |
| 248 | |
| 249 void space_iterate(SpaceClosure* blk, bool usedOnly = false); | |
| 250 | |
| 251 // Allocation support | |
| 252 virtual bool should_allocate(size_t word_size, bool is_tlab) { | |
| 253 assert(UseTLAB || !is_tlab, "Should not allocate tlab"); | |
| 254 | |
| 255 size_t overflow_limit = (size_t)1 << (BitsPerSize_t - LogHeapWordSize); | |
| 256 | |
| 257 const bool non_zero = word_size > 0; | |
| 258 const bool overflows = word_size >= overflow_limit; | |
| 259 const bool check_too_big = _pretenure_size_threshold_words > 0; | |
| 260 const bool not_too_big = word_size < _pretenure_size_threshold_words; | |
| 261 const bool size_ok = is_tlab || !check_too_big || not_too_big; | |
| 262 | |
| 263 bool result = !overflows && | |
| 264 non_zero && | |
| 265 size_ok; | |
| 266 | |
| 267 return result; | |
| 268 } | |
| 269 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
270 HeapWord* allocate(size_t word_size, bool is_tlab); |
| 0 | 271 HeapWord* allocate_from_space(size_t word_size); |
| 272 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
273 HeapWord* par_allocate(size_t word_size, bool is_tlab); |
| 0 | 274 |
| 275 // Prologue & Epilogue | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
276 virtual void gc_prologue(bool full); |
| 0 | 277 virtual void gc_epilogue(bool full); |
| 278 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
279 // Save the tops for eden, from, and to |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
280 virtual void record_spaces_top(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
281 |
| 0 | 282 // Doesn't require additional work during GC prologue and epilogue |
| 283 virtual bool performs_in_place_marking() const { return false; } | |
| 284 | |
| 285 // Accessing marks | |
| 286 void save_marks(); | |
| 287 void reset_saved_marks(); | |
| 288 bool no_allocs_since_save_marks(); | |
| 289 | |
| 290 // Need to declare the full complement of closures, whether we'll | |
| 291 // override them or not, or get message from the compiler: | |
| 292 // oop_since_save_marks_iterate_nv hides virtual function... | |
| 293 #define DefNew_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
| 294 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
| 295 | |
| 296 ALL_SINCE_SAVE_MARKS_CLOSURES(DefNew_SINCE_SAVE_MARKS_DECL) | |
| 297 | |
| 298 #undef DefNew_SINCE_SAVE_MARKS_DECL | |
| 299 | |
| 300 // For non-youngest collection, the DefNewGeneration can contribute | |
| 301 // "to-space". | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
302 virtual void contribute_scratch(ScratchBlock*& list, Generation* requestor, |
| 0 | 303 size_t max_alloc_words); |
| 304 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
305 // Reset for contribution of "to-space". |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
306 virtual void reset_scratch(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
307 |
| 0 | 308 // GC support |
| 309 virtual void compute_new_size(); | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
310 |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
311 // Returns true if the collection is likely to be safely |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
312 // completed. Even if this method returns true, a collection |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
313 // may not be guaranteed to succeed, and the system should be |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
314 // able to safely unwind and recover from that failure, albeit |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
315 // at some additional cost. Override superclass's implementation. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
316 virtual bool collection_attempt_is_safe(); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
317 |
| 0 | 318 virtual void collect(bool full, |
| 319 bool clear_all_soft_refs, | |
| 320 size_t size, | |
| 321 bool is_tlab); | |
| 322 HeapWord* expand_and_allocate(size_t size, | |
| 323 bool is_tlab, | |
| 324 bool parallel = false); | |
| 325 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
326 oop copy_to_survivor_space(oop old); |
| 0 | 327 int tenuring_threshold() { return _tenuring_threshold; } |
| 328 | |
| 329 // Performance Counter support | |
| 330 void update_counters(); | |
| 331 | |
| 332 // Printing | |
| 333 virtual const char* name() const; | |
| 334 virtual const char* short_name() const { return "DefNew"; } | |
| 335 | |
| 336 bool must_be_youngest() const { return true; } | |
| 337 bool must_be_oldest() const { return false; } | |
| 338 | |
| 339 // PrintHeapAtGC support. | |
| 340 void print_on(outputStream* st) const; | |
| 341 | |
| 342 void verify(bool allow_dirty); | |
| 343 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
344 bool promo_failure_scan_is_complete() const { |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
345 return _promo_failure_scan_stack.is_empty(); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
346 } |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
347 |
| 0 | 348 protected: |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
349 // If clear_space is true, clear the survivor spaces. Eden is |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
350 // cleared if the minimum size of eden is 0. If mangle_space |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
351 // is true, also mangle the space in debug mode. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
352 void compute_space_boundaries(uintx minimum_eden_size, |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
353 bool clear_space, |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
354 bool mangle_space); |
| 0 | 355 // Scavenge support |
| 356 void swap_spaces(); | |
| 357 }; | |
| 1972 | 358 |
| 359 #endif // SHARE_VM_MEMORY_DEFNEWGENERATION_HPP |