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 // 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
113 static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) {
114 #if INCLUDE_ALL_GCS
115 if ((UseConcMarkSweepGC || UseG1GC) && (value < PLAB::min_size())) {
116 CommandLineError::print(verbose,
117 "%s (" SIZE_FORMAT ") must be "
118 "greater than or equal to ergonomic PLAB minimum size (" SIZE_FORMAT ")\n",
119 name, value, PLAB::min_size());
120 return Flag::VIOLATES_CONSTRAINT;
121 }
122 #endif // INCLUDE_ALL_GCS
123 return Flag::SUCCESS;
124 }
125
126 static Flag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
127 #if INCLUDE_ALL_GCS
128 if ((UseConcMarkSweepGC || UseG1GC) && (value > PLAB::max_size())) {
129 CommandLineError::print(verbose,
130 "%s (" SIZE_FORMAT ") must be "
131 "less than or equal to ergonomic PLAB maximum size (" SIZE_FORMAT ")\n",
132 name, value, PLAB::max_size());
133 return Flag::VIOLATES_CONSTRAINT;
134 }
135 #endif // INCLUDE_ALL_GCS
136 return Flag::SUCCESS;
137 }
138
139 static Flag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
140 Flag::Error status = MinPLABSizeBounds(name, value, verbose);
141
142 if (status == Flag::SUCCESS) {
143 return MaxPLABSizeBounds(name, value, verbose);
144 }
145 return status;
146 }
147
148 Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) {
149 return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose);
150 }
151
152 Flag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose) {
153 Flag::Error status = Flag::SUCCESS;
154
155 #if INCLUDE_ALL_GCS
156 if (UseConcMarkSweepGC) {
157 if (value == 0) {
158 CommandLineError::print(verbose,
159 "OldPLABSize (" SIZE_FORMAT ") must be greater than 0",
160 value);
161 return Flag::VIOLATES_CONSTRAINT;
162 }
163 // For CMS, OldPLABSize is the number of free blocks of a given size that are used when
164 // replenishing the local per-worker free list caches.
165 // For more details, please refer to Arguments::set_cms_and_parnew_gc_flags().
166 status = MaxPLABSizeBounds("OldPLABSize", value, verbose);
167 } else {
168 status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
169 }
170 #endif
171 return status;
172 }
173
174 Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
175 if (value > MaxHeapFreeRatio) {
176 CommandLineError::print(verbose,
177 "MinHeapFreeRatio (" UINTX_FORMAT ") must be "
178 "less than or equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
179 value, MaxHeapFreeRatio);
180 return Flag::VIOLATES_CONSTRAINT;
181 } else {
182 return Flag::SUCCESS;
183 }
184 }
185
186 Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
187 if (value < MinHeapFreeRatio) {
188 CommandLineError::print(verbose,
189 "MaxHeapFreeRatio (" UINTX_FORMAT ") must be "
190 "greater than or equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n",
191 value, MinHeapFreeRatio);
192 return Flag::VIOLATES_CONSTRAINT;
193 } else {
194 return Flag::SUCCESS;
195 }
196 }
197
198 static Flag::Error CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(size_t maxHeap, intx softRef, bool verbose) {
199 if ((softRef > 0) && ((maxHeap / M) > (max_uintx / softRef))) {
200 CommandLineError::print(verbose,
201 "Desired lifetime of SoftReferences cannot be expressed correctly. "
202 "MaxHeapSize (" SIZE_FORMAT ") or SoftRefLRUPolicyMSPerMB "
203 "(" INTX_FORMAT ") is too large\n",
204 maxHeap, softRef);
205 return Flag::VIOLATES_CONSTRAINT;
206 } else {
207 return Flag::SUCCESS;
208 }
209 }
210
211 Flag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose) {
212 return CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(MaxHeapSize, value, verbose);
213 }
214
215 Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
216 if (value > MaxMetaspaceFreeRatio) {
217 CommandLineError::print(verbose,
218 "MinMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
219 "less than or equal to MaxMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
220 value, MaxMetaspaceFreeRatio);
221 return Flag::VIOLATES_CONSTRAINT;
222 } else {
223 return Flag::SUCCESS;
224 }
225 }
226
227 Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
228 if (value < MinMetaspaceFreeRatio) {
229 CommandLineError::print(verbose,
230 "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
231 "greater than or equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
232 value, MinMetaspaceFreeRatio);
233 return Flag::VIOLATES_CONSTRAINT;
234 } else {
235 return Flag::SUCCESS;
236 }
237 }
238
239 Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
240 #if INCLUDE_ALL_GCS
241 // InitialTenuringThreshold is only used for ParallelGC.
242 if (UseParallelGC && (value > MaxTenuringThreshold)) {
243 CommandLineError::print(verbose,
244 "InitialTenuringThreshold (" UINTX_FORMAT ") must be "
245 "less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n",
246 value, MaxTenuringThreshold);
247 return Flag::VIOLATES_CONSTRAINT;
248 }
249 #endif
250 return Flag::SUCCESS;
251 }
252
253 Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) {
254 #if INCLUDE_ALL_GCS
255 // As only ParallelGC uses InitialTenuringThreshold,
256 // we don't need to compare InitialTenuringThreshold with MaxTenuringThreshold.
257 if (UseParallelGC && (value < InitialTenuringThreshold)) {
258 CommandLineError::print(verbose,
259 "MaxTenuringThreshold (" UINTX_FORMAT ") must be "
260 "greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n",
261 value, InitialTenuringThreshold);
262 return Flag::VIOLATES_CONSTRAINT;
263 }
264 #endif
265
266 // MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
267 if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
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
341 Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) {
342 if (!UseG1GC) return Flag::SUCCESS;
343
344 if (value > G1MaxNewSizePercent) {
345 CommandLineError::print(verbose,
346 "G1NewSizePercent (" UINTX_FORMAT ") must be "
347 "less than or equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n",
348 value, G1MaxNewSizePercent);
349 return Flag::VIOLATES_CONSTRAINT;
350 } else {
351 return Flag::SUCCESS;
352 }
353 }
354
355 Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) {
356 if (!UseG1GC) return Flag::SUCCESS;
357
358 if (value < G1NewSizePercent) {
359 CommandLineError::print(verbose,
360 "G1MaxNewSizePercent (" UINTX_FORMAT ") must be "
361 "greater than or equal to G1NewSizePercent (" UINTX_FORMAT ")\n",
362 value, G1NewSizePercent);
363 return Flag::VIOLATES_CONSTRAINT;
364 } else {
365 return Flag::SUCCESS;
366 }
367 }
368 #endif // INCLUDE_ALL_GCS
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
383 Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
384 Flag::Error status = Flag::SUCCESS;
385
386 #if INCLUDE_ALL_GCS
387 if (UseConcMarkSweepGC) {
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);
418 return Flag::VIOLATES_CONSTRAINT;
419 } else {
420 return Flag::SUCCESS;
421 }
422 }
423
424 Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
425 #if INCLUDE_ALL_GCS
426 if (UseConcMarkSweepGC && (value <= CMSPrecleanNumerator)) {
427 CommandLineError::print(verbose,
428 "CMSPrecleanDenominator (" UINTX_FORMAT ") must be "
429 "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n",
430 value, CMSPrecleanNumerator);
431 return Flag::VIOLATES_CONSTRAINT;
432 }
433 #endif
434 return Flag::SUCCESS;
435 }
436
437 Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) {
438 #if INCLUDE_ALL_GCS
439 if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) {
440 CommandLineError::print(verbose,
441 "CMSPrecleanNumerator (" UINTX_FORMAT ") must be "
442 "less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n",
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);
631 return Flag::VIOLATES_CONSTRAINT;
632 } else {
633 return Flag::SUCCESS;
634 }
635 }
636
637 Flag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose) {
638 if (value != 0) {
639 if (!is_power_of_2(value)) {
640 CommandLineError::print(verbose,
641 "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
642 "power of 2\n",
643 value);
644 return Flag::VIOLATES_CONSTRAINT;
645 }
646 if (value < ObjectAlignmentInBytes) {
647 CommandLineError::print(verbose,
648 "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
649 "greater than or equal to ObjectAlignmentInBytes (" INTX_FORMAT ")\n",
650 value, ObjectAlignmentInBytes);
651 return Flag::VIOLATES_CONSTRAINT;
652 }
653 }
654 return Flag::SUCCESS;
655 }