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