21 * questions. |
21 * questions. |
22 * |
22 * |
23 */ |
23 */ |
24 |
24 |
25 #include "precompiled.hpp" |
25 #include "precompiled.hpp" |
|
26 #include "gc/shared/collectedHeap.hpp" |
|
27 #include "gc/shared/collectorPolicy.hpp" |
|
28 #include "gc/shared/threadLocalAllocBuffer.hpp" |
26 #include "runtime/arguments.hpp" |
29 #include "runtime/arguments.hpp" |
27 #include "runtime/commandLineFlagConstraintsGC.hpp" |
30 #include "runtime/commandLineFlagConstraintsGC.hpp" |
28 #include "runtime/commandLineFlagRangeList.hpp" |
31 #include "runtime/commandLineFlagRangeList.hpp" |
29 #include "runtime/globals.hpp" |
32 #include "runtime/globals.hpp" |
|
33 #include "runtime/globals_extension.hpp" |
30 #include "utilities/defaultStream.hpp" |
34 #include "utilities/defaultStream.hpp" |
31 |
35 |
32 #if INCLUDE_ALL_GCS |
36 #if INCLUDE_ALL_GCS |
33 #include "gc/g1/g1_globals.hpp" |
37 #include "gc/g1/g1_globals.hpp" |
34 #include "gc/g1/heapRegionBounds.inline.hpp" |
38 #include "gc/g1/heapRegionBounds.inline.hpp" |
35 #include "gc/parallel/parallelScavengeHeap.hpp" |
|
36 #include "gc/shared/plab.hpp" |
39 #include "gc/shared/plab.hpp" |
37 #endif // INCLUDE_ALL_GCS |
40 #endif // INCLUDE_ALL_GCS |
38 #ifdef COMPILER1 |
41 #ifdef COMPILER1 |
39 #include "c1/c1_globals.hpp" |
42 #include "c1/c1_globals.hpp" |
40 #endif // COMPILER1 |
43 #endif // COMPILER1 |
41 #ifdef COMPILER2 |
44 #ifdef COMPILER2 |
42 #include "opto/c2_globals.hpp" |
45 #include "opto/c2_globals.hpp" |
43 #endif // COMPILER2 |
46 #endif // COMPILER2 |
44 |
47 |
|
48 // Some flags that have default values that indicate that the |
|
49 // JVM should automatically determine an appropriate value |
|
50 // for that flag. In those cases it is only appropriate for the |
|
51 // constraint checking to be done if the user has specified the |
|
52 // value(s) of the flag(s) on the command line. In the constraint |
|
53 // checking functions, FLAG_IS_CMDLINE() is used to check if |
|
54 // the flag has been set by the user and so should be checked. |
|
55 |
|
56 #if INCLUDE_ALL_GCS |
|
57 static Flag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(uint threads, uintx threshold, bool verbose) { |
|
58 // CMSWorkQueueDrainThreshold is verified to be less than max_juint |
|
59 if (UseConcMarkSweepGC && (threads > (uint)(max_jint / (uint)threshold))) { |
|
60 CommandLineError::print(verbose, |
|
61 "ParallelGCThreads (" UINT32_FORMAT ") or CMSWorkQueueDrainThreshold (" |
|
62 UINTX_FORMAT ") is too large\n", |
|
63 threads, threshold); |
|
64 return Flag::VIOLATES_CONSTRAINT; |
|
65 } |
|
66 return Flag::SUCCESS; |
|
67 } |
|
68 #endif |
|
69 |
|
70 // As ParallelGCThreads differs among GC modes, we need constraint function. |
|
71 Flag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose) { |
|
72 Flag::Error status = Flag::SUCCESS; |
|
73 |
|
74 #if INCLUDE_ALL_GCS |
|
75 // Parallel GC passes ParallelGCThreads when creating GrowableArray as 'int' type parameter. |
|
76 // So can't exceed with "max_jint" |
|
77 if (UseParallelGC && (value > (uint)max_jint)) { |
|
78 CommandLineError::print(verbose, |
|
79 "ParallelGCThreads (" UINT32_FORMAT ") must be " |
|
80 "less than or equal to " UINT32_FORMAT " for Parallel GC\n", |
|
81 value, max_jint); |
|
82 return Flag::VIOLATES_CONSTRAINT; |
|
83 } |
|
84 // To avoid overflow at ParScanClosure::do_oop_work. |
|
85 if (UseConcMarkSweepGC && (value > (max_jint / 10))) { |
|
86 CommandLineError::print(verbose, |
|
87 "ParallelGCThreads (" UINT32_FORMAT ") must be " |
|
88 "less than or equal to " UINT32_FORMAT " for CMS GC\n", |
|
89 value, (max_jint / 10)); |
|
90 return Flag::VIOLATES_CONSTRAINT; |
|
91 } |
|
92 status = ParallelGCThreadsAndCMSWorkQueueDrainThreshold(value, CMSWorkQueueDrainThreshold, verbose); |
|
93 #endif |
|
94 return status; |
|
95 } |
|
96 |
|
97 // As ConcGCThreads should be smaller than ParallelGCThreads, |
|
98 // we need constraint function. |
|
99 Flag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose) { |
|
100 #if INCLUDE_ALL_GCS |
|
101 // CMS and G1 GCs use ConcGCThreads. |
|
102 if ((UseConcMarkSweepGC || UseG1GC) && (value > ParallelGCThreads)) { |
|
103 CommandLineError::print(verbose, |
|
104 "ConcGCThreads (" UINT32_FORMAT ") must be " |
|
105 "less than or equal to ParallelGCThreads (" UINT32_FORMAT ")\n", |
|
106 value, ParallelGCThreads); |
|
107 return Flag::VIOLATES_CONSTRAINT; |
|
108 } |
|
109 #endif |
|
110 return Flag::SUCCESS; |
|
111 } |
|
112 |
45 static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) { |
113 static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) { |
46 #if INCLUDE_ALL_GCS |
114 #if INCLUDE_ALL_GCS |
47 if ((UseConcMarkSweepGC || UseG1GC) && (value < PLAB::min_size())) { |
115 if ((UseConcMarkSweepGC || UseG1GC) && (value < PLAB::min_size())) { |
48 CommandLineError::print(verbose, |
116 CommandLineError::print(verbose, |
49 "%s (" SIZE_FORMAT ") must be " |
117 "%s (" SIZE_FORMAT ") must be " |
125 } else { |
234 } else { |
126 return Flag::SUCCESS; |
235 return Flag::SUCCESS; |
127 } |
236 } |
128 } |
237 } |
129 |
238 |
130 // GC workaround for "-XX:+UseConcMarkSweepGC" |
|
131 // which sets InitialTenuringThreshold to 7 but leaves MaxTenuringThreshold remaining at 6 |
|
132 // and therefore would invalidate the constraint |
|
133 #define UseConcMarkSweepGCWorkaroundIfNeeded(initial, max) { \ |
|
134 if ((initial == 7) && (max == 6)) { \ |
|
135 return Flag::SUCCESS; \ |
|
136 } \ |
|
137 } |
|
138 |
|
139 Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) { |
239 Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) { |
140 UseConcMarkSweepGCWorkaroundIfNeeded(value, MaxTenuringThreshold); |
240 #if INCLUDE_ALL_GCS |
141 |
241 // InitialTenuringThreshold is only used for ParallelGC. |
142 if (value > MaxTenuringThreshold) { |
242 if (UseParallelGC && (value > MaxTenuringThreshold)) { |
143 CommandLineError::print(verbose, |
243 CommandLineError::print(verbose, |
144 "InitialTenuringThreshold (" UINTX_FORMAT ") must be " |
244 "InitialTenuringThreshold (" UINTX_FORMAT ") must be " |
145 "less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n", |
245 "less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n", |
146 value, MaxTenuringThreshold); |
246 value, MaxTenuringThreshold); |
147 return Flag::VIOLATES_CONSTRAINT; |
247 return Flag::VIOLATES_CONSTRAINT; |
148 } else { |
248 } |
149 return Flag::SUCCESS; |
249 #endif |
150 } |
250 return Flag::SUCCESS; |
151 } |
251 } |
152 |
252 |
153 Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) { |
253 Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) { |
154 UseConcMarkSweepGCWorkaroundIfNeeded(InitialTenuringThreshold, value); |
254 #if INCLUDE_ALL_GCS |
155 |
255 // As only ParallelGC uses InitialTenuringThreshold, |
156 if (value < InitialTenuringThreshold) { |
256 // we don't need to compare InitialTenuringThreshold with MaxTenuringThreshold. |
|
257 if (UseParallelGC && (value < InitialTenuringThreshold)) { |
157 CommandLineError::print(verbose, |
258 CommandLineError::print(verbose, |
158 "MaxTenuringThreshold (" UINTX_FORMAT ") must be " |
259 "MaxTenuringThreshold (" UINTX_FORMAT ") must be " |
159 "greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n", |
260 "greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n", |
160 value, InitialTenuringThreshold); |
261 value, InitialTenuringThreshold); |
161 return Flag::VIOLATES_CONSTRAINT; |
262 return Flag::VIOLATES_CONSTRAINT; |
162 } else { |
263 } |
163 return Flag::SUCCESS; |
264 #endif |
164 } |
265 |
165 } |
266 // MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true |
166 |
267 if ((value == 0) && (NeverTenure || !AlwaysTenure)) { |
167 #if INCLUDE_ALL_GCS |
268 CommandLineError::print(verbose, |
|
269 "MaxTenuringThreshold (0) should match to NeverTenure=false " |
|
270 "&& AlwaysTenure=true. But we have NeverTenure=%s " |
|
271 "AlwaysTenure=%s\n", |
|
272 NeverTenure ? "true" : "false", |
|
273 AlwaysTenure ? "true" : "false"); |
|
274 return Flag::VIOLATES_CONSTRAINT; |
|
275 } |
|
276 return Flag::SUCCESS; |
|
277 } |
|
278 |
|
279 #if INCLUDE_ALL_GCS |
|
280 Flag::Error G1RSetRegionEntriesConstraintFunc(intx value, bool verbose) { |
|
281 if (!UseG1GC) return Flag::SUCCESS; |
|
282 |
|
283 // Default value of G1RSetRegionEntries=0 means will be set ergonomically. |
|
284 // Minimum value is 1. |
|
285 if (FLAG_IS_CMDLINE(G1RSetRegionEntries) && (value < 1)) { |
|
286 CommandLineError::print(verbose, |
|
287 "G1RSetRegionEntries (" INTX_FORMAT ") must be " |
|
288 "greater than or equal to 1\n", |
|
289 value); |
|
290 return Flag::VIOLATES_CONSTRAINT; |
|
291 } else { |
|
292 return Flag::SUCCESS; |
|
293 } |
|
294 } |
|
295 |
|
296 Flag::Error G1RSetSparseRegionEntriesConstraintFunc(intx value, bool verbose) { |
|
297 if (!UseG1GC) return Flag::SUCCESS; |
|
298 |
|
299 // Default value of G1RSetSparseRegionEntries=0 means will be set ergonomically. |
|
300 // Minimum value is 1. |
|
301 if (FLAG_IS_CMDLINE(G1RSetSparseRegionEntries) && (value < 1)) { |
|
302 CommandLineError::print(verbose, |
|
303 "G1RSetSparseRegionEntries (" INTX_FORMAT ") must be " |
|
304 "greater than or equal to 1\n", |
|
305 value); |
|
306 return Flag::VIOLATES_CONSTRAINT; |
|
307 } else { |
|
308 return Flag::SUCCESS; |
|
309 } |
|
310 } |
|
311 |
|
312 Flag::Error G1YoungSurvRateNumRegionsSummaryConstraintFunc(intx value, bool verbose) { |
|
313 if (!UseG1GC) return Flag::SUCCESS; |
|
314 |
|
315 if (value > (intx)HeapRegionBounds::target_number()) { |
|
316 CommandLineError::print(verbose, |
|
317 "G1YoungSurvRateNumRegionsSummary (" INTX_FORMAT ") must be " |
|
318 "less than or equal to region count (" SIZE_FORMAT ")\n", |
|
319 value, HeapRegionBounds::target_number()); |
|
320 return Flag::VIOLATES_CONSTRAINT; |
|
321 } else { |
|
322 return Flag::SUCCESS; |
|
323 } |
|
324 } |
|
325 |
|
326 Flag::Error G1HeapRegionSizeConstraintFunc(size_t value, bool verbose) { |
|
327 if (!UseG1GC) return Flag::SUCCESS; |
|
328 |
|
329 // Default value of G1HeapRegionSize=0 means will be set ergonomically. |
|
330 if (FLAG_IS_CMDLINE(G1HeapRegionSize) && (value < HeapRegionBounds::min_size())) { |
|
331 CommandLineError::print(verbose, |
|
332 "G1HeapRegionSize (" SIZE_FORMAT ") must be " |
|
333 "greater than or equal to ergonomic heap region minimum size\n", |
|
334 value); |
|
335 return Flag::VIOLATES_CONSTRAINT; |
|
336 } else { |
|
337 return Flag::SUCCESS; |
|
338 } |
|
339 } |
|
340 |
168 Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) { |
341 Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) { |
|
342 if (!UseG1GC) return Flag::SUCCESS; |
|
343 |
169 if (value > G1MaxNewSizePercent) { |
344 if (value > G1MaxNewSizePercent) { |
170 CommandLineError::print(verbose, |
345 CommandLineError::print(verbose, |
171 "G1NewSizePercent (" UINTX_FORMAT ") must be " |
346 "G1NewSizePercent (" UINTX_FORMAT ") must be " |
172 "less than or equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n", |
347 "less than or equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n", |
173 value, G1MaxNewSizePercent); |
348 value, G1MaxNewSizePercent); |
176 return Flag::SUCCESS; |
351 return Flag::SUCCESS; |
177 } |
352 } |
178 } |
353 } |
179 |
354 |
180 Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) { |
355 Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) { |
|
356 if (!UseG1GC) return Flag::SUCCESS; |
|
357 |
181 if (value < G1NewSizePercent) { |
358 if (value < G1NewSizePercent) { |
182 CommandLineError::print(verbose, |
359 CommandLineError::print(verbose, |
183 "G1MaxNewSizePercent (" UINTX_FORMAT ") must be " |
360 "G1MaxNewSizePercent (" UINTX_FORMAT ") must be " |
184 "greater than or equal to G1NewSizePercent (" UINTX_FORMAT ")\n", |
361 "greater than or equal to G1NewSizePercent (" UINTX_FORMAT ")\n", |
185 value, G1NewSizePercent); |
362 value, G1NewSizePercent); |
186 return Flag::VIOLATES_CONSTRAINT; |
363 return Flag::VIOLATES_CONSTRAINT; |
187 } else { |
364 } else { |
188 return Flag::SUCCESS; |
365 return Flag::SUCCESS; |
189 } |
366 } |
190 } |
367 } |
191 |
|
192 #endif // INCLUDE_ALL_GCS |
368 #endif // INCLUDE_ALL_GCS |
193 |
369 |
|
370 Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) { |
|
371 #if INCLUDE_ALL_GCS |
|
372 if (UseConcMarkSweepGC && (value > ((uintx)max_jint / (uintx)ParallelGCThreads))) { |
|
373 CommandLineError::print(verbose, |
|
374 "ParGCStridesPerThread (" UINTX_FORMAT ") must be " |
|
375 "less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n", |
|
376 value, ((uintx)max_jint / (uintx)ParallelGCThreads)); |
|
377 return Flag::VIOLATES_CONSTRAINT; |
|
378 } |
|
379 #endif |
|
380 return Flag::SUCCESS; |
|
381 } |
|
382 |
194 Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) { |
383 Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) { |
195 if (value > CMSOldPLABMax) { |
384 Flag::Error status = Flag::SUCCESS; |
196 CommandLineError::print(verbose, |
385 |
197 "CMSOldPLABMin (" SIZE_FORMAT ") must be " |
386 #if INCLUDE_ALL_GCS |
198 "less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n", |
387 if (UseConcMarkSweepGC) { |
199 value, CMSOldPLABMax); |
388 if (value > CMSOldPLABMax) { |
|
389 CommandLineError::print(verbose, |
|
390 "CMSOldPLABMin (" SIZE_FORMAT ") must be " |
|
391 "less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n", |
|
392 value, CMSOldPLABMax); |
|
393 return Flag::VIOLATES_CONSTRAINT; |
|
394 } |
|
395 status = MaxPLABSizeBounds("CMSOldPLABMin", value, verbose); |
|
396 } |
|
397 #endif |
|
398 return status; |
|
399 } |
|
400 |
|
401 Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) { |
|
402 Flag::Error status = Flag::SUCCESS; |
|
403 |
|
404 #if INCLUDE_ALL_GCS |
|
405 if (UseConcMarkSweepGC) { |
|
406 status = MaxPLABSizeBounds("CMSOldPLABMax", value, verbose); |
|
407 } |
|
408 #endif |
|
409 return status; |
|
410 } |
|
411 |
|
412 Flag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose) { |
|
413 if (value > MarkStackSizeMax) { |
|
414 CommandLineError::print(verbose, |
|
415 "MarkStackSize (" SIZE_FORMAT ") must be " |
|
416 "less than or equal to MarkStackSizeMax (" SIZE_FORMAT ")\n", |
|
417 value, MarkStackSizeMax); |
200 return Flag::VIOLATES_CONSTRAINT; |
418 return Flag::VIOLATES_CONSTRAINT; |
201 } else { |
419 } else { |
202 return Flag::SUCCESS; |
420 return Flag::SUCCESS; |
203 } |
421 } |
204 } |
422 } |
205 |
423 |
206 Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) { |
424 Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) { |
207 if (value <= CMSPrecleanNumerator) { |
425 #if INCLUDE_ALL_GCS |
|
426 if (UseConcMarkSweepGC && (value <= CMSPrecleanNumerator)) { |
208 CommandLineError::print(verbose, |
427 CommandLineError::print(verbose, |
209 "CMSPrecleanDenominator (" UINTX_FORMAT ") must be " |
428 "CMSPrecleanDenominator (" UINTX_FORMAT ") must be " |
210 "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n", |
429 "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n", |
211 value, CMSPrecleanNumerator); |
430 value, CMSPrecleanNumerator); |
212 return Flag::VIOLATES_CONSTRAINT; |
431 return Flag::VIOLATES_CONSTRAINT; |
213 } else { |
432 } |
214 return Flag::SUCCESS; |
433 #endif |
215 } |
434 return Flag::SUCCESS; |
216 } |
435 } |
217 |
436 |
218 Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) { |
437 Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) { |
219 if (value > (CMSPrecleanDenominator - 1)) { |
438 #if INCLUDE_ALL_GCS |
|
439 if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) { |
220 CommandLineError::print(verbose, |
440 CommandLineError::print(verbose, |
221 "CMSPrecleanNumerator (" UINTX_FORMAT ") must be " |
441 "CMSPrecleanNumerator (" UINTX_FORMAT ") must be " |
222 "less than or equal to CMSPrecleanDenominator - 1 (" UINTX_FORMAT ")\n", |
442 "less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n", |
223 value, CMSPrecleanDenominator - 1); |
443 value, CMSPrecleanDenominator); |
|
444 return Flag::VIOLATES_CONSTRAINT; |
|
445 } |
|
446 #endif |
|
447 return Flag::SUCCESS; |
|
448 } |
|
449 |
|
450 Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) { |
|
451 #if INCLUDE_ALL_GCS |
|
452 if (UseConcMarkSweepGC) { |
|
453 return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(ParallelGCThreads, value, verbose); |
|
454 } |
|
455 #endif |
|
456 return Flag::SUCCESS; |
|
457 } |
|
458 |
|
459 Flag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) { |
|
460 #if INCLUDE_ALL_GCS |
|
461 if (UseG1GC && FLAG_IS_CMDLINE(MaxGCPauseMillis) && (value >= GCPauseIntervalMillis)) { |
|
462 CommandLineError::print(verbose, |
|
463 "MaxGCPauseMillis (" UINTX_FORMAT ") must be " |
|
464 "less than GCPauseIntervalMillis (" UINTX_FORMAT ")\n", |
|
465 value, GCPauseIntervalMillis); |
|
466 return Flag::VIOLATES_CONSTRAINT; |
|
467 } |
|
468 #endif |
|
469 |
|
470 return Flag::SUCCESS; |
|
471 } |
|
472 |
|
473 Flag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) { |
|
474 #if INCLUDE_ALL_GCS |
|
475 if (UseG1GC) { |
|
476 if (FLAG_IS_CMDLINE(GCPauseIntervalMillis)) { |
|
477 if (value < 1) { |
|
478 CommandLineError::print(verbose, |
|
479 "GCPauseIntervalMillis (" UINTX_FORMAT ") must be " |
|
480 "greater than or equal to 1\n", |
|
481 value); |
|
482 return Flag::VIOLATES_CONSTRAINT; |
|
483 } |
|
484 if (value <= MaxGCPauseMillis) { |
|
485 CommandLineError::print(verbose, |
|
486 "GCPauseIntervalMillis (" UINTX_FORMAT ") must be " |
|
487 "greater than MaxGCPauseMillis (" UINTX_FORMAT ")\n", |
|
488 value, MaxGCPauseMillis); |
|
489 return Flag::VIOLATES_CONSTRAINT; |
|
490 } |
|
491 } |
|
492 } |
|
493 #endif |
|
494 return Flag::SUCCESS; |
|
495 } |
|
496 |
|
497 Flag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) { |
|
498 size_t aligned_max = (size_t)align_size_down(max_uintx/2, Metaspace::reserve_alignment_words()); |
|
499 if (value > aligned_max) { |
|
500 CommandLineError::print(verbose, |
|
501 "InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be " |
|
502 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n", |
|
503 value, aligned_max); |
|
504 return Flag::VIOLATES_CONSTRAINT; |
|
505 } |
|
506 return Flag::SUCCESS; |
|
507 } |
|
508 |
|
509 static Flag::Error MaxSizeForHeapAlignment(const char* name, size_t value, bool verbose) { |
|
510 // For G1 GC, we don't know until G1CollectorPolicy is created. |
|
511 size_t heap_alignment; |
|
512 |
|
513 #if INCLUDE_ALL_GCS |
|
514 if (UseG1GC) { |
|
515 heap_alignment = HeapRegionBounds::max_size(); |
|
516 } else |
|
517 #endif |
|
518 { |
|
519 heap_alignment = CollectorPolicy::compute_heap_alignment(); |
|
520 } |
|
521 |
|
522 // Not to overflow 'align_size_up(value, _heap_alignment) used from CollectorPolicy::initialize_flags()'. |
|
523 size_t aligned_max = ((max_uintx - heap_alignment) & ~(heap_alignment-1)); |
|
524 if (value > aligned_max) { |
|
525 CommandLineError::print(verbose, |
|
526 "%s (" SIZE_FORMAT ") must be " |
|
527 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n", |
|
528 name, value, aligned_max); |
|
529 return Flag::VIOLATES_CONSTRAINT; |
|
530 } |
|
531 return Flag::SUCCESS; |
|
532 } |
|
533 |
|
534 Flag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose) { |
|
535 return MaxSizeForHeapAlignment("InitialHeapSize", value, verbose); |
|
536 } |
|
537 |
|
538 Flag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) { |
|
539 Flag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose); |
|
540 |
|
541 if (status == Flag::SUCCESS) { |
|
542 status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose); |
|
543 } |
|
544 return status; |
|
545 } |
|
546 |
|
547 Flag::Error NewSizeConstraintFunc(size_t value, bool verbose) { |
|
548 #ifdef _LP64 |
|
549 #if INCLUDE_ALL_GCS |
|
550 // Overflow would happen for uint type variable of YoungGenSizer::_min_desired_young_length |
|
551 // when the value to be assigned exceeds uint range. |
|
552 // i.e. result of '(uint)(NewSize / region size(1~32MB))' |
|
553 // So maximum of NewSize should be 'max_juint * 1M' |
|
554 if (UseG1GC && (value > (max_juint * 1 * M))) { |
|
555 CommandLineError::print(verbose, |
|
556 "NewSize (" SIZE_FORMAT ") must be less than ergonomic maximum value\n", |
|
557 value); |
|
558 return Flag::VIOLATES_CONSTRAINT; |
|
559 } |
|
560 #endif // INCLUDE_ALL_GCS |
|
561 #endif // _LP64 |
|
562 return Flag::SUCCESS; |
|
563 } |
|
564 |
|
565 Flag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose) { |
|
566 // At least, alignment reserve area is needed. |
|
567 if (value < ThreadLocalAllocBuffer::alignment_reserve_in_bytes()) { |
|
568 CommandLineError::print(verbose, |
|
569 "MinTLABSize (" SIZE_FORMAT ") must be " |
|
570 "greater than or equal to reserved area in TLAB (" SIZE_FORMAT ")\n", |
|
571 value, ThreadLocalAllocBuffer::alignment_reserve_in_bytes()); |
|
572 return Flag::VIOLATES_CONSTRAINT; |
|
573 } else { |
|
574 return Flag::SUCCESS; |
|
575 } |
|
576 } |
|
577 |
|
578 Flag::Error TLABSizeConstraintFunc(size_t value, bool verbose) { |
|
579 // Skip for default value of zero which means set ergonomically. |
|
580 if (FLAG_IS_CMDLINE(TLABSize)) { |
|
581 if (value < MinTLABSize) { |
|
582 CommandLineError::print(verbose, |
|
583 "TLABSize (" SIZE_FORMAT ") must be " |
|
584 "greater than or equal to MinTLABSize (" SIZE_FORMAT ")\n", |
|
585 value, MinTLABSize); |
|
586 return Flag::VIOLATES_CONSTRAINT; |
|
587 } |
|
588 if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) { |
|
589 CommandLineError::print(verbose, |
|
590 "TLABSize (" SIZE_FORMAT ") must be " |
|
591 "less than or equal to ergonomic TLAB maximum size (" SIZE_FORMAT ")\n", |
|
592 value, (ThreadLocalAllocBuffer::max_size() * HeapWordSize)); |
|
593 return Flag::VIOLATES_CONSTRAINT; |
|
594 } |
|
595 } |
|
596 return Flag::SUCCESS; |
|
597 } |
|
598 |
|
599 Flag::Error SurvivorRatioConstraintFunc(uintx value, bool verbose) { |
|
600 if (FLAG_IS_CMDLINE(SurvivorRatio) && |
|
601 (value > (MaxHeapSize / Universe::heap()->collector_policy()->space_alignment()))) { |
|
602 CommandLineError::print(verbose, |
|
603 "SurvivorRatio (" UINTX_FORMAT ") must be " |
|
604 "less than or equal to ergonomic SurvivorRatio maximum (" SIZE_FORMAT ")\n", |
|
605 value, |
|
606 (MaxHeapSize / Universe::heap()->collector_policy()->space_alignment())); |
|
607 return Flag::VIOLATES_CONSTRAINT; |
|
608 } else { |
|
609 return Flag::SUCCESS; |
|
610 } |
|
611 } |
|
612 |
|
613 Flag::Error MetaspaceSizeConstraintFunc(size_t value, bool verbose) { |
|
614 if (value > MaxMetaspaceSize) { |
|
615 CommandLineError::print(verbose, |
|
616 "MetaspaceSize (" SIZE_FORMAT ") must be " |
|
617 "less than or equal to MaxMetaspaceSize (" SIZE_FORMAT ")\n", |
|
618 value, MaxMetaspaceSize); |
|
619 return Flag::VIOLATES_CONSTRAINT; |
|
620 } else { |
|
621 return Flag::SUCCESS; |
|
622 } |
|
623 } |
|
624 |
|
625 Flag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose) { |
|
626 if (value < MetaspaceSize) { |
|
627 CommandLineError::print(verbose, |
|
628 "MaxMetaspaceSize (" SIZE_FORMAT ") must be " |
|
629 "greater than or equal to MetaspaceSize (" SIZE_FORMAT ")\n", |
|
630 value, MaxMetaspaceSize); |
224 return Flag::VIOLATES_CONSTRAINT; |
631 return Flag::VIOLATES_CONSTRAINT; |
225 } else { |
632 } else { |
226 return Flag::SUCCESS; |
633 return Flag::SUCCESS; |
227 } |
634 } |
228 } |
635 } |