Mercurial > hg > graal-jvmci-8
comparison src/share/vm/memory/collectorPolicy.hpp @ 13060:8f07aa079343
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
7057939: jmap shows MaxNewSize=4GB when Java is using parallel collector
Summary: Major cleanup of the collectorpolicy classes
Reviewed-by: tschatzl, jcoomes
author | jwilhelm |
---|---|
date | Fri, 01 Nov 2013 17:09:38 +0100 |
parents | 46d7652b223c |
children | 236cecd9ec97 |
comparison
equal
deleted
inserted
replaced
13059:46d7652b223c | 13060:8f07aa079343 |
---|---|
59 | 59 |
60 class CollectorPolicy : public CHeapObj<mtGC> { | 60 class CollectorPolicy : public CHeapObj<mtGC> { |
61 protected: | 61 protected: |
62 GCPolicyCounters* _gc_policy_counters; | 62 GCPolicyCounters* _gc_policy_counters; |
63 | 63 |
64 // Requires that the concrete subclass sets the alignment constraints | 64 virtual void initialize_alignments() = 0; |
65 // before calling. | |
66 virtual void initialize_flags(); | 65 virtual void initialize_flags(); |
67 virtual void initialize_size_info(); | 66 virtual void initialize_size_info(); |
67 | |
68 DEBUG_ONLY(virtual void assert_flags();) | |
69 DEBUG_ONLY(virtual void assert_size_info();) | |
68 | 70 |
69 size_t _initial_heap_byte_size; | 71 size_t _initial_heap_byte_size; |
70 size_t _max_heap_byte_size; | 72 size_t _max_heap_byte_size; |
71 size_t _min_heap_byte_size; | 73 size_t _min_heap_byte_size; |
72 | 74 |
73 size_t _min_alignment; | 75 size_t _space_alignment; |
74 size_t _max_alignment; | 76 size_t _heap_alignment; |
77 | |
78 // Needed to keep information if MaxHeapSize was set on the command line | |
79 // when the flag value is aligned etc by ergonomics | |
80 bool _max_heap_size_cmdline; | |
75 | 81 |
76 // The sizing of the heap are controlled by a sizing policy. | 82 // The sizing of the heap are controlled by a sizing policy. |
77 AdaptiveSizePolicy* _size_policy; | 83 AdaptiveSizePolicy* _size_policy; |
78 | 84 |
79 // Set to true when policy wants soft refs cleared. | 85 // Set to true when policy wants soft refs cleared. |
85 // set to false each time gc returns to the mutator. For example, in the | 91 // set to false each time gc returns to the mutator. For example, in the |
86 // ParallelScavengeHeap case the latter would be done toward the end of | 92 // ParallelScavengeHeap case the latter would be done toward the end of |
87 // mem_allocate() where it returns op.result() | 93 // mem_allocate() where it returns op.result() |
88 bool _all_soft_refs_clear; | 94 bool _all_soft_refs_clear; |
89 | 95 |
90 CollectorPolicy() : | 96 CollectorPolicy(); |
91 _min_alignment(1), | 97 |
92 _max_alignment(1), | 98 public: |
93 _initial_heap_byte_size(0), | 99 virtual void initialize_all() { |
94 _max_heap_byte_size(0), | 100 initialize_alignments(); |
95 _min_heap_byte_size(0), | 101 initialize_flags(); |
96 _size_policy(NULL), | 102 initialize_size_info(); |
97 _should_clear_all_soft_refs(false), | 103 } |
98 _all_soft_refs_clear(false) | 104 |
99 {} | |
100 | |
101 public: | |
102 // Return maximum heap alignment that may be imposed by the policy | 105 // Return maximum heap alignment that may be imposed by the policy |
103 static size_t compute_max_alignment(); | 106 static size_t compute_heap_alignment(); |
104 | 107 |
105 size_t min_alignment() { return _min_alignment; } | 108 size_t space_alignment() { return _space_alignment; } |
106 size_t max_alignment() { return _max_alignment; } | 109 size_t heap_alignment() { return _heap_alignment; } |
107 | 110 |
108 size_t initial_heap_byte_size() { return _initial_heap_byte_size; } | 111 size_t initial_heap_byte_size() { return _initial_heap_byte_size; } |
109 size_t max_heap_byte_size() { return _max_heap_byte_size; } | 112 size_t max_heap_byte_size() { return _max_heap_byte_size; } |
110 size_t min_heap_byte_size() { return _min_heap_byte_size; } | 113 size_t min_heap_byte_size() { return _min_heap_byte_size; } |
111 | 114 |
193 // Returns true if a collector has eden space with soft end. | 196 // Returns true if a collector has eden space with soft end. |
194 virtual bool has_soft_ended_eden() { | 197 virtual bool has_soft_ended_eden() { |
195 return false; | 198 return false; |
196 } | 199 } |
197 | 200 |
201 // Do any updates required to global flags that are due to heap initialization | |
202 // changes | |
203 virtual void post_heap_initialize() = 0; | |
198 }; | 204 }; |
199 | 205 |
200 class ClearedAllSoftRefs : public StackObj { | 206 class ClearedAllSoftRefs : public StackObj { |
201 bool _clear_all_soft_refs; | 207 bool _clear_all_soft_refs; |
202 CollectorPolicy* _collector_policy; | 208 CollectorPolicy* _collector_policy; |
217 protected: | 223 protected: |
218 size_t _min_gen0_size; | 224 size_t _min_gen0_size; |
219 size_t _initial_gen0_size; | 225 size_t _initial_gen0_size; |
220 size_t _max_gen0_size; | 226 size_t _max_gen0_size; |
221 | 227 |
228 // _gen_alignment and _space_alignment will have the same value most of the | |
229 // time. When using large pages they can differ. | |
230 size_t _gen_alignment; | |
231 | |
222 GenerationSpec **_generations; | 232 GenerationSpec **_generations; |
223 | 233 |
224 // Return true if an allocation should be attempted in the older | 234 // Return true if an allocation should be attempted in the older |
225 // generation if it fails in the younger generation. Return | 235 // generation if it fails in the younger generation. Return |
226 // false, otherwise. | 236 // false, otherwise. |
227 virtual bool should_try_older_generation_allocation(size_t word_size) const; | 237 virtual bool should_try_older_generation_allocation(size_t word_size) const; |
228 | 238 |
229 void initialize_flags(); | 239 void initialize_flags(); |
230 void initialize_size_info(); | 240 void initialize_size_info(); |
231 | 241 |
242 DEBUG_ONLY(void assert_flags();) | |
243 DEBUG_ONLY(void assert_size_info();) | |
244 | |
232 // Try to allocate space by expanding the heap. | 245 // Try to allocate space by expanding the heap. |
233 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab); | 246 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab); |
234 | 247 |
235 // Scale the base_size by NewRation according to | 248 // Compute max heap alignment |
249 size_t compute_max_alignment(); | |
250 | |
251 // Scale the base_size by NewRatio according to | |
236 // result = base_size / (NewRatio + 1) | 252 // result = base_size / (NewRatio + 1) |
237 // and align by min_alignment() | 253 // and align by min_alignment() |
238 size_t scale_by_NewRatio_aligned(size_t base_size); | 254 size_t scale_by_NewRatio_aligned(size_t base_size); |
239 | 255 |
240 // Bound the value by the given maximum minus the | 256 // Bound the value by the given maximum minus the min_alignment |
241 // min_alignment. | |
242 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size); | 257 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size); |
243 | 258 |
244 public: | 259 public: |
260 GenCollectorPolicy(); | |
261 | |
245 // Accessors | 262 // Accessors |
246 size_t min_gen0_size() { return _min_gen0_size; } | 263 size_t min_gen0_size() { return _min_gen0_size; } |
247 size_t initial_gen0_size() { return _initial_gen0_size; } | 264 size_t initial_gen0_size() { return _initial_gen0_size; } |
248 size_t max_gen0_size() { return _max_gen0_size; } | 265 size_t max_gen0_size() { return _max_gen0_size; } |
266 size_t gen_alignment() { return _gen_alignment; } | |
249 | 267 |
250 virtual int number_of_generations() = 0; | 268 virtual int number_of_generations() = 0; |
251 | 269 |
252 virtual GenerationSpec **generations() { | 270 virtual GenerationSpec **generations() { |
253 assert(_generations != NULL, "Sanity check"); | 271 assert(_generations != NULL, "Sanity check"); |
254 return _generations; | 272 return _generations; |
255 } | 273 } |
256 | 274 |
257 virtual GenCollectorPolicy* as_generation_policy() { return this; } | 275 virtual GenCollectorPolicy* as_generation_policy() { return this; } |
258 | 276 |
259 virtual void initialize_generations() = 0; | 277 virtual void initialize_generations() { }; |
260 | 278 |
261 virtual void initialize_all() { | 279 virtual void initialize_all() { |
262 initialize_flags(); | 280 CollectorPolicy::initialize_all(); |
263 initialize_size_info(); | |
264 initialize_generations(); | 281 initialize_generations(); |
265 } | 282 } |
283 | |
284 size_t young_gen_size_lower_bound(); | |
266 | 285 |
267 HeapWord* mem_allocate_work(size_t size, | 286 HeapWord* mem_allocate_work(size_t size, |
268 bool is_tlab, | 287 bool is_tlab, |
269 bool* gc_overhead_limit_was_exceeded); | 288 bool* gc_overhead_limit_was_exceeded); |
270 | 289 |
273 // Adaptive size policy | 292 // Adaptive size policy |
274 virtual void initialize_size_policy(size_t init_eden_size, | 293 virtual void initialize_size_policy(size_t init_eden_size, |
275 size_t init_promo_size, | 294 size_t init_promo_size, |
276 size_t init_survivor_size); | 295 size_t init_survivor_size); |
277 | 296 |
278 // The alignment used for eden and survivors within the young gen | 297 virtual void post_heap_initialize() { |
279 // and for boundary between young gen and old gen. | 298 assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info"); |
280 static size_t intra_heap_alignment() { | |
281 return 64 * K * HeapWordSize; | |
282 } | 299 } |
283 }; | 300 }; |
284 | 301 |
285 // All of hotspot's current collectors are subtypes of this | 302 // All of hotspot's current collectors are subtypes of this |
286 // class. Currently, these collectors all use the same gen[0], | 303 // class. Currently, these collectors all use the same gen[0], |
294 size_t _initial_gen1_size; | 311 size_t _initial_gen1_size; |
295 size_t _max_gen1_size; | 312 size_t _max_gen1_size; |
296 | 313 |
297 void initialize_flags(); | 314 void initialize_flags(); |
298 void initialize_size_info(); | 315 void initialize_size_info(); |
299 void initialize_generations() { ShouldNotReachHere(); } | 316 |
300 | 317 DEBUG_ONLY(void assert_flags();) |
301 public: | 318 DEBUG_ONLY(void assert_size_info();) |
319 | |
320 public: | |
321 TwoGenerationCollectorPolicy() : GenCollectorPolicy(), _min_gen1_size(0), | |
322 _initial_gen1_size(0), _max_gen1_size(0) {} | |
323 | |
302 // Accessors | 324 // Accessors |
303 size_t min_gen1_size() { return _min_gen1_size; } | 325 size_t min_gen1_size() { return _min_gen1_size; } |
304 size_t initial_gen1_size() { return _initial_gen1_size; } | 326 size_t initial_gen1_size() { return _initial_gen1_size; } |
305 size_t max_gen1_size() { return _max_gen1_size; } | 327 size_t max_gen1_size() { return _max_gen1_size; } |
306 | 328 |
319 const size_t heap_size, const size_t min_gen1_size); | 341 const size_t heap_size, const size_t min_gen1_size); |
320 }; | 342 }; |
321 | 343 |
322 class MarkSweepPolicy : public TwoGenerationCollectorPolicy { | 344 class MarkSweepPolicy : public TwoGenerationCollectorPolicy { |
323 protected: | 345 protected: |
346 void initialize_alignments(); | |
324 void initialize_generations(); | 347 void initialize_generations(); |
325 | 348 |
326 public: | 349 public: |
327 MarkSweepPolicy(); | 350 MarkSweepPolicy() {} |
328 | 351 |
329 MarkSweepPolicy* as_mark_sweep_policy() { return this; } | 352 MarkSweepPolicy* as_mark_sweep_policy() { return this; } |
330 | 353 |
331 void initialize_gc_policy_counters(); | 354 void initialize_gc_policy_counters(); |
332 }; | 355 }; |