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
70 size_t _initial_heap_byte_size;
71 size_t _max_heap_byte_size;
72 size_t _min_heap_byte_size;
73
74 size_t _space_alignment;
75 size_t _heap_alignment;
76
77 // Needed to keep information if MaxHeapSize was set on the command line
78 // when the flag value is aligned etc by ergonomics.
79 bool _max_heap_size_cmdline;
80
81 // The sizing of the heap is controlled by a sizing policy.
82 AdaptiveSizePolicy* _size_policy;
132 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
133 #endif // INCLUDE_ALL_GCS
134 // Note that these are not virtual.
135 bool is_generation_policy() { return as_generation_policy() != NULL; }
136 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
137 #if INCLUDE_ALL_GCS
138 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
139 bool is_g1_policy() { return as_g1_policy() != NULL; }
140 #else // INCLUDE_ALL_GCS
141 bool is_concurrent_mark_sweep_policy() { return false; }
142 bool is_g1_policy() { return false; }
143 #endif // INCLUDE_ALL_GCS
144
145
146 virtual CardTableRS* create_rem_set(MemRegion reserved);
147
148 MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
149 size_t size,
150 Metaspace::MetadataType mdtype);
151
152 // Performance Counter support
153 GCPolicyCounters* counters() { return _gc_policy_counters; }
154
155 // Create the jstat counters for the GC policy. By default, policy's
156 // don't have associated counters, and we complain if this is invoked.
157 virtual void initialize_gc_policy_counters() {
158 ShouldNotReachHere();
159 }
160
161 // Do any updates required to global flags that are due to heap initialization
162 // changes
163 virtual void post_heap_initialize() = 0;
164 };
165
166 class ClearedAllSoftRefs : public StackObj {
167 bool _clear_all_soft_refs;
168 CollectorPolicy* _collector_policy;
169 public:
170 ClearedAllSoftRefs(bool clear_all_soft_refs,
171 CollectorPolicy* collector_policy) :
172 _clear_all_soft_refs(clear_all_soft_refs),
173 _collector_policy(collector_policy) {}
174
175 ~ClearedAllSoftRefs() {
176 if (_clear_all_soft_refs) {
177 _collector_policy->cleared_all_soft_refs();
178 }
179 }
180 };
181
182 class GenCollectorPolicy : public CollectorPolicy {
183 friend class TestGenCollectorPolicy;
184 friend class VMStructs;
185 protected:
186 size_t _min_young_size;
187 size_t _initial_young_size;
188 size_t _max_young_size;
189 size_t _min_old_size;
190 size_t _initial_old_size;
191 size_t _max_old_size;
192
193 // _gen_alignment and _space_alignment will have the same value most of the
194 // time. When using large pages they can differ.
195 size_t _gen_alignment;
196
197 GenerationSpec* _young_gen_spec;
198 GenerationSpec* _old_gen_spec;
199
200 // Return true if an allocation should be attempted in the older generation
201 // if it fails in the younger generation. Return false, otherwise.
202 virtual bool should_try_older_generation_allocation(size_t word_size) const;
203
204 void initialize_flags();
205 void initialize_size_info();
206
207 DEBUG_ONLY(void assert_flags();)
208 DEBUG_ONLY(void assert_size_info();)
209
210 // Try to allocate space by expanding the heap.
211 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
212
213 // Compute max heap alignment.
214 size_t compute_max_alignment();
215
216 // Scale the base_size by NewRatio according to
217 // result = base_size / (NewRatio + 1)
218 // and align by min_alignment()
219 size_t scale_by_NewRatio_aligned(size_t base_size);
224 public:
225 GenCollectorPolicy();
226
227 // Accessors
228 size_t min_young_size() { return _min_young_size; }
229 size_t initial_young_size() { return _initial_young_size; }
230 size_t max_young_size() { return _max_young_size; }
231 size_t gen_alignment() { return _gen_alignment; }
232 size_t min_old_size() { return _min_old_size; }
233 size_t initial_old_size() { return _initial_old_size; }
234 size_t max_old_size() { return _max_old_size; }
235
236 GenerationSpec* young_gen_spec() const {
237 assert(_young_gen_spec != NULL, "_young_gen_spec should have been initialized");
238 return _young_gen_spec;
239 }
240
241 GenerationSpec* old_gen_spec() const {
242 assert(_old_gen_spec != NULL, "_old_gen_spec should have been initialized");
243 return _old_gen_spec;
244 }
245
246 virtual GenCollectorPolicy* as_generation_policy() { return this; }
247
248 virtual void initialize_generations() { };
249
250 virtual void initialize_all() {
251 CollectorPolicy::initialize_all();
252 initialize_generations();
253 }
254
255 size_t young_gen_size_lower_bound();
256
257 size_t old_gen_size_lower_bound();
258
259 HeapWord* mem_allocate_work(size_t size,
260 bool is_tlab,
261 bool* gc_overhead_limit_was_exceeded);
262
263 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
|
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 virtual void initialize_alignments() = 0;
62 virtual void initialize_flags();
63 virtual void initialize_size_info();
64
65 DEBUG_ONLY(virtual void assert_flags();)
66 DEBUG_ONLY(virtual void assert_size_info();)
67
68 size_t _initial_heap_byte_size;
69 size_t _max_heap_byte_size;
70 size_t _min_heap_byte_size;
71
72 size_t _space_alignment;
73 size_t _heap_alignment;
74
75 // Needed to keep information if MaxHeapSize was set on the command line
76 // when the flag value is aligned etc by ergonomics.
77 bool _max_heap_size_cmdline;
78
79 // The sizing of the heap is controlled by a sizing policy.
80 AdaptiveSizePolicy* _size_policy;
130 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
131 #endif // INCLUDE_ALL_GCS
132 // Note that these are not virtual.
133 bool is_generation_policy() { return as_generation_policy() != NULL; }
134 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
135 #if INCLUDE_ALL_GCS
136 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
137 bool is_g1_policy() { return as_g1_policy() != NULL; }
138 #else // INCLUDE_ALL_GCS
139 bool is_concurrent_mark_sweep_policy() { return false; }
140 bool is_g1_policy() { return false; }
141 #endif // INCLUDE_ALL_GCS
142
143
144 virtual CardTableRS* create_rem_set(MemRegion reserved);
145
146 MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
147 size_t size,
148 Metaspace::MetadataType mdtype);
149
150 // Do any updates required to global flags that are due to heap initialization
151 // changes
152 virtual void post_heap_initialize() = 0;
153 };
154
155 class ClearedAllSoftRefs : public StackObj {
156 bool _clear_all_soft_refs;
157 CollectorPolicy* _collector_policy;
158 public:
159 ClearedAllSoftRefs(bool clear_all_soft_refs,
160 CollectorPolicy* collector_policy) :
161 _clear_all_soft_refs(clear_all_soft_refs),
162 _collector_policy(collector_policy) {}
163
164 ~ClearedAllSoftRefs() {
165 if (_clear_all_soft_refs) {
166 _collector_policy->cleared_all_soft_refs();
167 }
168 }
169 };
170
171 class GenCollectorPolicy : public CollectorPolicy {
172 friend class TestGenCollectorPolicy;
173 friend class VMStructs;
174 protected:
175 size_t _min_young_size;
176 size_t _initial_young_size;
177 size_t _max_young_size;
178 size_t _min_old_size;
179 size_t _initial_old_size;
180 size_t _max_old_size;
181
182 // _gen_alignment and _space_alignment will have the same value most of the
183 // time. When using large pages they can differ.
184 size_t _gen_alignment;
185
186 GenerationSpec* _young_gen_spec;
187 GenerationSpec* _old_gen_spec;
188
189 GCPolicyCounters* _gc_policy_counters;
190
191 // Return true if an allocation should be attempted in the older generation
192 // if it fails in the younger generation. Return false, otherwise.
193 virtual bool should_try_older_generation_allocation(size_t word_size) const;
194
195 void initialize_flags();
196 void initialize_size_info();
197
198 DEBUG_ONLY(void assert_flags();)
199 DEBUG_ONLY(void assert_size_info();)
200
201 // Try to allocate space by expanding the heap.
202 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
203
204 // Compute max heap alignment.
205 size_t compute_max_alignment();
206
207 // Scale the base_size by NewRatio according to
208 // result = base_size / (NewRatio + 1)
209 // and align by min_alignment()
210 size_t scale_by_NewRatio_aligned(size_t base_size);
215 public:
216 GenCollectorPolicy();
217
218 // Accessors
219 size_t min_young_size() { return _min_young_size; }
220 size_t initial_young_size() { return _initial_young_size; }
221 size_t max_young_size() { return _max_young_size; }
222 size_t gen_alignment() { return _gen_alignment; }
223 size_t min_old_size() { return _min_old_size; }
224 size_t initial_old_size() { return _initial_old_size; }
225 size_t max_old_size() { return _max_old_size; }
226
227 GenerationSpec* young_gen_spec() const {
228 assert(_young_gen_spec != NULL, "_young_gen_spec should have been initialized");
229 return _young_gen_spec;
230 }
231
232 GenerationSpec* old_gen_spec() const {
233 assert(_old_gen_spec != NULL, "_old_gen_spec should have been initialized");
234 return _old_gen_spec;
235 }
236
237 // Performance Counter support
238 GCPolicyCounters* counters() { return _gc_policy_counters; }
239
240 // Create the jstat counters for the GC policy. By default, policies
241 // don't have associated counters, and we complain if this is invoked.
242 virtual void initialize_gc_policy_counters() {
243 ShouldNotReachHere();
244 }
245
246 virtual GenCollectorPolicy* as_generation_policy() { return this; }
247
248 virtual void initialize_generations() { };
249
250 virtual void initialize_all() {
251 CollectorPolicy::initialize_all();
252 initialize_generations();
253 }
254
255 size_t young_gen_size_lower_bound();
256
257 size_t old_gen_size_lower_bound();
258
259 HeapWord* mem_allocate_work(size_t size,
260 bool is_tlab,
261 bool* gc_overhead_limit_was_exceeded);
262
263 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
|