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, |