31 #include "memory/gcLocker.inline.hpp"
32 #include "memory/genCollectedHeap.hpp"
33 #include "memory/generationSpec.hpp"
34 #include "memory/space.hpp"
35 #include "memory/universe.hpp"
36 #include "runtime/arguments.hpp"
37 #include "runtime/globals_extension.hpp"
38 #include "runtime/handles.inline.hpp"
39 #include "runtime/java.hpp"
40 #include "runtime/thread.inline.hpp"
41 #include "runtime/vmThread.hpp"
42 #include "utilities/macros.hpp"
43 #if INCLUDE_ALL_GCS
44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
46 #endif // INCLUDE_ALL_GCS
47
48 // CollectorPolicy methods.
49
50 void CollectorPolicy::initialize_flags() {
51 if (MetaspaceSize > MaxMetaspaceSize) {
52 MaxMetaspaceSize = MetaspaceSize;
53 }
54 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment()));
55 // Don't increase Metaspace size limit above specified.
56 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment());
57 if (MetaspaceSize > MaxMetaspaceSize) {
58 MetaspaceSize = MaxMetaspaceSize;
59 }
60
61 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment()));
62 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment()));
63
64 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
65
66 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment");
67 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment");
68 if (MetaspaceSize < 256*K) {
69 vm_exit_during_initialization("Too small initial Metaspace size");
70 }
71 }
72
73 void CollectorPolicy::initialize_size_info() {
74 // User inputs from -mx and ms are aligned
75 set_initial_heap_byte_size(InitialHeapSize);
76 if (initial_heap_byte_size() == 0) {
77 set_initial_heap_byte_size(NewSize + OldSize);
78 }
79 set_initial_heap_byte_size(align_size_up(_initial_heap_byte_size,
80 min_alignment()));
81
82 set_min_heap_byte_size(Arguments::min_heap_size());
83 if (min_heap_byte_size() == 0) {
84 set_min_heap_byte_size(NewSize + OldSize);
85 }
86 set_min_heap_byte_size(align_size_up(_min_heap_byte_size,
87 min_alignment()));
88
89 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
90
91 // Check heap parameter properties
92 if (initial_heap_byte_size() < M) {
93 vm_exit_during_initialization("Too small initial heap");
94 }
95 // Check heap parameter properties
96 if (min_heap_byte_size() < M) {
97 vm_exit_during_initialization("Too small minimum heap");
98 }
99 if (initial_heap_byte_size() <= NewSize) {
100 // make sure there is at least some room in old space
101 vm_exit_during_initialization("Too small initial heap for new size specified");
102 }
103 if (max_heap_byte_size() < min_heap_byte_size()) {
104 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
105 }
106 if (initial_heap_byte_size() < min_heap_byte_size()) {
107 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
108 }
216 NewSize = align_size_down(NewSize, min_alignment());
217 MaxNewSize = align_size_down(MaxNewSize, min_alignment());
218
219 // Check validity of heap flags
220 assert(NewSize % min_alignment() == 0, "eden space alignment");
221 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
222
223 if (NewSize < 3*min_alignment()) {
224 // make sure there room for eden and two survivor spaces
225 vm_exit_during_initialization("Too small new size specified");
226 }
227 if (SurvivorRatio < 1 || NewRatio < 1) {
228 vm_exit_during_initialization("Invalid heap ratio specified");
229 }
230 }
231
232 void TwoGenerationCollectorPolicy::initialize_flags() {
233 GenCollectorPolicy::initialize_flags();
234
235 OldSize = align_size_down(OldSize, min_alignment());
236 if (NewSize + OldSize > MaxHeapSize) {
237 MaxHeapSize = NewSize + OldSize;
238 }
239
240 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) {
241 // NewRatio will be used later to set the young generation size so we use
242 // it to calculate how big the heap should be based on the requested OldSize
243 // and NewRatio.
244 assert(NewRatio > 0, "NewRatio should have been set up earlier");
245 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
246
247 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment());
248 MaxHeapSize = calculated_heapsize;
249 InitialHeapSize = calculated_heapsize;
250 }
251 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
252
253 always_do_update_barrier = UseConcMarkSweepGC;
254
255 // Check validity of heap flags
256 assert(OldSize % min_alignment() == 0, "old space alignment");
257 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
258 }
259
260 // Values set on the command line win over any ergonomically
261 // set command line parameters.
262 // Ergonomic choice of parameters are done before this
263 // method is called. Values for command line parameters such as NewSize
264 // and MaxNewSize feed those ergonomic choices into this method.
265 // This method makes the final generation sizings consistent with
266 // themselves and with overall heap sizings.
267 // In the absence of explicitly set command line flags, policies
268 // such as the use of NewRatio are used to size the generation.
269 void GenCollectorPolicy::initialize_size_info() {
270 CollectorPolicy::initialize_size_info();
|
31 #include "memory/gcLocker.inline.hpp"
32 #include "memory/genCollectedHeap.hpp"
33 #include "memory/generationSpec.hpp"
34 #include "memory/space.hpp"
35 #include "memory/universe.hpp"
36 #include "runtime/arguments.hpp"
37 #include "runtime/globals_extension.hpp"
38 #include "runtime/handles.inline.hpp"
39 #include "runtime/java.hpp"
40 #include "runtime/thread.inline.hpp"
41 #include "runtime/vmThread.hpp"
42 #include "utilities/macros.hpp"
43 #if INCLUDE_ALL_GCS
44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
46 #endif // INCLUDE_ALL_GCS
47
48 // CollectorPolicy methods.
49
50 void CollectorPolicy::initialize_flags() {
51 if (MaxHeapSize < InitialHeapSize) {
52 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
53 }
54
55 if (MetaspaceSize > MaxMetaspaceSize) {
56 MaxMetaspaceSize = MetaspaceSize;
57 }
58 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment()));
59 // Don't increase Metaspace size limit above specified.
60 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment());
61 if (MetaspaceSize > MaxMetaspaceSize) {
62 MetaspaceSize = MaxMetaspaceSize;
63 }
64
65 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment()));
66 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment()));
67
68 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
69
70 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment");
71 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment");
72 if (MetaspaceSize < 256*K) {
73 vm_exit_during_initialization("Too small initial Metaspace size");
74 }
75 }
76
77 void CollectorPolicy::initialize_size_info() {
78 // User inputs from -mx and ms must be aligned
79 set_min_heap_byte_size(align_size_up(Arguments::min_heap_size(), min_alignment()));
80 set_initial_heap_byte_size(align_size_up(InitialHeapSize, min_alignment()));
81 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
82
83 // Check heap parameter properties
84 if (initial_heap_byte_size() < M) {
85 vm_exit_during_initialization("Too small initial heap");
86 }
87 // Check heap parameter properties
88 if (min_heap_byte_size() < M) {
89 vm_exit_during_initialization("Too small minimum heap");
90 }
91 if (initial_heap_byte_size() <= NewSize) {
92 // make sure there is at least some room in old space
93 vm_exit_during_initialization("Too small initial heap for new size specified");
94 }
95 if (max_heap_byte_size() < min_heap_byte_size()) {
96 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
97 }
98 if (initial_heap_byte_size() < min_heap_byte_size()) {
99 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
100 }
208 NewSize = align_size_down(NewSize, min_alignment());
209 MaxNewSize = align_size_down(MaxNewSize, min_alignment());
210
211 // Check validity of heap flags
212 assert(NewSize % min_alignment() == 0, "eden space alignment");
213 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
214
215 if (NewSize < 3*min_alignment()) {
216 // make sure there room for eden and two survivor spaces
217 vm_exit_during_initialization("Too small new size specified");
218 }
219 if (SurvivorRatio < 1 || NewRatio < 1) {
220 vm_exit_during_initialization("Invalid heap ratio specified");
221 }
222 }
223
224 void TwoGenerationCollectorPolicy::initialize_flags() {
225 GenCollectorPolicy::initialize_flags();
226
227 OldSize = align_size_down(OldSize, min_alignment());
228
229 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) {
230 // NewRatio will be used later to set the young generation size so we use
231 // it to calculate how big the heap should be based on the requested OldSize
232 // and NewRatio.
233 assert(NewRatio > 0, "NewRatio should have been set up earlier");
234 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
235
236 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment());
237 MaxHeapSize = calculated_heapsize;
238 InitialHeapSize = calculated_heapsize;
239 }
240 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
241
242 // adjust max heap size if necessary
243 if (NewSize + OldSize > MaxHeapSize) {
244 if (FLAG_IS_CMDLINE(MaxHeapSize)) {
245 // somebody set a maximum heap size with the intention that we should not
246 // exceed it. Adjust New/OldSize as necessary.
247 uintx calculated_size = NewSize + OldSize;
248 double shrink_factor = (double) MaxHeapSize / calculated_size;
249 // align
250 NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment());
251 // OldSize is already aligned because above we aligned MaxHeapSize to
252 // max_alignment(), and we just made sure that NewSize is aligned to
253 // min_alignment(). In initialize_flags() we verified that max_alignment()
254 // is a multiple of min_alignment().
255 OldSize = MaxHeapSize - NewSize;
256 } else {
257 MaxHeapSize = NewSize + OldSize;
258 }
259 }
260 // need to do this again
261 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
262
263 always_do_update_barrier = UseConcMarkSweepGC;
264
265 // Check validity of heap flags
266 assert(OldSize % min_alignment() == 0, "old space alignment");
267 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
268 }
269
270 // Values set on the command line win over any ergonomically
271 // set command line parameters.
272 // Ergonomic choice of parameters are done before this
273 // method is called. Values for command line parameters such as NewSize
274 // and MaxNewSize feed those ergonomic choices into this method.
275 // This method makes the final generation sizings consistent with
276 // themselves and with overall heap sizings.
277 // In the absence of explicitly set command line flags, policies
278 // such as the use of NewRatio are used to size the generation.
279 void GenCollectorPolicy::initialize_size_info() {
280 CollectorPolicy::initialize_size_info();
|