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 "code/relocInfo.hpp" 27 #include "compiler/compilerConfig.hpp" 28 #include "oops/metadata.hpp" 29 #include "runtime/os.hpp" 30 #include "interpreter/invocationCounter.hpp" 31 #include "runtime/arguments.hpp" 32 #include "runtime/flags/jvmFlag.hpp" 33 #include "runtime/flags/jvmFlagConstraintsCompiler.hpp" 34 #include "runtime/flags/jvmFlagRangeList.hpp" 35 #include "runtime/globals.hpp" 36 #include "runtime/globals_extension.hpp" 37 #include "utilities/defaultStream.hpp" 38 39 JVMFlag::Error AliasLevelConstraintFunc(intx value, bool verbose) { 40 if ((value <= 1) && (Arguments::mode() == Arguments::_comp || Arguments::mode() == Arguments::_mixed)) { 41 CommandLineError::print(verbose, 42 "AliasLevel (" INTX_FORMAT ") is not " 43 "compatible with -Xcomp or -Xmixed\n", 44 value); 45 return JVMFlag::VIOLATES_CONSTRAINT; 46 } else { 47 return JVMFlag::SUCCESS; 48 } 49 } 50 51 /** 52 * Validate the minimum number of compiler threads needed to run the 53 * JVM. The following configurations are possible. 54 * 55 * 1) The JVM is build using an interpreter only. As a result, the minimum number of 56 * compiler threads is 0. 57 * 2) The JVM is build using the compiler(s) and tiered compilation is disabled. As 58 * a result, either C1 or C2 is used, so the minimum number of compiler threads is 1. 59 * 3) The JVM is build using the compiler(s) and tiered compilation is enabled. However, 60 * the option "TieredStopAtLevel < CompLevel_full_optimization". As a result, only 61 * C1 can be used, so the minimum number of compiler threads is 1. 62 * 4) The JVM is build using the compilers and tiered compilation is enabled. The option 63 * 'TieredStopAtLevel = CompLevel_full_optimization' (the default value). As a result, 64 * the minimum number of compiler threads is 2. 65 */ 66 JVMFlag::Error CICompilerCountConstraintFunc(intx value, bool verbose) { 67 int min_number_of_compiler_threads = 0; 68 #if !defined(COMPILER1) && !defined(COMPILER2) && !INCLUDE_JVMCI 69 // case 1 70 #else 71 if (!TieredCompilation || (TieredStopAtLevel < CompLevel_full_optimization)) { 72 min_number_of_compiler_threads = 1; // case 2 or case 3 73 } else { 74 min_number_of_compiler_threads = 2; // case 4 (tiered) 75 } 76 #endif 77 78 // The default CICompilerCount's value is CI_COMPILER_COUNT. 79 // With a client VM, -XX:+TieredCompilation causes TieredCompilation 80 // to be true here (the option is validated later) and 81 // min_number_of_compiler_threads to exceed CI_COMPILER_COUNT. 82 min_number_of_compiler_threads = MIN2(min_number_of_compiler_threads, CI_COMPILER_COUNT); 83 84 if (value < (intx)min_number_of_compiler_threads) { 85 CommandLineError::print(verbose, 86 "CICompilerCount (" INTX_FORMAT ") must be " 87 "at least %d \n", 88 value, min_number_of_compiler_threads); 89 return JVMFlag::VIOLATES_CONSTRAINT; 90 } else { 91 return JVMFlag::SUCCESS; 92 } 93 } 94 95 JVMFlag::Error AllocatePrefetchDistanceConstraintFunc(intx value, bool verbose) { 96 if (value < 0 || value > 512) { 97 CommandLineError::print(verbose, 98 "AllocatePrefetchDistance (" INTX_FORMAT ") must be " 99 "between 0 and " INTX_FORMAT "\n", 100 AllocatePrefetchDistance, 512); 101 return JVMFlag::VIOLATES_CONSTRAINT; 102 } 103 104 return JVMFlag::SUCCESS; 105 } 106 107 JVMFlag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose) { 108 if (AllocatePrefetchStyle == 3) { 109 if (value % wordSize != 0) { 110 CommandLineError::print(verbose, 111 "AllocatePrefetchStepSize (" INTX_FORMAT ") must be multiple of %d\n", 112 value, wordSize); 113 return JVMFlag::VIOLATES_CONSTRAINT; 114 } 115 } 116 return JVMFlag::SUCCESS; 117 } 118 119 JVMFlag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose) { 120 intx max_value = max_intx; 121 #if defined(SPARC) 122 max_value = 1; 123 #elif defined(X86) 124 max_value = 3; 125 #endif 126 if (value < 0 || value > max_value) { 127 CommandLineError::print(verbose, 128 "AllocatePrefetchInstr (" INTX_FORMAT ") must be " 129 "between 0 and " INTX_FORMAT "\n", value, max_value); 130 return JVMFlag::VIOLATES_CONSTRAINT; 131 } 132 133 return JVMFlag::SUCCESS; 134 } 135 136 JVMFlag::Error CompileThresholdConstraintFunc(intx value, bool verbose) { 137 if (value < 0 || value > INT_MAX >> InvocationCounter::count_shift) { 138 CommandLineError::print(verbose, 139 "CompileThreshold (" INTX_FORMAT ") " 140 "must be between 0 and %d\n", 141 value, 142 INT_MAX >> InvocationCounter::count_shift); 143 return JVMFlag::VIOLATES_CONSTRAINT; 144 } 145 146 return JVMFlag::SUCCESS; 147 } 148 149 JVMFlag::Error OnStackReplacePercentageConstraintFunc(intx value, bool verbose) { 150 int backward_branch_limit; 151 if (ProfileInterpreter) { 152 if (OnStackReplacePercentage < InterpreterProfilePercentage) { 153 CommandLineError::print(verbose, 154 "OnStackReplacePercentage (" INTX_FORMAT ") must be " 155 "larger than InterpreterProfilePercentage (" INTX_FORMAT ")\n", 156 OnStackReplacePercentage, InterpreterProfilePercentage); 157 return JVMFlag::VIOLATES_CONSTRAINT; 158 } 159 160 backward_branch_limit = ((CompileThreshold * (OnStackReplacePercentage - InterpreterProfilePercentage)) / 100) 161 << InvocationCounter::count_shift; 162 163 if (backward_branch_limit < 0) { 164 CommandLineError::print(verbose, 165 "CompileThreshold * (InterpreterProfilePercentage - OnStackReplacePercentage) / 100 = " 166 INTX_FORMAT " " 167 "must be between 0 and " INTX_FORMAT ", try changing " 168 "CompileThreshold, InterpreterProfilePercentage, and/or OnStackReplacePercentage\n", 169 (CompileThreshold * (OnStackReplacePercentage - InterpreterProfilePercentage)) / 100, 170 INT_MAX >> InvocationCounter::count_shift); 171 return JVMFlag::VIOLATES_CONSTRAINT; 172 } 173 } else { 174 if (OnStackReplacePercentage < 0 ) { 175 CommandLineError::print(verbose, 176 "OnStackReplacePercentage (" INTX_FORMAT ") must be " 177 "non-negative\n", OnStackReplacePercentage); 178 return JVMFlag::VIOLATES_CONSTRAINT; 179 } 180 181 backward_branch_limit = ((CompileThreshold * OnStackReplacePercentage) / 100) 182 << InvocationCounter::count_shift; 183 184 if (backward_branch_limit < 0) { 185 CommandLineError::print(verbose, 186 "CompileThreshold * OnStackReplacePercentage / 100 = " INTX_FORMAT " " 187 "must be between 0 and " INTX_FORMAT ", try changing " 188 "CompileThreshold and/or OnStackReplacePercentage\n", 189 (CompileThreshold * OnStackReplacePercentage) / 100, 190 INT_MAX >> InvocationCounter::count_shift); 191 return JVMFlag::VIOLATES_CONSTRAINT; 192 } 193 } 194 return JVMFlag::SUCCESS; 195 } 196 197 JVMFlag::Error CodeCacheSegmentSizeConstraintFunc(uintx value, bool verbose) { 198 if (CodeCacheSegmentSize < (uintx)CodeEntryAlignment) { 199 CommandLineError::print(verbose, 200 "CodeCacheSegmentSize (" UINTX_FORMAT ") must be " 201 "larger than or equal to CodeEntryAlignment (" INTX_FORMAT ") " 202 "to align entry points\n", 203 CodeCacheSegmentSize, CodeEntryAlignment); 204 return JVMFlag::VIOLATES_CONSTRAINT; 205 } 206 207 if (CodeCacheSegmentSize < sizeof(jdouble)) { 208 CommandLineError::print(verbose, 209 "CodeCacheSegmentSize (" UINTX_FORMAT ") must be " 210 "at least " SIZE_FORMAT " to align constants\n", 211 CodeCacheSegmentSize, sizeof(jdouble)); 212 return JVMFlag::VIOLATES_CONSTRAINT; 213 } 214 215 #ifdef COMPILER2 216 if (CodeCacheSegmentSize < (uintx)OptoLoopAlignment) { 217 CommandLineError::print(verbose, 218 "CodeCacheSegmentSize (" UINTX_FORMAT ") must be " 219 "larger than or equal to OptoLoopAlignment (" INTX_FORMAT ") " 220 "to align inner loops\n", 221 CodeCacheSegmentSize, OptoLoopAlignment); 222 return JVMFlag::VIOLATES_CONSTRAINT; 223 } 224 #endif 225 226 return JVMFlag::SUCCESS; 227 } 228 229 JVMFlag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose) { 230 #ifdef SOLARIS 231 if ((value < MinimumPriority || value > MaximumPriority) && 232 (value != -1) && (value != -FXCriticalPriority)) { 233 CommandLineError::print(verbose, 234 "CompileThreadPriority (" INTX_FORMAT ") must be " 235 "between %d and %d inclusively or -1 (means no change) " 236 "or %d (special value for critical thread class/priority)\n", 237 value, MinimumPriority, MaximumPriority, -FXCriticalPriority); 238 return JVMFlag::VIOLATES_CONSTRAINT; 239 } 240 #endif 241 242 return JVMFlag::SUCCESS; 243 } 244 245 JVMFlag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose) { 246 #ifdef SPARC 247 if (CodeEntryAlignment % relocInfo::addr_unit() != 0) { 248 CommandLineError::print(verbose, 249 "CodeEntryAlignment (" INTX_FORMAT ") must be " 250 "multiple of NOP size\n", CodeEntryAlignment); 251 return JVMFlag::VIOLATES_CONSTRAINT; 252 } 253 #endif 254 255 if (!is_power_of_2(value)) { 256 CommandLineError::print(verbose, 257 "CodeEntryAlignment (" INTX_FORMAT ") must be " 258 "a power of two\n", CodeEntryAlignment); 259 return JVMFlag::VIOLATES_CONSTRAINT; 260 } 261 262 if (CodeEntryAlignment < 16) { 263 CommandLineError::print(verbose, 264 "CodeEntryAlignment (" INTX_FORMAT ") must be " 265 "greater than or equal to %d\n", 266 CodeEntryAlignment, 16); 267 return JVMFlag::VIOLATES_CONSTRAINT; 268 } 269 270 return JVMFlag::SUCCESS; 271 } 272 273 JVMFlag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose) { 274 if (!is_power_of_2(value)) { 275 CommandLineError::print(verbose, 276 "OptoLoopAlignment (" INTX_FORMAT ") " 277 "must be a power of two\n", 278 value); 279 return JVMFlag::VIOLATES_CONSTRAINT; 280 } 281 282 // Relevant on ppc, s390, sparc. Will be optimized where 283 // addr_unit() == 1. 284 if (OptoLoopAlignment % relocInfo::addr_unit() != 0) { 285 CommandLineError::print(verbose, 286 "OptoLoopAlignment (" INTX_FORMAT ") must be " 287 "multiple of NOP size (%d)\n", 288 value, relocInfo::addr_unit()); 289 return JVMFlag::VIOLATES_CONSTRAINT; 290 } 291 292 return JVMFlag::SUCCESS; 293 } 294 295 JVMFlag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose) { 296 if (value >= 4032) { 297 CommandLineError::print(verbose, 298 "ArraycopyDstPrefetchDistance (" UINTX_FORMAT ") must be" 299 "between 0 and 4031\n", value); 300 return JVMFlag::VIOLATES_CONSTRAINT; 301 } 302 303 return JVMFlag::SUCCESS; 304 } 305 306 JVMFlag::Error ArraycopySrcPrefetchDistanceConstraintFunc(uintx value, bool verbose) { 307 if (value >= 4032) { 308 CommandLineError::print(verbose, 309 "ArraycopySrcPrefetchDistance (" UINTX_FORMAT ") must be" 310 "between 0 and 4031\n", value); 311 return JVMFlag::VIOLATES_CONSTRAINT; 312 } 313 314 return JVMFlag::SUCCESS; 315 } 316 317 JVMFlag::Error TypeProfileLevelConstraintFunc(uintx value, bool verbose) { 318 for (int i = 0; i < 3; i++) { 319 if (value % 10 > 2) { 320 CommandLineError::print(verbose, 321 "Invalid value (" UINTX_FORMAT ") " 322 "in TypeProfileLevel at position %d\n", value, i); 323 return JVMFlag::VIOLATES_CONSTRAINT; 324 } 325 value = value / 10; 326 } 327 328 return JVMFlag::SUCCESS; 329 } 330 331 JVMFlag::Error InitArrayShortSizeConstraintFunc(intx value, bool verbose) { 332 if (value % BytesPerLong != 0) { 333 return JVMFlag::VIOLATES_CONSTRAINT; 334 } else { 335 return JVMFlag::SUCCESS; 336 } 337 } 338 339 #ifdef COMPILER2 340 JVMFlag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose) { 341 if (InteriorEntryAlignment > CodeEntryAlignment) { 342 CommandLineError::print(verbose, 343 "InteriorEntryAlignment (" INTX_FORMAT ") must be " 344 "less than or equal to CodeEntryAlignment (" INTX_FORMAT ")\n", 345 InteriorEntryAlignment, CodeEntryAlignment); 346 return JVMFlag::VIOLATES_CONSTRAINT; 347 } 348 349 #ifdef SPARC 350 if (InteriorEntryAlignment % relocInfo::addr_unit() != 0) { 351 CommandLineError::print(verbose, 352 "InteriorEntryAlignment (" INTX_FORMAT ") must be " 353 "multiple of NOP size\n"); 354 return JVMFlag::VIOLATES_CONSTRAINT; 355 } 356 #endif 357 358 if (!is_power_of_2(value)) { 359 CommandLineError::print(verbose, 360 "InteriorEntryAlignment (" INTX_FORMAT ") must be " 361 "a power of two\n", InteriorEntryAlignment); 362 return JVMFlag::VIOLATES_CONSTRAINT; 363 } 364 365 int minimum_alignment = 16; 366 #if defined(SPARC) || (defined(X86) && !defined(AMD64)) 367 minimum_alignment = 4; 368 #elif defined(S390) 369 minimum_alignment = 2; 370 #endif 371 372 if (InteriorEntryAlignment < minimum_alignment) { 373 CommandLineError::print(verbose, 374 "InteriorEntryAlignment (" INTX_FORMAT ") must be " 375 "greater than or equal to %d\n", 376 InteriorEntryAlignment, minimum_alignment); 377 return JVMFlag::VIOLATES_CONSTRAINT; 378 } 379 380 return JVMFlag::SUCCESS; 381 } 382 383 JVMFlag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose) { 384 if (value < MaxNodeLimit * 2 / 100 || value > MaxNodeLimit * 40 / 100) { 385 CommandLineError::print(verbose, 386 "NodeLimitFudgeFactor must be between 2%% and 40%% " 387 "of MaxNodeLimit (" INTX_FORMAT ")\n", 388 MaxNodeLimit); 389 return JVMFlag::VIOLATES_CONSTRAINT; 390 } 391 392 return JVMFlag::SUCCESS; 393 } 394 #endif // COMPILER2 395 396 JVMFlag::Error RTMTotalCountIncrRateConstraintFunc(int value, bool verbose) { 397 #if INCLUDE_RTM_OPT 398 if (UseRTMLocking && !is_power_of_2(RTMTotalCountIncrRate)) { 399 CommandLineError::print(verbose, 400 "RTMTotalCountIncrRate (" INTX_FORMAT 401 ") must be a power of 2, resetting it to 64\n", 402 RTMTotalCountIncrRate); 403 FLAG_SET_DEFAULT(RTMTotalCountIncrRate, 64); 404 } 405 #endif 406 407 return JVMFlag::SUCCESS; 408 }