1 /*
2 * Copyright (c) 2015, 2018, 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/genCollectedHeap.hpp"
29 #include "gc/shared/threadLocalAllocBuffer.hpp"
30 #include "runtime/arguments.hpp"
31 #include "runtime/commandLineFlagConstraintsGC.hpp"
32 #include "runtime/commandLineFlagRangeList.hpp"
33 #include "runtime/globals.hpp"
34 #include "runtime/globals_extension.hpp"
35 #include "runtime/thread.inline.hpp"
36 #include "utilities/align.hpp"
37 #include "utilities/defaultStream.hpp"
38
39 #if INCLUDE_ALL_GCS
40 #include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
41 #include "gc/g1/g1_globals.hpp"
42 #include "gc/g1/heapRegionBounds.inline.hpp"
43 #include "gc/shared/plab.hpp"
44 #endif // INCLUDE_ALL_GCS
45 #ifdef COMPILER1
46 #include "c1/c1_globals.hpp"
47 #endif // COMPILER1
48 #ifdef COMPILER2
49 #include "opto/c2_globals.hpp"
50 #endif // COMPILER2
51
52 // Some flags that have default values that indicate that the
53 // JVM should automatically determine an appropriate value
54 // for that flag. In those cases it is only appropriate for the
55 // constraint checking to be done if the user has specified the
56 // value(s) of the flag(s) on the command line. In the constraint
57 // checking functions, FLAG_IS_CMDLINE() is used to check if
58 // the flag has been set by the user and so should be checked.
59
60 #if INCLUDE_ALL_GCS
61 static Flag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(uint threads, uintx threshold, bool verbose) {
62 // CMSWorkQueueDrainThreshold is verified to be less than max_juint
63 if (UseConcMarkSweepGC && (threads > (uint)(max_jint / (uint)threshold))) {
64 CommandLineError::print(verbose,
65 "ParallelGCThreads (" UINT32_FORMAT ") or CMSWorkQueueDrainThreshold ("
66 UINTX_FORMAT ") is too large\n",
67 threads, threshold);
68 return Flag::VIOLATES_CONSTRAINT;
69 }
70 return Flag::SUCCESS;
71 }
72 #endif
73
74 // As ParallelGCThreads differs among GC modes, we need constraint function.
75 Flag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose) {
76 Flag::Error status = Flag::SUCCESS;
77
78 #if INCLUDE_ALL_GCS
79 // Parallel GC passes ParallelGCThreads when creating GrowableArray as 'int' type parameter.
80 // So can't exceed with "max_jint"
81 if (UseParallelGC && (value > (uint)max_jint)) {
82 CommandLineError::print(verbose,
83 "ParallelGCThreads (" UINT32_FORMAT ") must be "
84 "less than or equal to " UINT32_FORMAT " for Parallel GC\n",
85 value, max_jint);
86 return Flag::VIOLATES_CONSTRAINT;
87 }
88 // To avoid overflow at ParScanClosure::do_oop_work.
89 if (UseConcMarkSweepGC && (value > (max_jint / 10))) {
90 CommandLineError::print(verbose,
91 "ParallelGCThreads (" UINT32_FORMAT ") must be "
92 "less than or equal to " UINT32_FORMAT " for CMS GC\n",
93 value, (max_jint / 10));
94 return Flag::VIOLATES_CONSTRAINT;
95 }
96 status = ParallelGCThreadsAndCMSWorkQueueDrainThreshold(value, CMSWorkQueueDrainThreshold, verbose);
97 #endif
98 return status;
99 }
100
101 // As ConcGCThreads should be smaller than ParallelGCThreads,
102 // we need constraint function.
103 Flag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose) {
104 #if INCLUDE_ALL_GCS
105 // CMS and G1 GCs use ConcGCThreads.
106 if ((UseConcMarkSweepGC || UseG1GC) && (value > ParallelGCThreads)) {
107 CommandLineError::print(verbose,
108 "ConcGCThreads (" UINT32_FORMAT ") must be "
109 "less than or equal to ParallelGCThreads (" UINT32_FORMAT ")\n",
110 value, ParallelGCThreads);
111 return Flag::VIOLATES_CONSTRAINT;
112 }
113 #endif
114 return Flag::SUCCESS;
115 }
116
117 static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) {
118 #if INCLUDE_ALL_GCS
119 if ((UseConcMarkSweepGC || UseG1GC || UseParallelGC) && (value < PLAB::min_size())) {
120 CommandLineError::print(verbose,
121 "%s (" SIZE_FORMAT ") must be "
122 "greater than or equal to ergonomic PLAB minimum size (" SIZE_FORMAT ")\n",
123 name, value, PLAB::min_size());
124 return Flag::VIOLATES_CONSTRAINT;
125 }
126 #endif // INCLUDE_ALL_GCS
127 return Flag::SUCCESS;
128 }
129
130 static Flag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
131 #if INCLUDE_ALL_GCS
132 if ((UseConcMarkSweepGC || UseG1GC || UseParallelGC) && (value > PLAB::max_size())) {
133 CommandLineError::print(verbose,
134 "%s (" SIZE_FORMAT ") must be "
135 "less than or equal to ergonomic PLAB maximum size (" SIZE_FORMAT ")\n",
136 name, value, PLAB::max_size());
137 return Flag::VIOLATES_CONSTRAINT;
138 }
139 #endif // INCLUDE_ALL_GCS
140 return Flag::SUCCESS;
141 }
142
143 static Flag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
144 Flag::Error status = MinPLABSizeBounds(name, value, verbose);
145
146 if (status == Flag::SUCCESS) {
147 return MaxPLABSizeBounds(name, value, verbose);
148 }
149 return status;
150 }
151
152 Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) {
153 return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose);
154 }
155
156 Flag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose) {
157 Flag::Error status = Flag::SUCCESS;
158
159 #if INCLUDE_ALL_GCS
160 if (UseConcMarkSweepGC) {
161 if (value == 0) {
162 CommandLineError::print(verbose,
163 "OldPLABSize (" SIZE_FORMAT ") must be greater than 0",
164 value);
165 return Flag::VIOLATES_CONSTRAINT;
166 }
167 // For CMS, OldPLABSize is the number of free blocks of a given size that are used when
168 // replenishing the local per-worker free list caches.
169 // For more details, please refer to Arguments::set_cms_and_parnew_gc_flags().
170 status = MaxPLABSizeBounds("OldPLABSize", value, verbose);
171 } else {
172 status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
173 }
174 #endif
175 return status;
176 }
177
178 Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
179 if (value > MaxHeapFreeRatio) {
180 CommandLineError::print(verbose,
181 "MinHeapFreeRatio (" UINTX_FORMAT ") must be "
182 "less than or equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
183 value, MaxHeapFreeRatio);
184 return Flag::VIOLATES_CONSTRAINT;
185 } else {
186 return Flag::SUCCESS;
187 }
188 }
189
190 Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
191 if (value < MinHeapFreeRatio) {
192 CommandLineError::print(verbose,
193 "MaxHeapFreeRatio (" UINTX_FORMAT ") must be "
194 "greater than or equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n",
195 value, MinHeapFreeRatio);
196 return Flag::VIOLATES_CONSTRAINT;
197 } else {
198 return Flag::SUCCESS;
199 }
200 }
201
202 static Flag::Error CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(size_t maxHeap, intx softRef, bool verbose) {
203 if ((softRef > 0) && ((maxHeap / M) > (max_uintx / softRef))) {
204 CommandLineError::print(verbose,
205 "Desired lifetime of SoftReferences cannot be expressed correctly. "
206 "MaxHeapSize (" SIZE_FORMAT ") or SoftRefLRUPolicyMSPerMB "
207 "(" INTX_FORMAT ") is too large\n",
208 maxHeap, softRef);
209 return Flag::VIOLATES_CONSTRAINT;
210 } else {
211 return Flag::SUCCESS;
212 }
213 }
214
215 Flag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose) {
216 return CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(MaxHeapSize, value, verbose);
217 }
218
219 Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
220 if (value > MaxMetaspaceFreeRatio) {
221 CommandLineError::print(verbose,
222 "MinMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
223 "less than or equal to MaxMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
224 value, MaxMetaspaceFreeRatio);
225 return Flag::VIOLATES_CONSTRAINT;
226 } else {
227 return Flag::SUCCESS;
228 }
229 }
230
231 Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
232 if (value < MinMetaspaceFreeRatio) {
233 CommandLineError::print(verbose,
234 "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
235 "greater than or equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
236 value, MinMetaspaceFreeRatio);
237 return Flag::VIOLATES_CONSTRAINT;
238 } else {
239 return Flag::SUCCESS;
240 }
241 }
242
243 Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
244 #if INCLUDE_ALL_GCS
245 // InitialTenuringThreshold is only used for ParallelGC.
246 if (UseParallelGC && (value > MaxTenuringThreshold)) {
247 CommandLineError::print(verbose,
248 "InitialTenuringThreshold (" UINTX_FORMAT ") must be "
249 "less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n",
250 value, MaxTenuringThreshold);
251 return Flag::VIOLATES_CONSTRAINT;
252 }
253 #endif
254 return Flag::SUCCESS;
255 }
256
257 Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) {
258 #if INCLUDE_ALL_GCS
259 // As only ParallelGC uses InitialTenuringThreshold,
260 // we don't need to compare InitialTenuringThreshold with MaxTenuringThreshold.
261 if (UseParallelGC && (value < InitialTenuringThreshold)) {
262 CommandLineError::print(verbose,
263 "MaxTenuringThreshold (" UINTX_FORMAT ") must be "
264 "greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n",
265 value, InitialTenuringThreshold);
266 return Flag::VIOLATES_CONSTRAINT;
267 }
268 #endif
269
270 // MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
271 if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
272 CommandLineError::print(verbose,
273 "MaxTenuringThreshold (0) should match to NeverTenure=false "
274 "&& AlwaysTenure=true. But we have NeverTenure=%s "
275 "AlwaysTenure=%s\n",
276 NeverTenure ? "true" : "false",
277 AlwaysTenure ? "true" : "false");
278 return Flag::VIOLATES_CONSTRAINT;
279 }
280 return Flag::SUCCESS;
281 }
282
283 #if INCLUDE_ALL_GCS
284 Flag::Error G1RSetRegionEntriesConstraintFunc(intx value, bool verbose) {
285 if (!UseG1GC) return Flag::SUCCESS;
286
287 // Default value of G1RSetRegionEntries=0 means will be set ergonomically.
288 // Minimum value is 1.
289 if (FLAG_IS_CMDLINE(G1RSetRegionEntries) && (value < 1)) {
290 CommandLineError::print(verbose,
291 "G1RSetRegionEntries (" INTX_FORMAT ") must be "
292 "greater than or equal to 1\n",
293 value);
294 return Flag::VIOLATES_CONSTRAINT;
295 } else {
296 return Flag::SUCCESS;
297 }
298 }
299
300 Flag::Error G1RSetSparseRegionEntriesConstraintFunc(intx value, bool verbose) {
301 if (!UseG1GC) return Flag::SUCCESS;
302
303 // Default value of G1RSetSparseRegionEntries=0 means will be set ergonomically.
304 // Minimum value is 1.
305 if (FLAG_IS_CMDLINE(G1RSetSparseRegionEntries) && (value < 1)) {
306 CommandLineError::print(verbose,
307 "G1RSetSparseRegionEntries (" INTX_FORMAT ") must be "
308 "greater than or equal to 1\n",
309 value);
310 return Flag::VIOLATES_CONSTRAINT;
311 } else {
312 return Flag::SUCCESS;
313 }
314 }
315
316 Flag::Error G1HeapRegionSizeConstraintFunc(size_t value, bool verbose) {
317 if (!UseG1GC) return Flag::SUCCESS;
318
319 // Default value of G1HeapRegionSize=0 means will be set ergonomically.
320 if (FLAG_IS_CMDLINE(G1HeapRegionSize) && (value < HeapRegionBounds::min_size())) {
321 CommandLineError::print(verbose,
322 "G1HeapRegionSize (" SIZE_FORMAT ") must be "
323 "greater than or equal to ergonomic heap region minimum size\n",
324 value);
325 return Flag::VIOLATES_CONSTRAINT;
326 } else {
327 return Flag::SUCCESS;
328 }
329 }
330
331 Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) {
332 if (!UseG1GC) return Flag::SUCCESS;
333
334 if (value > G1MaxNewSizePercent) {
335 CommandLineError::print(verbose,
336 "G1NewSizePercent (" UINTX_FORMAT ") must be "
337 "less than or equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n",
338 value, G1MaxNewSizePercent);
339 return Flag::VIOLATES_CONSTRAINT;
340 } else {
341 return Flag::SUCCESS;
342 }
343 }
344
345 Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) {
346 if (!UseG1GC) return Flag::SUCCESS;
347
348 if (value < G1NewSizePercent) {
349 CommandLineError::print(verbose,
350 "G1MaxNewSizePercent (" UINTX_FORMAT ") must be "
351 "greater than or equal to G1NewSizePercent (" UINTX_FORMAT ")\n",
352 value, G1NewSizePercent);
353 return Flag::VIOLATES_CONSTRAINT;
354 } else {
355 return Flag::SUCCESS;
356 }
357 }
358 #endif // INCLUDE_ALL_GCS
359
360 Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) {
361 #if INCLUDE_ALL_GCS
362 if (UseConcMarkSweepGC && (value > ((uintx)max_jint / (uintx)ParallelGCThreads))) {
363 CommandLineError::print(verbose,
364 "ParGCStridesPerThread (" UINTX_FORMAT ") must be "
365 "less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n",
366 value, ((uintx)max_jint / (uintx)ParallelGCThreads));
367 return Flag::VIOLATES_CONSTRAINT;
368 }
369 #endif
370 return Flag::SUCCESS;
371 }
372
373 Flag::Error ParGCCardsPerStrideChunkConstraintFunc(intx value, bool verbose) {
374 #if INCLUDE_ALL_GCS
375 if (UseConcMarkSweepGC) {
376 // ParGCCardsPerStrideChunk should be compared with card table size.
377 size_t heap_size = Universe::heap()->reserved_region().word_size();
378 CardTableRS* ct = GenCollectedHeap::heap()->rem_set();
379 size_t card_table_size = ct->cards_required(heap_size) - 1; // Valid card table size
380
381 if ((size_t)value > card_table_size) {
382 CommandLineError::print(verbose,
383 "ParGCCardsPerStrideChunk (" INTX_FORMAT ") is too large for the heap size and "
384 "must be less than or equal to card table size (" SIZE_FORMAT ")\n",
385 value, card_table_size);
386 return Flag::VIOLATES_CONSTRAINT;
387 }
388
389 // ParGCCardsPerStrideChunk is used with n_strides(ParallelGCThreads*ParGCStridesPerThread)
390 // from CardTableRS::process_stride(). Note that ParGCStridesPerThread is already checked
391 // not to make an overflow with ParallelGCThreads from its constraint function.
392 uintx n_strides = ParallelGCThreads * ParGCStridesPerThread;
393 uintx ergo_max = max_uintx / n_strides;
394 if ((uintx)value > ergo_max) {
395 CommandLineError::print(verbose,
396 "ParGCCardsPerStrideChunk (" INTX_FORMAT ") must be "
397 "less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n",
398 value, ergo_max);
399 return Flag::VIOLATES_CONSTRAINT;
400 }
401 }
402 #endif
403 return Flag::SUCCESS;
404 }
405
406 Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
407 Flag::Error status = Flag::SUCCESS;
408
409 #if INCLUDE_ALL_GCS
410 if (UseConcMarkSweepGC) {
411 if (value > CMSOldPLABMax) {
412 CommandLineError::print(verbose,
413 "CMSOldPLABMin (" SIZE_FORMAT ") must be "
414 "less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
415 value, CMSOldPLABMax);
416 return Flag::VIOLATES_CONSTRAINT;
417 }
418 status = MaxPLABSizeBounds("CMSOldPLABMin", value, verbose);
419 }
420 #endif
421 return status;
422 }
423
424 Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) {
425 Flag::Error status = Flag::SUCCESS;
426
427 #if INCLUDE_ALL_GCS
428 if (UseConcMarkSweepGC) {
429 status = MaxPLABSizeBounds("CMSOldPLABMax", value, verbose);
430 }
431 #endif
432 return status;
433 }
434
435 Flag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose) {
436 if (value > MarkStackSizeMax) {
437 CommandLineError::print(verbose,
438 "MarkStackSize (" SIZE_FORMAT ") must be "
439 "less than or equal to MarkStackSizeMax (" SIZE_FORMAT ")\n",
440 value, MarkStackSizeMax);
441 return Flag::VIOLATES_CONSTRAINT;
442 } else {
443 return Flag::SUCCESS;
444 }
445 }
446
447 static Flag::Error CMSReservedAreaConstraintFunc(const char* name, size_t value, bool verbose) {
448 #if INCLUDE_ALL_GCS
449 if (UseConcMarkSweepGC) {
450 ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*)GenCollectedHeap::heap()->old_gen();
451 const size_t ergo_max = cms->cmsSpace()->max_flag_size_for_task_size();
452 if (value > ergo_max) {
453 CommandLineError::print(verbose,
454 "%s (" SIZE_FORMAT ") must be "
455 "less than or equal to ergonomic maximum (" SIZE_FORMAT ") "
456 "which is based on the maximum size of the old generation of the Java heap\n",
457 name, value, ergo_max);
458 return Flag::VIOLATES_CONSTRAINT;
459 }
460 }
461 #endif
462
463 return Flag::SUCCESS;
464 }
465
466 Flag::Error CMSRescanMultipleConstraintFunc(size_t value, bool verbose) {
467 Flag::Error status = CMSReservedAreaConstraintFunc("CMSRescanMultiple", value, verbose);
468
469 #if INCLUDE_ALL_GCS
470 if (status == Flag::SUCCESS && UseConcMarkSweepGC) {
471 // CMSParRemarkTask::do_dirty_card_rescan_tasks requires CompactibleFreeListSpace::rescan_task_size()
472 // to be aligned to CardTable::card_size * BitsPerWord.
473 // Note that rescan_task_size() will be aligned if CMSRescanMultiple is a multiple of 'HeapWordSize'
474 // because rescan_task_size() is CardTable::card_size / HeapWordSize * BitsPerWord.
475 if (value % HeapWordSize != 0) {
476 CommandLineError::print(verbose,
477 "CMSRescanMultiple (" SIZE_FORMAT ") must be "
478 "a multiple of " SIZE_FORMAT "\n",
479 value, HeapWordSize);
480 status = Flag::VIOLATES_CONSTRAINT;
481 }
482 }
483 #endif
484
485 return status;
486 }
487
488 Flag::Error CMSConcMarkMultipleConstraintFunc(size_t value, bool verbose) {
489 return CMSReservedAreaConstraintFunc("CMSConcMarkMultiple", value, verbose);
490 }
491
492 Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
493 #if INCLUDE_ALL_GCS
494 if (UseConcMarkSweepGC && (value <= CMSPrecleanNumerator)) {
495 CommandLineError::print(verbose,
496 "CMSPrecleanDenominator (" UINTX_FORMAT ") must be "
497 "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n",
498 value, CMSPrecleanNumerator);
499 return Flag::VIOLATES_CONSTRAINT;
500 }
501 #endif
502 return Flag::SUCCESS;
503 }
504
505 Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) {
506 #if INCLUDE_ALL_GCS
507 if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) {
508 CommandLineError::print(verbose,
509 "CMSPrecleanNumerator (" UINTX_FORMAT ") must be "
510 "less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n",
511 value, CMSPrecleanDenominator);
512 return Flag::VIOLATES_CONSTRAINT;
513 }
514 #endif
515 return Flag::SUCCESS;
516 }
517
518 Flag::Error CMSSamplingGrainConstraintFunc(uintx value, bool verbose) {
519 #if INCLUDE_ALL_GCS
520 if (UseConcMarkSweepGC) {
521 size_t max_capacity = GenCollectedHeap::heap()->young_gen()->max_capacity();
522 if (value > max_uintx - max_capacity) {
523 CommandLineError::print(verbose,
524 "CMSSamplingGrain (" UINTX_FORMAT ") must be "
525 "less than or equal to ergonomic maximum (" SIZE_FORMAT ")\n",
526 value, max_uintx - max_capacity);
527 return Flag::VIOLATES_CONSTRAINT;
528 }
529 }
530 #endif
531 return Flag::SUCCESS;
532 }
533
534 Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) {
535 #if INCLUDE_ALL_GCS
536 if (UseConcMarkSweepGC) {
537 return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(ParallelGCThreads, value, verbose);
538 }
539 #endif
540 return Flag::SUCCESS;
541 }
542
543 Flag::Error CMSBitMapYieldQuantumConstraintFunc(size_t value, bool verbose) {
544 #if INCLUDE_ALL_GCS
545 // Skip for current default value.
546 if (UseConcMarkSweepGC && FLAG_IS_CMDLINE(CMSBitMapYieldQuantum)) {
547 // CMSBitMapYieldQuantum should be compared with mark bitmap size.
548 ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*)GenCollectedHeap::heap()->old_gen();
549 size_t bitmap_size = cms->collector()->markBitMap()->sizeInWords();
550
551 if (value > bitmap_size) {
552 CommandLineError::print(verbose,
553 "CMSBitMapYieldQuantum (" SIZE_FORMAT ") must "
554 "be less than or equal to bitmap size (" SIZE_FORMAT ") "
555 "whose size corresponds to the size of old generation of the Java heap\n",
556 value, bitmap_size);
557 return Flag::VIOLATES_CONSTRAINT;
558 }
559 }
560 #endif
561 return Flag::SUCCESS;
562 }
563
564 Flag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) {
565 #if INCLUDE_ALL_GCS
566 if (UseG1GC && FLAG_IS_CMDLINE(MaxGCPauseMillis) && (value >= GCPauseIntervalMillis)) {
567 CommandLineError::print(verbose,
568 "MaxGCPauseMillis (" UINTX_FORMAT ") must be "
569 "less than GCPauseIntervalMillis (" UINTX_FORMAT ")\n",
570 value, GCPauseIntervalMillis);
571 return Flag::VIOLATES_CONSTRAINT;
572 }
573 #endif
574
575 return Flag::SUCCESS;
576 }
577
578 Flag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
579 #if INCLUDE_ALL_GCS
580 if (UseG1GC) {
581 if (FLAG_IS_CMDLINE(GCPauseIntervalMillis)) {
582 if (value < 1) {
583 CommandLineError::print(verbose,
584 "GCPauseIntervalMillis (" UINTX_FORMAT ") must be "
585 "greater than or equal to 1\n",
586 value);
587 return Flag::VIOLATES_CONSTRAINT;
588 }
589
590 if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
591 CommandLineError::print(verbose,
592 "GCPauseIntervalMillis cannot be set "
593 "without setting MaxGCPauseMillis\n");
594 return Flag::VIOLATES_CONSTRAINT;
595 }
596
597 if (value <= MaxGCPauseMillis) {
598 CommandLineError::print(verbose,
599 "GCPauseIntervalMillis (" UINTX_FORMAT ") must be "
600 "greater than MaxGCPauseMillis (" UINTX_FORMAT ")\n",
601 value, MaxGCPauseMillis);
602 return Flag::VIOLATES_CONSTRAINT;
603 }
604 }
605 }
606 #endif
607 return Flag::SUCCESS;
608 }
609
610 Flag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
611 size_t aligned_max = align_down(max_uintx/2, Metaspace::reserve_alignment_words());
612 if (value > aligned_max) {
613 CommandLineError::print(verbose,
614 "InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be "
615 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
616 value, aligned_max);
617 return Flag::VIOLATES_CONSTRAINT;
618 }
619 return Flag::SUCCESS;
620 }
621
622 // To avoid an overflow by 'align_up(value, alignment)'.
623 static Flag::Error MaxSizeForAlignment(const char* name, size_t value, size_t alignment, bool verbose) {
624 size_t aligned_max = ((max_uintx - alignment) & ~(alignment-1));
625 if (value > aligned_max) {
626 CommandLineError::print(verbose,
627 "%s (" SIZE_FORMAT ") must be "
628 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
629 name, value, aligned_max);
630 return Flag::VIOLATES_CONSTRAINT;
631 }
632 return Flag::SUCCESS;
633 }
634
635 static Flag::Error MaxSizeForHeapAlignment(const char* name, size_t value, bool verbose) {
636 // For G1 GC, we don't know until G1CollectorPolicy is created.
637 size_t heap_alignment;
638
639 #if INCLUDE_ALL_GCS
640 if (UseG1GC) {
641 heap_alignment = HeapRegionBounds::max_size();
642 } else
643 #endif
644 {
645 heap_alignment = CollectorPolicy::compute_heap_alignment();
646 }
647
648 return MaxSizeForAlignment(name, value, heap_alignment, verbose);
649 }
650
651 Flag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose) {
652 return MaxSizeForHeapAlignment("InitialHeapSize", value, verbose);
653 }
654
655 Flag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) {
656 Flag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose);
657
658 if (status == Flag::SUCCESS) {
659 status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose);
660 }
661 return status;
662 }
663
664 Flag::Error HeapBaseMinAddressConstraintFunc(size_t value, bool verbose) {
665 // If an overflow happened in Arguments::set_heap_size(), MaxHeapSize will have too large a value.
666 // Check for this by ensuring that MaxHeapSize plus the requested min base address still fit within max_uintx.
667 if (UseCompressedOops && FLAG_IS_ERGO(MaxHeapSize) && (value > (max_uintx - MaxHeapSize))) {
668 CommandLineError::print(verbose,
669 "HeapBaseMinAddress (" SIZE_FORMAT ") or MaxHeapSize (" SIZE_FORMAT ") is too large. "
670 "Sum of them must be less than or equal to maximum of size_t (" SIZE_FORMAT ")\n",
671 value, MaxHeapSize, max_uintx);
672 return Flag::VIOLATES_CONSTRAINT;
673 }
674
675 return MaxSizeForHeapAlignment("HeapBaseMinAddress", value, verbose);
676 }
677
678 Flag::Error NewSizeConstraintFunc(size_t value, bool verbose) {
679 #ifdef _LP64
680 #if INCLUDE_ALL_GCS
681 // Overflow would happen for uint type variable of YoungGenSizer::_min_desired_young_length
682 // when the value to be assigned exceeds uint range.
683 // i.e. result of '(uint)(NewSize / region size(1~32MB))'
684 // So maximum of NewSize should be 'max_juint * 1M'
685 if (UseG1GC && (value > (max_juint * 1 * M))) {
686 CommandLineError::print(verbose,
687 "NewSize (" SIZE_FORMAT ") must be less than ergonomic maximum value\n",
688 value);
689 return Flag::VIOLATES_CONSTRAINT;
690 }
691 #endif // INCLUDE_ALL_GCS
692 #endif // _LP64
693 return Flag::SUCCESS;
694 }
695
696 Flag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose) {
697 // At least, alignment reserve area is needed.
698 if (value < ThreadLocalAllocBuffer::alignment_reserve_in_bytes()) {
699 CommandLineError::print(verbose,
700 "MinTLABSize (" SIZE_FORMAT ") must be "
701 "greater than or equal to reserved area in TLAB (" SIZE_FORMAT ")\n",
702 value, ThreadLocalAllocBuffer::alignment_reserve_in_bytes());
703 return Flag::VIOLATES_CONSTRAINT;
704 }
705 if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) {
706 CommandLineError::print(verbose,
707 "MinTLABSize (" SIZE_FORMAT ") must be "
708 "less than or equal to ergonomic TLAB maximum (" SIZE_FORMAT ")\n",
709 value, ThreadLocalAllocBuffer::max_size() * HeapWordSize);
710 return Flag::VIOLATES_CONSTRAINT;
711 }
712 return Flag::SUCCESS;
713 }
714
715 Flag::Error TLABSizeConstraintFunc(size_t value, bool verbose) {
716 // Skip for default value of zero which means set ergonomically.
717 if (FLAG_IS_CMDLINE(TLABSize)) {
718 if (value < MinTLABSize) {
719 CommandLineError::print(verbose,
720 "TLABSize (" SIZE_FORMAT ") must be "
721 "greater than or equal to MinTLABSize (" SIZE_FORMAT ")\n",
722 value, MinTLABSize);
723 return Flag::VIOLATES_CONSTRAINT;
724 }
725 if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) {
726 CommandLineError::print(verbose,
727 "TLABSize (" SIZE_FORMAT ") must be "
728 "less than or equal to ergonomic TLAB maximum size (" SIZE_FORMAT ")\n",
729 value, (ThreadLocalAllocBuffer::max_size() * HeapWordSize));
730 return Flag::VIOLATES_CONSTRAINT;
731 }
732 }
733 return Flag::SUCCESS;
734 }
735
736 // We will protect overflow from ThreadLocalAllocBuffer::record_slow_allocation(),
737 // so AfterMemoryInit type is enough to check.
738 Flag::Error TLABWasteIncrementConstraintFunc(uintx value, bool verbose) {
739 if (UseTLAB) {
740 size_t refill_waste_limit = Thread::current()->tlab().refill_waste_limit();
741
742 // Compare with 'max_uintx' as ThreadLocalAllocBuffer::_refill_waste_limit is 'size_t'.
743 if (refill_waste_limit > (max_uintx - value)) {
744 CommandLineError::print(verbose,
745 "TLABWasteIncrement (" UINTX_FORMAT ") must be "
746 "less than or equal to ergonomic TLAB waste increment maximum size(" SIZE_FORMAT ")\n",
747 value, (max_uintx - refill_waste_limit));
748 return Flag::VIOLATES_CONSTRAINT;
749 }
750 }
751 return Flag::SUCCESS;
752 }
753
754 Flag::Error SurvivorRatioConstraintFunc(uintx value, bool verbose) {
755 if (FLAG_IS_CMDLINE(SurvivorRatio) &&
756 (value > (MaxHeapSize / Universe::heap()->collector_policy()->space_alignment()))) {
757 CommandLineError::print(verbose,
758 "SurvivorRatio (" UINTX_FORMAT ") must be "
759 "less than or equal to ergonomic SurvivorRatio maximum (" SIZE_FORMAT ")\n",
760 value,
761 (MaxHeapSize / Universe::heap()->collector_policy()->space_alignment()));
762 return Flag::VIOLATES_CONSTRAINT;
763 } else {
764 return Flag::SUCCESS;
765 }
766 }
767
768 Flag::Error MetaspaceSizeConstraintFunc(size_t value, bool verbose) {
769 if (value > MaxMetaspaceSize) {
770 CommandLineError::print(verbose,
771 "MetaspaceSize (" SIZE_FORMAT ") must be "
772 "less than or equal to MaxMetaspaceSize (" SIZE_FORMAT ")\n",
773 value, MaxMetaspaceSize);
774 return Flag::VIOLATES_CONSTRAINT;
775 } else {
776 return Flag::SUCCESS;
777 }
778 }
779
780 Flag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
781 if (value < MetaspaceSize) {
782 CommandLineError::print(verbose,
783 "MaxMetaspaceSize (" SIZE_FORMAT ") must be "
784 "greater than or equal to MetaspaceSize (" SIZE_FORMAT ")\n",
785 value, MaxMetaspaceSize);
786 return Flag::VIOLATES_CONSTRAINT;
787 } else {
788 return Flag::SUCCESS;
789 }
790 }
791
792 Flag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose) {
793 if (value != 0) {
794 if (!is_power_of_2(value)) {
795 CommandLineError::print(verbose,
796 "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
797 "power of 2\n",
798 value);
799 return Flag::VIOLATES_CONSTRAINT;
800 }
801 if (value < ObjectAlignmentInBytes) {
802 CommandLineError::print(verbose,
803 "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be "
804 "greater than or equal to ObjectAlignmentInBytes (" INTX_FORMAT ")\n",
805 value, ObjectAlignmentInBytes);
806 return Flag::VIOLATES_CONSTRAINT;
807 }
808 }
809 return Flag::SUCCESS;
810 }