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 |
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 |