30 #include "memory/generationSpec.hpp"
31 #include "memory/genRemSet.hpp"
32 #include "utilities/macros.hpp"
33
34 // This class (or more correctly, subtypes of this class)
35 // are used to define global garbage collector attributes.
36 // This includes initialization of generations and any other
37 // shared resources they may need.
38 //
39 // In general, all flag adjustment and validation should be
40 // done in initialize_flags(), which is called prior to
41 // initialize_size_info().
42 //
43 // This class is not fully developed yet. As more collector(s)
44 // are added, it is expected that we will come across further
45 // behavior that requires global attention. The correct place
46 // to deal with those issues is this class.
47
48 // Forward declarations.
49 class GenCollectorPolicy;
50 class TwoGenerationCollectorPolicy;
51 class AdaptiveSizePolicy;
52 #if INCLUDE_ALL_GCS
53 class ConcurrentMarkSweepPolicy;
54 class G1CollectorPolicy;
55 #endif // INCLUDE_ALL_GCS
56
57 class GCPolicyCounters;
58 class MarkSweepPolicy;
59
60 class CollectorPolicy : public CHeapObj<mtGC> {
61 protected:
62 GCPolicyCounters* _gc_policy_counters;
63
64 virtual void initialize_alignments() = 0;
65 virtual void initialize_flags();
66 virtual void initialize_size_info();
67
68 DEBUG_ONLY(virtual void assert_flags();)
69 DEBUG_ONLY(virtual void assert_size_info();)
70
97
98 public:
99 virtual void initialize_all() {
100 initialize_alignments();
101 initialize_flags();
102 initialize_size_info();
103 }
104
105 // Return maximum heap alignment that may be imposed by the policy.
106 static size_t compute_heap_alignment();
107
108 size_t space_alignment() { return _space_alignment; }
109 size_t heap_alignment() { return _heap_alignment; }
110
111 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
112 size_t max_heap_byte_size() { return _max_heap_byte_size; }
113 size_t min_heap_byte_size() { return _min_heap_byte_size; }
114
115 enum Name {
116 CollectorPolicyKind,
117 TwoGenerationCollectorPolicyKind,
118 ConcurrentMarkSweepPolicyKind,
119 ASConcurrentMarkSweepPolicyKind,
120 G1CollectorPolicyKind
121 };
122
123 AdaptiveSizePolicy* size_policy() { return _size_policy; }
124 bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; }
125 void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; }
126 // Returns the current value of _should_clear_all_soft_refs.
127 // _should_clear_all_soft_refs is set to false as a side effect.
128 bool use_should_clear_all_soft_refs(bool v);
129 bool all_soft_refs_clear() { return _all_soft_refs_clear; }
130 void set_all_soft_refs_clear(bool v) { _all_soft_refs_clear = v; }
131
132 // Called by the GC after Soft Refs have been cleared to indicate
133 // that the request in _should_clear_all_soft_refs has been fulfilled.
134 void cleared_all_soft_refs();
135
136 // Identification methods.
137 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
138 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
139 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
140 #if INCLUDE_ALL_GCS
141 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
142 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
143 #endif // INCLUDE_ALL_GCS
144 // Note that these are not virtual.
145 bool is_generation_policy() { return as_generation_policy() != NULL; }
146 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
147 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
148 #if INCLUDE_ALL_GCS
149 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
150 bool is_g1_policy() { return as_g1_policy() != NULL; }
151 #else // INCLUDE_ALL_GCS
152 bool is_concurrent_mark_sweep_policy() { return false; }
153 bool is_g1_policy() { return false; }
154 #endif // INCLUDE_ALL_GCS
155
156
157 virtual BarrierSet::Name barrier_set_name() = 0;
158
159 // Create the remembered set (to cover the given reserved region,
160 // allowing breaking up into at most "max_covered_regions").
161 virtual GenRemSet* create_rem_set(MemRegion reserved,
162 int max_covered_regions);
163
164 // This method controls how a collector satisfies a request
165 // for a block of memory. "gc_time_limit_was_exceeded" will
166 // be set to true if the adaptive size policy determine that
208 CollectorPolicy* _collector_policy;
209 public:
210 ClearedAllSoftRefs(bool clear_all_soft_refs,
211 CollectorPolicy* collector_policy) :
212 _clear_all_soft_refs(clear_all_soft_refs),
213 _collector_policy(collector_policy) {}
214
215 ~ClearedAllSoftRefs() {
216 if (_clear_all_soft_refs) {
217 _collector_policy->cleared_all_soft_refs();
218 }
219 }
220 };
221
222 class GenCollectorPolicy : public CollectorPolicy {
223 friend class TestGenCollectorPolicy;
224 protected:
225 size_t _min_gen0_size;
226 size_t _initial_gen0_size;
227 size_t _max_gen0_size;
228
229 // _gen_alignment and _space_alignment will have the same value most of the
230 // time. When using large pages they can differ.
231 size_t _gen_alignment;
232
233 GenerationSpec **_generations;
234
235 // Return true if an allocation should be attempted in the older generation
236 // if it fails in the younger generation. Return false, otherwise.
237 virtual bool should_try_older_generation_allocation(size_t word_size) const;
238
239 void initialize_flags();
240 void initialize_size_info();
241
242 DEBUG_ONLY(void assert_flags();)
243 DEBUG_ONLY(void assert_size_info();)
244
245 // Try to allocate space by expanding the heap.
246 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
247
248 // Compute max heap alignment.
249 size_t compute_max_alignment();
250
251 // Scale the base_size by NewRatio according to
252 // result = base_size / (NewRatio + 1)
253 // and align by min_alignment()
254 size_t scale_by_NewRatio_aligned(size_t base_size);
255
256 // Bound the value by the given maximum minus the min_alignment.
257 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
258
259 public:
260 GenCollectorPolicy();
261
262 // Accessors
263 size_t min_gen0_size() { return _min_gen0_size; }
264 size_t initial_gen0_size() { return _initial_gen0_size; }
265 size_t max_gen0_size() { return _max_gen0_size; }
266 size_t gen_alignment() { return _gen_alignment; }
267
268 virtual int number_of_generations() = 0;
269
270 virtual GenerationSpec **generations() {
271 assert(_generations != NULL, "Sanity check");
272 return _generations;
273 }
274
275 virtual GenCollectorPolicy* as_generation_policy() { return this; }
276
277 virtual void initialize_generations() { };
278
279 virtual void initialize_all() {
280 CollectorPolicy::initialize_all();
281 initialize_generations();
282 }
283
284 size_t young_gen_size_lower_bound();
285
286 HeapWord* mem_allocate_work(size_t size,
287 bool is_tlab,
288 bool* gc_overhead_limit_was_exceeded);
289
290 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
291
292 // Adaptive size policy
293 virtual void initialize_size_policy(size_t init_eden_size,
294 size_t init_promo_size,
295 size_t init_survivor_size);
296
297 virtual void post_heap_initialize() {
298 assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
299 }
300 };
301
302 // All of hotspot's current collectors are subtypes of this
303 // class. Currently, these collectors all use the same gen[0],
304 // but have different gen[1] types. If we add another subtype
305 // of CollectorPolicy, this class should be broken out into
306 // its own file.
307
308 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
309 protected:
310 size_t _min_gen1_size;
311 size_t _initial_gen1_size;
312 size_t _max_gen1_size;
313
314 void initialize_flags();
315 void initialize_size_info();
316
317 DEBUG_ONLY(void assert_flags();)
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
324 // Accessors
325 size_t min_gen1_size() { return _min_gen1_size; }
326 size_t initial_gen1_size() { return _initial_gen1_size; }
327 size_t max_gen1_size() { return _max_gen1_size; }
328
329 // Inherited methods
330 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
331
332 int number_of_generations() { return 2; }
333 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
334
335 virtual CollectorPolicy::Name kind() {
336 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
337 }
338 };
339
340 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
341 protected:
342 void initialize_alignments();
343 void initialize_generations();
344
345 public:
346 MarkSweepPolicy() {}
347
348 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
349
350 void initialize_gc_policy_counters();
351 };
352
353 #endif // SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
|
30 #include "memory/generationSpec.hpp"
31 #include "memory/genRemSet.hpp"
32 #include "utilities/macros.hpp"
33
34 // This class (or more correctly, subtypes of this class)
35 // are used to define global garbage collector attributes.
36 // This includes initialization of generations and any other
37 // shared resources they may need.
38 //
39 // In general, all flag adjustment and validation should be
40 // done in initialize_flags(), which is called prior to
41 // initialize_size_info().
42 //
43 // This class is not fully developed yet. As more collector(s)
44 // are added, it is expected that we will come across further
45 // behavior that requires global attention. The correct place
46 // to deal with those issues is this class.
47
48 // Forward declarations.
49 class GenCollectorPolicy;
50 class AdaptiveSizePolicy;
51 #if INCLUDE_ALL_GCS
52 class ConcurrentMarkSweepPolicy;
53 class G1CollectorPolicy;
54 #endif // INCLUDE_ALL_GCS
55
56 class GCPolicyCounters;
57 class MarkSweepPolicy;
58
59 class CollectorPolicy : public CHeapObj<mtGC> {
60 protected:
61 GCPolicyCounters* _gc_policy_counters;
62
63 virtual void initialize_alignments() = 0;
64 virtual void initialize_flags();
65 virtual void initialize_size_info();
66
67 DEBUG_ONLY(virtual void assert_flags();)
68 DEBUG_ONLY(virtual void assert_size_info();)
69
96
97 public:
98 virtual void initialize_all() {
99 initialize_alignments();
100 initialize_flags();
101 initialize_size_info();
102 }
103
104 // Return maximum heap alignment that may be imposed by the policy.
105 static size_t compute_heap_alignment();
106
107 size_t space_alignment() { return _space_alignment; }
108 size_t heap_alignment() { return _heap_alignment; }
109
110 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
111 size_t max_heap_byte_size() { return _max_heap_byte_size; }
112 size_t min_heap_byte_size() { return _min_heap_byte_size; }
113
114 enum Name {
115 CollectorPolicyKind,
116 GenCollectorPolicyKind,
117 ConcurrentMarkSweepPolicyKind,
118 ASConcurrentMarkSweepPolicyKind,
119 G1CollectorPolicyKind
120 };
121
122 AdaptiveSizePolicy* size_policy() { return _size_policy; }
123 bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; }
124 void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; }
125 // Returns the current value of _should_clear_all_soft_refs.
126 // _should_clear_all_soft_refs is set to false as a side effect.
127 bool use_should_clear_all_soft_refs(bool v);
128 bool all_soft_refs_clear() { return _all_soft_refs_clear; }
129 void set_all_soft_refs_clear(bool v) { _all_soft_refs_clear = v; }
130
131 // Called by the GC after Soft Refs have been cleared to indicate
132 // that the request in _should_clear_all_soft_refs has been fulfilled.
133 void cleared_all_soft_refs();
134
135 // Identification methods.
136 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
137 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
138 #if INCLUDE_ALL_GCS
139 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
140 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
141 #endif // INCLUDE_ALL_GCS
142 // Note that these are not virtual.
143 bool is_generation_policy() { return as_generation_policy() != NULL; }
144 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
145 #if INCLUDE_ALL_GCS
146 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
147 bool is_g1_policy() { return as_g1_policy() != NULL; }
148 #else // INCLUDE_ALL_GCS
149 bool is_concurrent_mark_sweep_policy() { return false; }
150 bool is_g1_policy() { return false; }
151 #endif // INCLUDE_ALL_GCS
152
153
154 virtual BarrierSet::Name barrier_set_name() = 0;
155
156 // Create the remembered set (to cover the given reserved region,
157 // allowing breaking up into at most "max_covered_regions").
158 virtual GenRemSet* create_rem_set(MemRegion reserved,
159 int max_covered_regions);
160
161 // This method controls how a collector satisfies a request
162 // for a block of memory. "gc_time_limit_was_exceeded" will
163 // be set to true if the adaptive size policy determine that
205 CollectorPolicy* _collector_policy;
206 public:
207 ClearedAllSoftRefs(bool clear_all_soft_refs,
208 CollectorPolicy* collector_policy) :
209 _clear_all_soft_refs(clear_all_soft_refs),
210 _collector_policy(collector_policy) {}
211
212 ~ClearedAllSoftRefs() {
213 if (_clear_all_soft_refs) {
214 _collector_policy->cleared_all_soft_refs();
215 }
216 }
217 };
218
219 class GenCollectorPolicy : public CollectorPolicy {
220 friend class TestGenCollectorPolicy;
221 protected:
222 size_t _min_gen0_size;
223 size_t _initial_gen0_size;
224 size_t _max_gen0_size;
225 size_t _min_gen1_size;
226 size_t _initial_gen1_size;
227 size_t _max_gen1_size;
228
229 // _gen_alignment and _space_alignment will have the same value most of the
230 // time. When using large pages they can differ.
231 size_t _gen_alignment;
232
233 GenerationSpec **_generations;
234
235 // Return true if an allocation should be attempted in the older generation
236 // if it fails in the younger generation. Return false, otherwise.
237 virtual bool should_try_older_generation_allocation(size_t word_size) const;
238
239 void initialize_flags();
240 void initialize_size_info();
241
242 DEBUG_ONLY(void assert_flags();)
243 DEBUG_ONLY(void assert_size_info();)
244
245 // Try to allocate space by expanding the heap.
246 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
247
248 // Compute max heap alignment.
249 size_t compute_max_alignment();
250
251 // Scale the base_size by NewRatio according to
252 // result = base_size / (NewRatio + 1)
253 // and align by min_alignment()
254 size_t scale_by_NewRatio_aligned(size_t base_size);
255
256 // Bound the value by the given maximum minus the min_alignment.
257 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
258
259 public:
260 GenCollectorPolicy();
261
262 // Accessors
263 size_t min_gen0_size() { return _min_gen0_size; }
264 size_t initial_gen0_size() { return _initial_gen0_size; }
265 size_t max_gen0_size() { return _max_gen0_size; }
266 size_t gen_alignment() { return _gen_alignment; }
267 size_t min_gen1_size() { return _min_gen1_size; }
268 size_t initial_gen1_size() { return _initial_gen1_size; }
269 size_t max_gen1_size() { return _max_gen1_size; }
270
271 int number_of_generations() { return 2; }
272
273 virtual GenerationSpec **generations() {
274 assert(_generations != NULL, "Sanity check");
275 return _generations;
276 }
277
278 virtual GenCollectorPolicy* as_generation_policy() { return this; }
279
280 virtual void initialize_generations() { };
281
282 virtual void initialize_all() {
283 CollectorPolicy::initialize_all();
284 initialize_generations();
285 }
286
287 size_t young_gen_size_lower_bound();
288
289 HeapWord* mem_allocate_work(size_t size,
290 bool is_tlab,
291 bool* gc_overhead_limit_was_exceeded);
292
293 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
294
295 // Adaptive size policy
296 virtual void initialize_size_policy(size_t init_eden_size,
297 size_t init_promo_size,
298 size_t init_survivor_size);
299
300 virtual void post_heap_initialize() {
301 assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
302 }
303
304 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
305
306 virtual CollectorPolicy::Name kind() {
307 return CollectorPolicy::GenCollectorPolicyKind;
308 }
309 };
310
311 class MarkSweepPolicy : public GenCollectorPolicy {
312 protected:
313 void initialize_alignments();
314 void initialize_generations();
315
316 public:
317 MarkSweepPolicy() {}
318
319 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
320
321 void initialize_gc_policy_counters();
322 };
323
324 #endif // SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
|