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/jvmFlagConstraintsGC.hpp"
29 #include "gc/shared/plab.hpp"
30 #include "gc/shared/threadLocalAllocBuffer.hpp"
31 #include "runtime/arguments.hpp"
32 #include "runtime/flags/jvmFlagRangeList.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 #include "utilities/macros.hpp"
39 #if INCLUDE_ALL_GCS
40 #include "gc/cms/jvmFlagConstraintsCMS.hpp"
41 #include "gc/g1/jvmFlagConstraintsG1.hpp"
42 #include "gc/parallel/jvmFlagConstraintsParallel.hpp"
43 #endif
44 #ifdef COMPILER1
45 #include "c1/c1_globals.hpp"
46 #endif // COMPILER1
47 #ifdef COMPILER2
48 #include "opto/c2_globals.hpp"
49 #endif // COMPILER2
50
51 // Some flags that have default values that indicate that the
52 // JVM should automatically determine an appropriate value
53 // for that flag. In those cases it is only appropriate for the
54 // constraint checking to be done if the user has specified the
55 // value(s) of the flag(s) on the command line. In the constraint
56 // checking functions, FLAG_IS_CMDLINE() is used to check if
57 // the flag has been set by the user and so should be checked.
58
59 // As ParallelGCThreads differs among GC modes, we need constraint function.
60 JVMFlag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose) {
61 JVMFlag::Error status = JVMFlag::SUCCESS;
62
63 #if INCLUDE_ALL_GCS
64 status = ParallelGCThreadsConstraintFuncParallel(value, verbose);
65 if (status != JVMFlag::SUCCESS) {
66 return status;
67 }
68
69 status = ParallelGCThreadsConstraintFuncCMS(value, verbose);
70 if (status != JVMFlag::SUCCESS) {
71 return status;
72 }
73 #endif
74
75 return status;
76 }
77
78 // As ConcGCThreads should be smaller than ParallelGCThreads,
79 // we need constraint function.
80 JVMFlag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose) {
81 #if INCLUDE_ALL_GCS
82 // CMS and G1 GCs use ConcGCThreads.
83 if ((UseConcMarkSweepGC || UseG1GC) && (value > ParallelGCThreads)) {
84 CommandLineError::print(verbose,
85 "ConcGCThreads (" UINT32_FORMAT ") must be "
86 "less than or equal to ParallelGCThreads (" UINT32_FORMAT ")\n",
87 value, ParallelGCThreads);
88 return JVMFlag::VIOLATES_CONSTRAINT;
89 }
90 #endif
91 return JVMFlag::SUCCESS;
92 }
93
94 static JVMFlag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) {
95 #if INCLUDE_ALL_GCS
96 if ((UseConcMarkSweepGC || UseG1GC || UseParallelGC) && (value < PLAB::min_size())) {
97 CommandLineError::print(verbose,
98 "%s (" SIZE_FORMAT ") must be "
99 "greater than or equal to ergonomic PLAB minimum size (" SIZE_FORMAT ")\n",
100 name, value, PLAB::min_size());
101 return JVMFlag::VIOLATES_CONSTRAINT;
102 }
103 #endif // INCLUDE_ALL_GCS
104 return JVMFlag::SUCCESS;
105 }
106
107 JVMFlag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
108 #if INCLUDE_ALL_GCS
109 if ((UseConcMarkSweepGC || UseG1GC || UseParallelGC) && (value > PLAB::max_size())) {
110 CommandLineError::print(verbose,
111 "%s (" SIZE_FORMAT ") must be "
112 "less than or equal to ergonomic PLAB maximum size (" SIZE_FORMAT ")\n",
113 name, value, PLAB::max_size());
114 return JVMFlag::VIOLATES_CONSTRAINT;
115 }
116 #endif // INCLUDE_ALL_GCS
117 return JVMFlag::SUCCESS;
118 }
119
120 static JVMFlag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
121 JVMFlag::Error status = MinPLABSizeBounds(name, value, verbose);
122
123 if (status == JVMFlag::SUCCESS) {
124 return MaxPLABSizeBounds(name, value, verbose);
125 }
126 return status;
127 }
128
129 JVMFlag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) {
130 return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose);
131 }
132
133 JVMFlag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose) {
134 JVMFlag::Error status = JVMFlag::SUCCESS;
135
136 #if INCLUDE_ALL_GCS
137 if (UseConcMarkSweepGC) {
138 return OldPLABSizeConstraintFuncCMS(value, verbose);
139 } else {
140 status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
141 }
142 #endif
143 return status;
144 }
145
146 JVMFlag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
147 if (value > MaxHeapFreeRatio) {
148 CommandLineError::print(verbose,
149 "MinHeapFreeRatio (" UINTX_FORMAT ") must be "
150 "less than or equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
151 value, MaxHeapFreeRatio);
152 return JVMFlag::VIOLATES_CONSTRAINT;
153 } else {
154 return JVMFlag::SUCCESS;
155 }
156 }
157
158 JVMFlag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
159 if (value < MinHeapFreeRatio) {
160 CommandLineError::print(verbose,
161 "MaxHeapFreeRatio (" UINTX_FORMAT ") must be "
162 "greater than or equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n",
204 value, MaxMetaspaceFreeRatio);
205 return JVMFlag::VIOLATES_CONSTRAINT;
206 } else {
207 return JVMFlag::SUCCESS;
208 }
209 }
210
211 JVMFlag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
212 if (value < MinMetaspaceFreeRatio) {
213 CommandLineError::print(verbose,
214 "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
215 "greater than or equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
216 value, MinMetaspaceFreeRatio);
217 return JVMFlag::VIOLATES_CONSTRAINT;
218 } else {
219 return JVMFlag::SUCCESS;
220 }
221 }
222
223 JVMFlag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
224 #if INCLUDE_ALL_GCS
225 JVMFlag::Error status = InitialTenuringThresholdConstraintFuncParallel(value, verbose);
226 if (status != JVMFlag::SUCCESS) {
227 return status;
228 }
229 #endif
230
231 return JVMFlag::SUCCESS;
232 }
233
234 JVMFlag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) {
235 #if INCLUDE_ALL_GCS
236 JVMFlag::Error status = MaxTenuringThresholdConstraintFuncParallel(value, verbose);
237 if (status != JVMFlag::SUCCESS) {
238 return status;
239 }
240 #endif
241
242 // MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
243 if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
244 CommandLineError::print(verbose,
245 "MaxTenuringThreshold (0) should match to NeverTenure=false "
246 "&& AlwaysTenure=true. But we have NeverTenure=%s "
247 "AlwaysTenure=%s\n",
248 NeverTenure ? "true" : "false",
249 AlwaysTenure ? "true" : "false");
250 return JVMFlag::VIOLATES_CONSTRAINT;
251 }
252 return JVMFlag::SUCCESS;
253 }
254
255 JVMFlag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) {
256 #if INCLUDE_ALL_GCS
257 JVMFlag::Error status = MaxGCPauseMillisConstraintFuncG1(value, verbose);
258 if (status != JVMFlag::SUCCESS) {
259 return status;
260 }
261 #endif
262
263 return JVMFlag::SUCCESS;
264 }
265
266 JVMFlag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
267 #if INCLUDE_ALL_GCS
268 JVMFlag::Error status = GCPauseIntervalMillisConstraintFuncG1(value, verbose);
269 if (status != JVMFlag::SUCCESS) {
270 return status;
271 }
272 #endif
273
274 return JVMFlag::SUCCESS;
275 }
276
277 JVMFlag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
278 size_t aligned_max = align_down(max_uintx/2, Metaspace::reserve_alignment_words());
279 if (value > aligned_max) {
280 CommandLineError::print(verbose,
281 "InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be "
282 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
283 value, aligned_max);
284 return JVMFlag::VIOLATES_CONSTRAINT;
285 }
286 return JVMFlag::SUCCESS;
287 }
288
289 // To avoid an overflow by 'align_up(value, alignment)'.
290 static JVMFlag::Error MaxSizeForAlignment(const char* name, size_t value, size_t alignment, bool verbose) {
291 size_t aligned_max = ((max_uintx - alignment) & ~(alignment-1));
292 if (value > aligned_max) {
293 CommandLineError::print(verbose,
294 "%s (" SIZE_FORMAT ") must be "
295 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
296 name, value, aligned_max);
297 return JVMFlag::VIOLATES_CONSTRAINT;
298 }
299 return JVMFlag::SUCCESS;
300 }
301
302 static JVMFlag::Error MaxSizeForHeapAlignment(const char* name, size_t value, bool verbose) {
303 size_t heap_alignment;
304
305 #if INCLUDE_ALL_GCS
306 if (UseG1GC) {
307 // For G1 GC, we don't know until G1CollectorPolicy is created.
308 heap_alignment = MaxSizeForHeapAlignmentG1();
309 } else
310 #endif
311 {
312 heap_alignment = CollectorPolicy::compute_heap_alignment();
313 }
314
315 return MaxSizeForAlignment(name, value, heap_alignment, verbose);
316 }
317
318 JVMFlag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose) {
319 return MaxSizeForHeapAlignment("InitialHeapSize", value, verbose);
320 }
321
322 JVMFlag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) {
323 JVMFlag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose);
324
325 if (status == JVMFlag::SUCCESS) {
326 status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose);
327 }
328 return status;
329 }
330
331 JVMFlag::Error HeapBaseMinAddressConstraintFunc(size_t value, bool verbose) {
332 // If an overflow happened in Arguments::set_heap_size(), MaxHeapSize will have too large a value.
333 // Check for this by ensuring that MaxHeapSize plus the requested min base address still fit within max_uintx.
334 if (UseCompressedOops && FLAG_IS_ERGO(MaxHeapSize) && (value > (max_uintx - MaxHeapSize))) {
335 CommandLineError::print(verbose,
336 "HeapBaseMinAddress (" SIZE_FORMAT ") or MaxHeapSize (" SIZE_FORMAT ") is too large. "
337 "Sum of them must be less than or equal to maximum of size_t (" SIZE_FORMAT ")\n",
338 value, MaxHeapSize, max_uintx);
339 return JVMFlag::VIOLATES_CONSTRAINT;
340 }
341
342 return MaxSizeForHeapAlignment("HeapBaseMinAddress", value, verbose);
343 }
344
345 JVMFlag::Error NewSizeConstraintFunc(size_t value, bool verbose) {
346 #if INCLUDE_ALL_GCS
347 JVMFlag::Error status = NewSizeConstraintFuncG1(value, verbose);
348 if (status != JVMFlag::SUCCESS) {
349 return status;
350 }
351 #endif
352
353 return JVMFlag::SUCCESS;
354 }
355
356 JVMFlag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose) {
357 // At least, alignment reserve area is needed.
358 if (value < ThreadLocalAllocBuffer::alignment_reserve_in_bytes()) {
359 CommandLineError::print(verbose,
360 "MinTLABSize (" SIZE_FORMAT ") must be "
361 "greater than or equal to reserved area in TLAB (" SIZE_FORMAT ")\n",
362 value, ThreadLocalAllocBuffer::alignment_reserve_in_bytes());
363 return JVMFlag::VIOLATES_CONSTRAINT;
364 }
365 if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) {
366 CommandLineError::print(verbose,
|
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/gcConfig.hpp"
29 #include "gc/shared/jvmFlagConstraintsGC.hpp"
30 #include "gc/shared/plab.hpp"
31 #include "gc/shared/threadLocalAllocBuffer.hpp"
32 #include "runtime/arguments.hpp"
33 #include "runtime/flags/jvmFlagRangeList.hpp"
34 #include "runtime/globals.hpp"
35 #include "runtime/globals_extension.hpp"
36 #include "runtime/thread.inline.hpp"
37 #include "utilities/align.hpp"
38 #include "utilities/defaultStream.hpp"
39 #include "utilities/macros.hpp"
40 #if INCLUDE_CMSGC
41 #include "gc/cms/jvmFlagConstraintsCMS.hpp"
42 #endif
43 #if INCLUDE_G1GC
44 #include "gc/g1/jvmFlagConstraintsG1.hpp"
45 #endif
46 #if INCLUDE_PARALLELGC
47 #include "gc/parallel/jvmFlagConstraintsParallel.hpp"
48 #endif
49 #ifdef COMPILER1
50 #include "c1/c1_globals.hpp"
51 #endif // COMPILER1
52 #ifdef COMPILER2
53 #include "opto/c2_globals.hpp"
54 #endif // COMPILER2
55
56 // Some flags that have default values that indicate that the
57 // JVM should automatically determine an appropriate value
58 // for that flag. In those cases it is only appropriate for the
59 // constraint checking to be done if the user has specified the
60 // value(s) of the flag(s) on the command line. In the constraint
61 // checking functions, FLAG_IS_CMDLINE() is used to check if
62 // the flag has been set by the user and so should be checked.
63
64 // As ParallelGCThreads differs among GC modes, we need constraint function.
65 JVMFlag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose) {
66 JVMFlag::Error status = JVMFlag::SUCCESS;
67
68 #if INCLUDE_PARALLELGC
69 status = ParallelGCThreadsConstraintFuncParallel(value, verbose);
70 if (status != JVMFlag::SUCCESS) {
71 return status;
72 }
73 #endif
74
75 #if INCLUDE_CMSGC
76 status = ParallelGCThreadsConstraintFuncCMS(value, verbose);
77 if (status != JVMFlag::SUCCESS) {
78 return status;
79 }
80 #endif
81
82 return status;
83 }
84
85 // As ConcGCThreads should be smaller than ParallelGCThreads,
86 // we need constraint function.
87 JVMFlag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose) {
88 // CMS and G1 GCs use ConcGCThreads.
89 if ((GCConfig::is_gc_selected(CollectedHeap::CMS) ||
90 GCConfig::is_gc_selected(CollectedHeap::G1)) && (value > ParallelGCThreads)) {
91 CommandLineError::print(verbose,
92 "ConcGCThreads (" UINT32_FORMAT ") must be "
93 "less than or equal to ParallelGCThreads (" UINT32_FORMAT ")\n",
94 value, ParallelGCThreads);
95 return JVMFlag::VIOLATES_CONSTRAINT;
96 }
97
98 return JVMFlag::SUCCESS;
99 }
100
101 static JVMFlag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) {
102 if ((GCConfig::is_gc_selected(CollectedHeap::CMS) ||
103 GCConfig::is_gc_selected(CollectedHeap::G1) ||
104 GCConfig::is_gc_selected(CollectedHeap::Parallel)) && (value < PLAB::min_size())) {
105 CommandLineError::print(verbose,
106 "%s (" SIZE_FORMAT ") must be "
107 "greater than or equal to ergonomic PLAB minimum size (" SIZE_FORMAT ")\n",
108 name, value, PLAB::min_size());
109 return JVMFlag::VIOLATES_CONSTRAINT;
110 }
111
112 return JVMFlag::SUCCESS;
113 }
114
115 JVMFlag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
116 if ((GCConfig::is_gc_selected(CollectedHeap::CMS) ||
117 GCConfig::is_gc_selected(CollectedHeap::G1) ||
118 GCConfig::is_gc_selected(CollectedHeap::Parallel)) && (value > PLAB::max_size())) {
119 CommandLineError::print(verbose,
120 "%s (" SIZE_FORMAT ") must be "
121 "less than or equal to ergonomic PLAB maximum size (" SIZE_FORMAT ")\n",
122 name, value, PLAB::max_size());
123 return JVMFlag::VIOLATES_CONSTRAINT;
124 }
125
126 return JVMFlag::SUCCESS;
127 }
128
129 static JVMFlag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
130 JVMFlag::Error status = MinPLABSizeBounds(name, value, verbose);
131
132 if (status == JVMFlag::SUCCESS) {
133 return MaxPLABSizeBounds(name, value, verbose);
134 }
135 return status;
136 }
137
138 JVMFlag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) {
139 return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose);
140 }
141
142 JVMFlag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose) {
143 JVMFlag::Error status = JVMFlag::SUCCESS;
144
145 #if INCLUDE_CMSGC
146 if (UseConcMarkSweepGC) {
147 return OldPLABSizeConstraintFuncCMS(value, verbose);
148 } else
149 #endif
150 {
151 status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
152 }
153
154 return status;
155 }
156
157 JVMFlag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
158 if (value > MaxHeapFreeRatio) {
159 CommandLineError::print(verbose,
160 "MinHeapFreeRatio (" UINTX_FORMAT ") must be "
161 "less than or equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
162 value, MaxHeapFreeRatio);
163 return JVMFlag::VIOLATES_CONSTRAINT;
164 } else {
165 return JVMFlag::SUCCESS;
166 }
167 }
168
169 JVMFlag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
170 if (value < MinHeapFreeRatio) {
171 CommandLineError::print(verbose,
172 "MaxHeapFreeRatio (" UINTX_FORMAT ") must be "
173 "greater than or equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n",
215 value, MaxMetaspaceFreeRatio);
216 return JVMFlag::VIOLATES_CONSTRAINT;
217 } else {
218 return JVMFlag::SUCCESS;
219 }
220 }
221
222 JVMFlag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
223 if (value < MinMetaspaceFreeRatio) {
224 CommandLineError::print(verbose,
225 "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be "
226 "greater than or equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
227 value, MinMetaspaceFreeRatio);
228 return JVMFlag::VIOLATES_CONSTRAINT;
229 } else {
230 return JVMFlag::SUCCESS;
231 }
232 }
233
234 JVMFlag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
235 #if INCLUDE_PARALLELGC
236 JVMFlag::Error status = InitialTenuringThresholdConstraintFuncParallel(value, verbose);
237 if (status != JVMFlag::SUCCESS) {
238 return status;
239 }
240 #endif
241
242 return JVMFlag::SUCCESS;
243 }
244
245 JVMFlag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) {
246 #if INCLUDE_PARALLELGC
247 JVMFlag::Error status = MaxTenuringThresholdConstraintFuncParallel(value, verbose);
248 if (status != JVMFlag::SUCCESS) {
249 return status;
250 }
251 #endif
252
253 // MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
254 if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
255 CommandLineError::print(verbose,
256 "MaxTenuringThreshold (0) should match to NeverTenure=false "
257 "&& AlwaysTenure=true. But we have NeverTenure=%s "
258 "AlwaysTenure=%s\n",
259 NeverTenure ? "true" : "false",
260 AlwaysTenure ? "true" : "false");
261 return JVMFlag::VIOLATES_CONSTRAINT;
262 }
263 return JVMFlag::SUCCESS;
264 }
265
266 JVMFlag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) {
267 #if INCLUDE_G1GC
268 JVMFlag::Error status = MaxGCPauseMillisConstraintFuncG1(value, verbose);
269 if (status != JVMFlag::SUCCESS) {
270 return status;
271 }
272 #endif
273
274 return JVMFlag::SUCCESS;
275 }
276
277 JVMFlag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
278 #if INCLUDE_G1GC
279 JVMFlag::Error status = GCPauseIntervalMillisConstraintFuncG1(value, verbose);
280 if (status != JVMFlag::SUCCESS) {
281 return status;
282 }
283 #endif
284
285 return JVMFlag::SUCCESS;
286 }
287
288 JVMFlag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
289 size_t aligned_max = align_down(max_uintx/2, Metaspace::reserve_alignment_words());
290 if (value > aligned_max) {
291 CommandLineError::print(verbose,
292 "InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be "
293 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
294 value, aligned_max);
295 return JVMFlag::VIOLATES_CONSTRAINT;
296 }
297 return JVMFlag::SUCCESS;
298 }
299
300 // To avoid an overflow by 'align_up(value, alignment)'.
301 static JVMFlag::Error MaxSizeForAlignment(const char* name, size_t value, size_t alignment, bool verbose) {
302 size_t aligned_max = ((max_uintx - alignment) & ~(alignment-1));
303 if (value > aligned_max) {
304 CommandLineError::print(verbose,
305 "%s (" SIZE_FORMAT ") must be "
306 "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
307 name, value, aligned_max);
308 return JVMFlag::VIOLATES_CONSTRAINT;
309 }
310 return JVMFlag::SUCCESS;
311 }
312
313 static JVMFlag::Error MaxSizeForHeapAlignment(const char* name, size_t value, bool verbose) {
314 size_t heap_alignment;
315
316 #if INCLUDE_G1GC
317 if (UseG1GC) {
318 // For G1 GC, we don't know until G1CollectorPolicy is created.
319 heap_alignment = MaxSizeForHeapAlignmentG1();
320 } else
321 #endif
322 {
323 heap_alignment = CollectorPolicy::compute_heap_alignment();
324 }
325
326 return MaxSizeForAlignment(name, value, heap_alignment, verbose);
327 }
328
329 JVMFlag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose) {
330 return MaxSizeForHeapAlignment("InitialHeapSize", value, verbose);
331 }
332
333 JVMFlag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) {
334 JVMFlag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose);
335
336 if (status == JVMFlag::SUCCESS) {
337 status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose);
338 }
339 return status;
340 }
341
342 JVMFlag::Error HeapBaseMinAddressConstraintFunc(size_t value, bool verbose) {
343 // If an overflow happened in Arguments::set_heap_size(), MaxHeapSize will have too large a value.
344 // Check for this by ensuring that MaxHeapSize plus the requested min base address still fit within max_uintx.
345 if (UseCompressedOops && FLAG_IS_ERGO(MaxHeapSize) && (value > (max_uintx - MaxHeapSize))) {
346 CommandLineError::print(verbose,
347 "HeapBaseMinAddress (" SIZE_FORMAT ") or MaxHeapSize (" SIZE_FORMAT ") is too large. "
348 "Sum of them must be less than or equal to maximum of size_t (" SIZE_FORMAT ")\n",
349 value, MaxHeapSize, max_uintx);
350 return JVMFlag::VIOLATES_CONSTRAINT;
351 }
352
353 return MaxSizeForHeapAlignment("HeapBaseMinAddress", value, verbose);
354 }
355
356 JVMFlag::Error NewSizeConstraintFunc(size_t value, bool verbose) {
357 #if INCLUDE_G1GC
358 JVMFlag::Error status = NewSizeConstraintFuncG1(value, verbose);
359 if (status != JVMFlag::SUCCESS) {
360 return status;
361 }
362 #endif
363
364 return JVMFlag::SUCCESS;
365 }
366
367 JVMFlag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose) {
368 // At least, alignment reserve area is needed.
369 if (value < ThreadLocalAllocBuffer::alignment_reserve_in_bytes()) {
370 CommandLineError::print(verbose,
371 "MinTLABSize (" SIZE_FORMAT ") must be "
372 "greater than or equal to reserved area in TLAB (" SIZE_FORMAT ")\n",
373 value, ThreadLocalAllocBuffer::alignment_reserve_in_bytes());
374 return JVMFlag::VIOLATES_CONSTRAINT;
375 }
376 if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) {
377 CommandLineError::print(verbose,
|