Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/defNewGeneration.hpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
author | coleenp |
---|---|
date | Wed, 20 Mar 2013 08:04:54 -0400 |
parents | a30e7b564541 |
children | 001ec9515f84 |
rev | line source |
---|---|
0 | 1 /* |
6008 | 2 * Copyright (c) 2001, 2012, 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; | |
6818 | 46 uint _tenuring_threshold; // Tenuring threshold for next collection. |
0 | 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); | |
2038
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
1972
diff
changeset
|
88 void preserve_mark(oop obj, markOop m); // work routine used by the above |
0 | 89 |
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
90 // 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
|
91 // They should always contain the same number of elements. |
6197 | 92 Stack<oop, mtGC> _objs_with_preserved_marks; |
93 Stack<markOop, mtGC> _preserved_marks_of_objs; | |
0 | 94 |
95 // Promotion failure handling | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
96 ExtendedOopClosure *_promo_failure_scan_stack_closure; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
97 void set_promo_failure_scan_stack_closure(ExtendedOopClosure *scan_stack_closure) { |
0 | 98 _promo_failure_scan_stack_closure = scan_stack_closure; |
99 } | |
100 | |
6197 | 101 Stack<oop, mtGC> _promo_failure_scan_stack; |
0 | 102 void drain_promo_failure_scan_stack(void); |
103 bool _promo_failure_drain_in_progress; | |
104 | |
105 // Performance Counters | |
106 GenerationCounters* _gen_counters; | |
107 CSpaceCounters* _eden_counters; | |
108 CSpaceCounters* _from_counters; | |
109 CSpaceCounters* _to_counters; | |
110 | |
111 // sizing information | |
112 size_t _max_eden_size; | |
113 size_t _max_survivor_size; | |
114 | |
115 // Allocation support | |
116 bool _should_allocate_from_space; | |
117 bool should_allocate_from_space() const { | |
118 return _should_allocate_from_space; | |
119 } | |
120 void clear_should_allocate_from_space() { | |
121 _should_allocate_from_space = false; | |
122 } | |
123 void set_should_allocate_from_space() { | |
124 _should_allocate_from_space = true; | |
125 } | |
126 | |
7609
a30e7b564541
8005972: ParNew should not update the tenuring threshold when promotion failed has occurred
brutisso
parents:
6818
diff
changeset
|
127 // Tenuring |
a30e7b564541
8005972: ParNew should not update the tenuring threshold when promotion failed has occurred
brutisso
parents:
6818
diff
changeset
|
128 void adjust_desired_tenuring_threshold(); |
a30e7b564541
8005972: ParNew should not update the tenuring threshold when promotion failed has occurred
brutisso
parents:
6818
diff
changeset
|
129 |
0 | 130 // Spaces |
131 EdenSpace* _eden_space; | |
132 ContiguousSpace* _from_space; | |
133 ContiguousSpace* _to_space; | |
134 | |
135 enum SomeProtectedConstants { | |
136 // Generations are GenGrain-aligned and have size that are multiples of | |
137 // GenGrain. | |
138 MinFreeScratchWords = 100 | |
139 }; | |
140 | |
141 // Return the size of a survivor space if this generation were of size | |
142 // gen_size. | |
143 size_t compute_survivor_size(size_t gen_size, size_t alignment) const { | |
144 size_t n = gen_size / (SurvivorRatio + 2); | |
145 return n > alignment ? align_size_down(n, alignment) : alignment; | |
146 } | |
147 | |
148 public: // was "protected" but caused compile error on win32 | |
149 class IsAliveClosure: public BoolObjectClosure { | |
150 Generation* _g; | |
151 public: | |
152 IsAliveClosure(Generation* g); | |
153 void do_object(oop p); | |
154 bool do_object_b(oop p); | |
155 }; | |
156 | |
157 class KeepAliveClosure: public OopClosure { | |
158 protected: | |
159 ScanWeakRefClosure* _cl; | |
160 CardTableRS* _rs; | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
161 template <class T> void do_oop_work(T* p); |
0 | 162 public: |
163 KeepAliveClosure(ScanWeakRefClosure* cl); | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
164 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
|
165 virtual void do_oop(narrowOop* p); |
0 | 166 }; |
167 | |
168 class FastKeepAliveClosure: public KeepAliveClosure { | |
169 protected: | |
170 HeapWord* _boundary; | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
171 template <class T> void do_oop_work(T* p); |
0 | 172 public: |
173 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
|
174 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
|
175 virtual void do_oop(narrowOop* p); |
0 | 176 }; |
177 | |
178 class EvacuateFollowersClosure: public VoidClosure { | |
179 GenCollectedHeap* _gch; | |
180 int _level; | |
181 ScanClosure* _scan_cur_or_nonheap; | |
182 ScanClosure* _scan_older; | |
183 public: | |
184 EvacuateFollowersClosure(GenCollectedHeap* gch, int level, | |
185 ScanClosure* cur, ScanClosure* older); | |
186 void do_void(); | |
187 }; | |
188 | |
189 class FastEvacuateFollowersClosure: public VoidClosure { | |
190 GenCollectedHeap* _gch; | |
191 int _level; | |
192 DefNewGeneration* _gen; | |
193 FastScanClosure* _scan_cur_or_nonheap; | |
194 FastScanClosure* _scan_older; | |
195 public: | |
196 FastEvacuateFollowersClosure(GenCollectedHeap* gch, int level, | |
197 DefNewGeneration* gen, | |
198 FastScanClosure* cur, | |
199 FastScanClosure* older); | |
200 void do_void(); | |
201 }; | |
202 | |
203 public: | |
204 DefNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level, | |
205 const char* policy="Copy"); | |
206 | |
207 virtual Generation::Name kind() { return Generation::DefNew; } | |
208 | |
209 // Accessing spaces | |
210 EdenSpace* eden() const { return _eden_space; } | |
211 ContiguousSpace* from() const { return _from_space; } | |
212 ContiguousSpace* to() const { return _to_space; } | |
213 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
214 virtual CompactibleSpace* first_compaction_space() const; |
0 | 215 |
216 // Space enquiries | |
217 size_t capacity() const; | |
218 size_t used() const; | |
219 size_t free() const; | |
220 size_t max_capacity() const; | |
221 size_t capacity_before_gc() const; | |
222 size_t unsafe_max_alloc_nogc() const; | |
223 size_t contiguous_available() const; | |
224 | |
225 size_t max_eden_size() const { return _max_eden_size; } | |
226 size_t max_survivor_size() const { return _max_survivor_size; } | |
227 | |
228 bool supports_inline_contig_alloc() const { return true; } | |
229 HeapWord** top_addr() const; | |
230 HeapWord** end_addr() const; | |
231 | |
232 // Thread-local allocation buffers | |
233 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
|
234 size_t tlab_capacity() const; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
235 size_t unsafe_max_tlab_alloc() const; |
0 | 236 |
237 // Grow the generation by the specified number of bytes. | |
238 // The size of bytes is assumed to be properly aligned. | |
239 // Return true if the expansion was successful. | |
240 bool expand(size_t bytes); | |
241 | |
242 // DefNewGeneration cannot currently expand except at | |
243 // a GC. | |
244 virtual bool is_maximal_no_gc() const { return true; } | |
245 | |
246 // Iteration | |
247 void object_iterate(ObjectClosure* blk); | |
248 void object_iterate_since_last_GC(ObjectClosure* cl); | |
249 | |
250 void younger_refs_iterate(OopsInGenClosure* cl); | |
251 | |
252 void space_iterate(SpaceClosure* blk, bool usedOnly = false); | |
253 | |
254 // Allocation support | |
255 virtual bool should_allocate(size_t word_size, bool is_tlab) { | |
256 assert(UseTLAB || !is_tlab, "Should not allocate tlab"); | |
257 | |
258 size_t overflow_limit = (size_t)1 << (BitsPerSize_t - LogHeapWordSize); | |
259 | |
260 const bool non_zero = word_size > 0; | |
261 const bool overflows = word_size >= overflow_limit; | |
262 const bool check_too_big = _pretenure_size_threshold_words > 0; | |
263 const bool not_too_big = word_size < _pretenure_size_threshold_words; | |
264 const bool size_ok = is_tlab || !check_too_big || not_too_big; | |
265 | |
266 bool result = !overflows && | |
267 non_zero && | |
268 size_ok; | |
269 | |
270 return result; | |
271 } | |
272 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
273 HeapWord* allocate(size_t word_size, bool is_tlab); |
0 | 274 HeapWord* allocate_from_space(size_t word_size); |
275 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
276 HeapWord* par_allocate(size_t word_size, bool is_tlab); |
0 | 277 |
278 // Prologue & Epilogue | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
279 virtual void gc_prologue(bool full); |
0 | 280 virtual void gc_epilogue(bool full); |
281 | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
282 // 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
|
283 virtual void record_spaces_top(); |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
284 |
0 | 285 // Doesn't require additional work during GC prologue and epilogue |
286 virtual bool performs_in_place_marking() const { return false; } | |
287 | |
288 // Accessing marks | |
289 void save_marks(); | |
290 void reset_saved_marks(); | |
291 bool no_allocs_since_save_marks(); | |
292 | |
293 // Need to declare the full complement of closures, whether we'll | |
294 // override them or not, or get message from the compiler: | |
295 // oop_since_save_marks_iterate_nv hides virtual function... | |
296 #define DefNew_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
297 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
298 | |
299 ALL_SINCE_SAVE_MARKS_CLOSURES(DefNew_SINCE_SAVE_MARKS_DECL) | |
300 | |
301 #undef DefNew_SINCE_SAVE_MARKS_DECL | |
302 | |
303 // For non-youngest collection, the DefNewGeneration can contribute | |
304 // "to-space". | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
305 virtual void contribute_scratch(ScratchBlock*& list, Generation* requestor, |
0 | 306 size_t max_alloc_words); |
307 | |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
308 // 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
|
309 virtual void reset_scratch(); |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
310 |
0 | 311 // GC support |
312 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
|
313 |
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
314 // 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
|
315 // 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
|
316 // 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
|
317 // 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
|
318 // 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
|
319 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
|
320 |
0 | 321 virtual void collect(bool full, |
322 bool clear_all_soft_refs, | |
323 size_t size, | |
324 bool is_tlab); | |
325 HeapWord* expand_and_allocate(size_t size, | |
326 bool is_tlab, | |
327 bool parallel = false); | |
328 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
329 oop copy_to_survivor_space(oop old); |
6818 | 330 uint tenuring_threshold() { return _tenuring_threshold; } |
0 | 331 |
332 // Performance Counter support | |
333 void update_counters(); | |
334 | |
335 // Printing | |
336 virtual const char* name() const; | |
337 virtual const char* short_name() const { return "DefNew"; } | |
338 | |
339 bool must_be_youngest() const { return true; } | |
340 bool must_be_oldest() const { return false; } | |
341 | |
342 // PrintHeapAtGC support. | |
343 void print_on(outputStream* st) const; | |
344 | |
6008 | 345 void verify(); |
0 | 346 |
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
347 bool promo_failure_scan_is_complete() const { |
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
348 return _promo_failure_scan_stack.is_empty(); |
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
349 } |
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
350 |
0 | 351 protected: |
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
352 // 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
|
353 // 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
|
354 // 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
|
355 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
|
356 bool clear_space, |
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
357 bool mangle_space); |
0 | 358 // Scavenge support |
359 void swap_spaces(); | |
360 }; | |
1972 | 361 |
362 #endif // SHARE_VM_MEMORY_DEFNEWGENERATION_HPP |