8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
Summary: Add range check or constraint where necessary.
Reviewed-by: roland, thartmann
--- a/hotspot/src/cpu/sparc/vm/globals_sparc.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/cpu/sparc/vm/globals_sparc.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -82,6 +82,7 @@
\
product(intx, UseVIS, 99, \
"Highest supported VIS instructions set on Sparc") \
+ range(0, 99) \
\
product(bool, UseCBCond, false, \
"Use compare and branch instruction on SPARC") \
@@ -91,12 +92,14 @@
\
product(intx, BlockZeroingLowLimit, 2048, \
"Minimum size in bytes when block zeroing will be used") \
+ range(1, max_jint) \
\
product(bool, UseBlockCopy, false, \
"Use special cpu instructions for block copy") \
\
product(intx, BlockCopyLowLimit, 2048, \
"Minimum size in bytes when block copy will be used") \
+ range(1, max_jint) \
\
develop(bool, UseV8InstrsOnly, false, \
"Use SPARC-V8 Compliant instruction subset") \
@@ -108,9 +111,11 @@
"Do not use swap instructions, but only CAS (in a loop) on SPARC")\
\
product(uintx, ArraycopySrcPrefetchDistance, 0, \
- "Distance to prefetch source array in arracopy") \
+ "Distance to prefetch source array in arraycopy") \
+ constraint(ArraycopySrcPrefetchDistanceConstraintFunc, AfterErgo) \
\
product(uintx, ArraycopyDstPrefetchDistance, 0, \
- "Distance to prefetch destination array in arracopy") \
+ "Distance to prefetch destination array in arraycopy") \
+ constraint(ArraycopyDstPrefetchDistanceConstraintFunc, AfterErgo) \
#endif // CPU_SPARC_VM_GLOBALS_SPARC_HPP
--- a/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp Fri Oct 09 14:21:26 2015 +0200
@@ -40,10 +40,6 @@
PrefetchScanIntervalInBytes = prefetch_scan_interval_in_bytes();
PrefetchFieldsAhead = prefetch_fields_ahead();
- assert(0 <= AllocatePrefetchInstr && AllocatePrefetchInstr <= 1, "invalid value");
- if( AllocatePrefetchInstr < 0 ) AllocatePrefetchInstr = 0;
- if( AllocatePrefetchInstr > 1 ) AllocatePrefetchInstr = 0;
-
// Allocation prefetch settings
intx cache_line_size = prefetch_data_size();
if( cache_line_size > AllocatePrefetchStepSize )
@@ -59,13 +55,6 @@
AllocatePrefetchDistance = allocate_prefetch_distance();
AllocatePrefetchStyle = allocate_prefetch_style();
- assert((AllocatePrefetchDistance % AllocatePrefetchStepSize) == 0 &&
- (AllocatePrefetchDistance > 0), "invalid value");
- if ((AllocatePrefetchDistance % AllocatePrefetchStepSize) != 0 ||
- (AllocatePrefetchDistance <= 0)) {
- AllocatePrefetchDistance = AllocatePrefetchStepSize;
- }
-
if (AllocatePrefetchStyle == 3 && !has_blk_init()) {
warning("BIS instructions are not available on this CPU");
FLAG_SET_DEFAULT(AllocatePrefetchStyle, 1);
@@ -73,13 +62,6 @@
guarantee(VM_Version::has_v9(), "only SPARC v9 is supported");
- assert(ArraycopySrcPrefetchDistance < 4096, "invalid value");
- if (ArraycopySrcPrefetchDistance >= 4096)
- ArraycopySrcPrefetchDistance = 4064;
- assert(ArraycopyDstPrefetchDistance < 4096, "invalid value");
- if (ArraycopyDstPrefetchDistance >= 4096)
- ArraycopyDstPrefetchDistance = 4064;
-
UseSSE = 0; // Only on x86 and x64
_supports_cx8 = has_v9();
--- a/hotspot/src/cpu/x86/vm/globals_x86.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/cpu/x86/vm/globals_x86.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -91,6 +91,7 @@
\
product(intx, UseAVX, 99, \
"Highest supported AVX instructions set on x86/x64") \
+ range(0, 99) \
\
product(bool, UseCLMUL, false, \
"Control whether CLMUL instructions can be used on x86/x64") \
--- a/hotspot/src/cpu/x86/vm/vm_version_x86.cpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/cpu/x86/vm/vm_version_x86.cpp Fri Oct 09 14:21:26 2015 +0200
@@ -1092,11 +1092,6 @@
}
#endif // COMPILER2
- assert(0 <= AllocatePrefetchInstr && AllocatePrefetchInstr <= 3, "invalid value");
-
- // set valid Prefetch instruction
- if( AllocatePrefetchInstr < 0 ) AllocatePrefetchInstr = 0;
- if( AllocatePrefetchInstr > 3 ) AllocatePrefetchInstr = 3;
if( AllocatePrefetchInstr == 3 && !supports_3dnow_prefetch() ) AllocatePrefetchInstr=0;
if( !supports_sse() && supports_3dnow_prefetch() ) AllocatePrefetchInstr = 3;
@@ -1135,7 +1130,6 @@
}
#endif
}
- assert(AllocatePrefetchDistance % AllocatePrefetchStepSize == 0, "invalid value");
#ifdef _LP64
// Prefetch settings
--- a/hotspot/src/share/vm/c1/c1_globals.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/c1/c1_globals.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -152,6 +152,7 @@
\
product(intx, ValueMapMaxLoopSize, 8, \
"maximum size of a loop optimized by global value numbering") \
+ range(0, 128) \
\
develop(bool, EliminateBlocks, true, \
"Eliminate unneccessary basic blocks") \
@@ -220,6 +221,7 @@
\
develop(intx, TraceLinearScanLevel, 0, \
"Debug levels for the linear scan allocator") \
+ range(0, 4) \
\
develop(bool, StressLinearScan, false, \
"scramble block order used by LinearScan (stress test)") \
@@ -294,6 +296,7 @@
\
develop(intx, NMethodSizeLimit, (64*K)*wordSize, \
"Maximum size of a compiled method.") \
+ range(0, max_jint) \
\
develop(bool, TraceFPUStack, false, \
"Trace emulation of the FPU stack (intel only)") \
@@ -309,6 +312,7 @@
\
develop(intx, InstructionCountCutoff, 37000, \
"If GraphBuilder adds this many instructions, bails out") \
+ range(0, max_jint) \
\
develop(bool, ComputeExactFPURegisterUsage, true, \
"Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)") \
--- a/hotspot/src/share/vm/oops/methodCounters.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/oops/methodCounters.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -42,7 +42,7 @@
// The counter is reset by the sweeper and is decremented by some of the compiled
// code. The counter values are interpreted as follows:
// 1. (HotMethodDetection..INT_MAX] - initial value, no counters inserted
- // 2. (1..HotMethodDetectionLimit) - the method is warm, the counter is used
+ // 2. [1..HotMethodDetectionLimit) - the method is warm, the counter is used
// to figure out which methods can be flushed.
// 3. (INT_MIN..0] - method is hot and will deopt and get
// recompiled without the counters
--- a/hotspot/src/share/vm/opto/c2_globals.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -72,24 +72,29 @@
develop(intx, OptoPrologueNops, 0, \
"Insert this many extra nop instructions " \
"in the prologue of every nmethod") \
+ range(0, 128) \
\
product_pd(intx, InteriorEntryAlignment, \
"Code alignment for interior entry points " \
"in generated code (in bytes)") \
+ constraint(InteriorEntryAlignmentConstraintFunc, AfterErgo) \
\
product(intx, MaxLoopPad, (OptoLoopAlignment-1), \
"Align a loop if padding size in bytes is less or equal to this " \
"value") \
+ range(0, max_jint) \
\
product(intx, MaxVectorSize, 64, \
"Max vector size in bytes, " \
"actual size could be less depending on elements type") \
+ range(0, max_jint) \
\
product(bool, AlignVector, true, \
"Perform vector store/load alignment in loop") \
\
product(intx, NumberOfLoopInstrToAlign, 4, \
"Number of first instructions in a loop to align") \
+ range(0, max_jint) \
\
notproduct(intx, IndexSetWatch, 0, \
"Trace all operations on this IndexSet (-1 means all, 0 none)") \
@@ -97,9 +102,11 @@
\
develop(intx, OptoNodeListSize, 4, \
"Starting allocation size of Node_List data structures") \
+ range(0, max_jint) \
\
develop(intx, OptoBlockListSize, 8, \
"Starting allocation size of Block_List data structures") \
+ range(0, max_jint) \
\
develop(intx, OptoPeepholeAt, -1, \
"Apply peephole optimizations to this peephole rule") \
@@ -173,9 +180,11 @@
\
product_pd(intx, LoopUnrollLimit, \
"Unroll loop bodies with node count less than this") \
+ range(0, max_jint / 4) \
\
product(intx, LoopMaxUnroll, 16, \
"Maximum number of unrolls for main loop") \
+ range(0, max_jint) \
\
product(bool, SuperWordLoopUnrollAnalysis, false, \
"Map number of unrolls for main loop via " \
@@ -187,16 +196,19 @@
product(intx, LoopUnrollMin, 4, \
"Minimum number of unroll loop bodies before checking progress" \
"of rounds of unroll,optimize,..") \
+ range(0, max_jint) \
\
develop(intx, UnrollLimitForProfileCheck, 1, \
"Don't use profile_trip_cnt() to restrict unrolling until " \
"unrolling would push the number of unrolled iterations above " \
"UnrollLimitForProfileCheck. A higher value allows more " \
"unrolling. Zero acts as a very large value." ) \
+ range(0, max_intx) \
\
product(intx, MultiArrayExpandLimit, 6, \
"Maximum number of individual allocations in an inline-expanded " \
"multianewarray instruction") \
+ range(0, max_jint) \
\
notproduct(bool, TraceProfileTripCount, false, \
"Trace profile loop trip count information") \
@@ -243,6 +255,7 @@
\
product(intx, TrackedInitializationLimit, 50, \
"When initializing fields, track up to this many words") \
+ range(0, 65535) \
\
product(bool, ReduceFieldZeroing, true, \
"When initializing fields, try to avoid needless zeroing") \
@@ -277,9 +290,11 @@
\
develop_pd(intx, FLOATPRESSURE, \
"Number of float LRG's that constitute high register pressure") \
+ range(0, max_jint) \
\
develop_pd(intx, INTPRESSURE, \
"Number of integer LRG's that constitute high register pressure") \
+ range(0, max_jint) \
\
notproduct(bool, TraceOptoPipelining, false, \
"Trace pipelining information") \
@@ -298,6 +313,7 @@
\
product(intx, PartialPeelNewPhiDelta, 0, \
"Additional phis that can be created by partial peeling") \
+ range(0, max_jint) \
\
notproduct(bool, TracePartialPeeling, false, \
"Trace partial peeling (loop rotation) information") \
@@ -337,6 +353,7 @@
\
product_pd(intx, ConditionalMoveLimit, \
"Limit of ops to make speculative when using CMOVE") \
+ range(0, max_jint) \
\
/* Set BranchOnRegister == false. See 4965987. */ \
product(bool, BranchOnRegister, false, \
@@ -361,6 +378,7 @@
\
develop(intx, PrintIdealGraphPort, 4444, \
"Ideal graph printer to network port") \
+ range(0, SHRT_MAX) \
\
notproduct(ccstr, PrintIdealGraphAddress, "127.0.0.1", \
"IP address to connect to visualizer") \
@@ -389,50 +407,64 @@
develop(intx, ImplicitNullCheckThreshold, 3, \
"Don't do implicit null checks if NPE's in a method exceeds " \
"limit") \
+ range(0, max_jint) \
\
product(intx, LoopOptsCount, 43, \
"Set level of loop optimization for tier 1 compiles") \
+ range(5, 43) \
\
/* controls for heat-based inlining */ \
\
develop(intx, NodeCountInliningCutoff, 18000, \
"If parser node generation exceeds limit stop inlining") \
+ range(0, max_jint) \
\
develop(intx, NodeCountInliningStep, 1000, \
"Target size of warm calls inlined between optimization passes") \
+ range(0, max_jint) \
\
develop(bool, InlineWarmCalls, false, \
"Use a heat-based priority queue to govern inlining") \
\
develop(intx, HotCallCountThreshold, 999999, \
"large numbers of calls (per method invocation) force hotness") \
+ range(0, max_intx) \
\
develop(intx, HotCallProfitThreshold, 999999, \
"highly profitable inlining opportunities force hotness") \
+ range(0, max_intx) \
\
develop(intx, HotCallTrivialWork, -1, \
"trivial execution time (no larger than this) forces hotness") \
+ range(-1, max_intx) \
\
develop(intx, HotCallTrivialSize, -1, \
"trivial methods (no larger than this) force calls to be hot") \
+ range(-1, max_intx) \
\
develop(intx, WarmCallMinCount, -1, \
"number of calls (per method invocation) to enable inlining") \
+ range(-1, max_intx) \
\
develop(intx, WarmCallMinProfit, -1, \
"number of calls (per method invocation) to enable inlining") \
+ range(-1, max_intx) \
\
develop(intx, WarmCallMaxWork, 999999, \
"execution time of the largest inlinable method") \
+ range(0, max_intx) \
\
develop(intx, WarmCallMaxSize, 999999, \
"size of the largest inlinable method") \
+ range(0, max_intx) \
\
product(intx, MaxNodeLimit, 80000, \
"Maximum number of nodes") \
+ range(1000, max_jint / 3) \
\
product(intx, NodeLimitFudgeFactor, 2000, \
"Fudge Factor for certain optimizations") \
+ constraint(NodeLimitFudgeFactorConstraintFunc, AfterErgo) \
\
product(bool, UseJumpTables, true, \
"Use JumpTables instead of a binary search tree for switches") \
@@ -442,12 +474,15 @@
\
product_pd(intx, MinJumpTableSize, \
"Minimum number of targets in a generated jump table") \
+ range(0, max_intx) \
\
product(intx, MaxJumpTableSize, 65000, \
"Maximum number of targets in a generated jump table") \
+ range(0, max_intx) \
\
product(intx, MaxJumpTableSparseness, 5, \
"Maximum sparseness for jumptables") \
+ range(0, max_intx / 4) \
\
product(bool, EliminateLocks, true, \
"Coarsen locks when possible") \
@@ -475,6 +510,7 @@
\
product(intx, AutoBoxCacheMax, 128, \
"Sets max value cached by the java.lang.Integer autobox cache") \
+ range(0, max_jint) \
\
experimental(bool, AggressiveUnboxing, false, \
"Control optimizations for aggressive boxing elimination") \
@@ -487,6 +523,7 @@
\
product(double, EscapeAnalysisTimeout, 20. DEBUG_ONLY(+40.), \
"Abort EA when it reaches time limit (in sec)") \
+ range(0, DBL_MAX) \
\
develop(bool, ExitEscapeAnalysisOnTimeout, true, \
"Exit or throw assert in EA when it reaches time limit") \
@@ -502,6 +539,7 @@
\
product(intx, EliminateAllocationArraySizeLimit, 64, \
"Array size (number of elements) limit for scalar replacement") \
+ range(0, max_jint) \
\
product(bool, OptimizePtrCompare, true, \
"Use escape analysis to optimize pointers compare") \
@@ -523,12 +561,15 @@
\
product(intx, ValueSearchLimit, 1000, \
"Recursion limit in PhaseMacroExpand::value_from_mem_phi") \
+ range(0, max_jint) \
\
product(intx, MaxLabelRootDepth, 1100, \
"Maximum times call Label_Root to prevent stack overflow") \
+ range(100, max_jint) \
\
diagnostic(intx, DominatorSearchLimit, 1000, \
"Iterations limit in Node::dominates") \
+ range(0, max_jint) \
\
product(bool, BlockLayoutByFrequency, true, \
"Use edge frequencies to drive block ordering") \
@@ -638,6 +679,7 @@
\
develop(intx, FreqCountInvocations, 1, \
"Scaling factor for branch frequencies (deprecated)") \
+ range(1, max_intx) \
\
product(intx, AliasLevel, 3, \
"0 for no aliasing, 1 for oop/field/static/array split, " \
@@ -656,6 +698,7 @@
\
product(intx, LiveNodeCountInliningCutoff, 40000, \
"max number of live nodes in a method") \
+ range(0, max_juint / 8) \
\
diagnostic(bool, OptimizeExpensiveOps, true, \
"Find best control for expensive operations") \
@@ -692,6 +735,7 @@
product(intx, ArrayCopyLoadStoreMaxElem, 8, \
"Maximum number of arraycopy elements inlined as a sequence of" \
"loads/stores") \
+ range(0, max_intx) \
\
develop(bool, StressArrayCopyMacroNode, false, \
"Perform ArrayCopy load/store replacement during IGVN only")
--- a/hotspot/src/share/vm/opto/parse3.cpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/opto/parse3.cpp Fri Oct 09 14:21:26 2015 +0200
@@ -404,7 +404,7 @@
// The original expression was of this form: new T[length0][length1]...
// It is often the case that the lengths are small (except the last).
// If that happens, use the fast 1-d creator a constant number of times.
- const jint expand_limit = MIN2((juint)MultiArrayExpandLimit, (juint)100);
+ const jint expand_limit = MIN2((jint)MultiArrayExpandLimit, 100);
jint expand_count = 1; // count of allocations in the expansion
jint expand_fanout = 1; // running total fanout
for (j = 0; j < ndimensions-1; j++) {
--- a/hotspot/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp Fri Oct 09 14:21:26 2015 +0200
@@ -23,6 +23,10 @@
*/
#include "precompiled.hpp"
+#include "oops/metadata.hpp"
+#include "runtime/os.hpp"
+#include "code/relocInfo.hpp"
+#include "interpreter/invocationCounter.hpp"
#include "runtime/arguments.hpp"
#include "runtime/commandLineFlagConstraintsCompiler.hpp"
#include "runtime/commandLineFlagRangeList.hpp"
@@ -84,3 +88,308 @@
return Flag::SUCCESS;
}
}
+
+Flag::Error AllocatePrefetchDistanceConstraintFunc(intx value, bool verbose) {
+ if (value < 0) {
+ CommandLineError::print(verbose,
+ "Unable to determine system-specific value for AllocatePrefetchDistance. "
+ "Please provide appropriate value, if unsure, use 0 to disable prefetching\n");
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose) {
+ intx max_value = max_intx;
+#if defined(SPARC)
+ max_value = 1;
+#elif defined(X86)
+ max_value = 3;
+#endif
+ if (value < 0 || value > max_value) {
+ CommandLineError::print(verbose,
+ "AllocatePrefetchInstr (" INTX_FORMAT ") must be "
+ "between 0 and " INTX_FORMAT "\n", value, max_value);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose) {
+ if (value < 0 || value > max_jint) {
+ CommandLineError::print(verbose,
+ "AllocatePrefetchStepSize (" INTX_FORMAT ") "
+ "must be between 0 and %d\n",
+ AllocatePrefetchStepSize,
+ max_jint);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ if (AllocatePrefetchDistance % AllocatePrefetchStepSize != 0) {
+ CommandLineError::print(verbose,
+ "AllocatePrefetchDistance (" INTX_FORMAT ") "
+ "%% AllocatePrefetchStepSize (" INTX_FORMAT ") "
+ "= " INTX_FORMAT " "
+ "must be 0\n",
+ AllocatePrefetchDistance, AllocatePrefetchStepSize,
+ AllocatePrefetchDistance % AllocatePrefetchStepSize);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error CompileThresholdConstraintFunc(intx value, bool verbose) {
+ if (value < 0 || value > INT_MAX >> InvocationCounter::count_shift) {
+ CommandLineError::print(verbose,
+ "CompileThreshold (" INTX_FORMAT ") "
+ "must be between 0 and %d\n",
+ value,
+ INT_MAX >> InvocationCounter::count_shift);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error OnStackReplacePercentageConstraintFunc(intx value, bool verbose) {
+ int backward_branch_limit;
+ if (ProfileInterpreter) {
+ if (OnStackReplacePercentage < InterpreterProfilePercentage) {
+ CommandLineError::print(verbose,
+ "OnStackReplacePercentage (" INTX_FORMAT ") must be "
+ "larger than InterpreterProfilePercentage (" INTX_FORMAT ")\n",
+ OnStackReplacePercentage, InterpreterProfilePercentage);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ backward_branch_limit = ((CompileThreshold * (OnStackReplacePercentage - InterpreterProfilePercentage)) / 100)
+ << InvocationCounter::count_shift;
+
+ if (backward_branch_limit < 0) {
+ CommandLineError::print(verbose,
+ "CompileThreshold * (InterpreterProfilePercentage - OnStackReplacePercentage) / 100 = "
+ INTX_FORMAT " "
+ "must be between 0 and " INTX_FORMAT ", try changing "
+ "CompileThreshold, InterpreterProfilePercentage, and/or OnStackReplacePercentage\n",
+ (CompileThreshold * (OnStackReplacePercentage - InterpreterProfilePercentage)) / 100,
+ INT_MAX >> InvocationCounter::count_shift);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+ } else {
+ if (OnStackReplacePercentage < 0 ) {
+ CommandLineError::print(verbose,
+ "OnStackReplacePercentage (" INTX_FORMAT ") must be "
+ "non-negative\n", OnStackReplacePercentage);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ backward_branch_limit = ((CompileThreshold * OnStackReplacePercentage) / 100)
+ << InvocationCounter::count_shift;
+
+ if (backward_branch_limit < 0) {
+ CommandLineError::print(verbose,
+ "CompileThreshold * OnStackReplacePercentage / 100 = " INTX_FORMAT " "
+ "must be between 0 and " INTX_FORMAT ", try changing "
+ "CompileThreshold and/or OnStackReplacePercentage\n",
+ (CompileThreshold * OnStackReplacePercentage) / 100,
+ INT_MAX >> InvocationCounter::count_shift);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+ }
+ return Flag::SUCCESS;
+}
+
+Flag::Error CodeCacheSegmentSizeConstraintFunc(uintx value, bool verbose) {
+ if (CodeCacheSegmentSize < (uintx)CodeEntryAlignment) {
+ CommandLineError::print(verbose,
+ "CodeCacheSegmentSize (" UINTX_FORMAT ") must be "
+ "larger than or equal to CodeEntryAlignment (" INTX_FORMAT ")"
+ "to align entry points\n",
+ CodeCacheSegmentSize, CodeEntryAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ if (CodeCacheSegmentSize < sizeof(jdouble)) {
+ CommandLineError::print(verbose,
+ "CodeCacheSegmentSize (" UINTX_FORMAT ") must be "
+ "at least " SIZE_FORMAT " to align constants\n",
+ CodeCacheSegmentSize, sizeof(jdouble));
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+#ifdef COMPILER2
+ if (CodeCacheSegmentSize < (uintx)OptoLoopAlignment) {
+ CommandLineError::print(verbose,
+ "CodeCacheSegmentSize (" UINTX_FORMAT ") must be "
+ "larger than or equal to OptoLoopAlignment (" INTX_FORMAT ")"
+ "to align inner loops\n",
+ CodeCacheSegmentSize, OptoLoopAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+#endif
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose) {
+ if (value < min_jint || value > max_jint) {
+ CommandLineError::print(verbose,
+ "CompileThreadPriority (" INTX_FORMAT ") "
+ "must be between %d and %d. "
+ "Please also make sure to specify values that are "
+ "meaningful to your operating system\n",
+ value, min_jint, max_jint);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose) {
+#ifdef SPARC
+ if (CodeEntryAlignment % relocInfo::addr_unit() != 0) {
+ CommandLineError::print(verbose,
+ "CodeEntryAlignment (" INTX_FORMAT ") must be "
+ "multiple of NOP size\n", CodeEntryAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+#endif
+
+ if (!is_power_of_2(value)) {
+ CommandLineError::print(verbose,
+ "CodeEntryAlignment (" INTX_FORMAT ") must be "
+ "a power of two\n", CodeEntryAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ if (CodeEntryAlignment < 16) {
+ CommandLineError::print(verbose,
+ "CodeEntryAlignment (" INTX_FORMAT ") must be "
+ "greater than or equal to %d\n",
+ CodeEntryAlignment, 16);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose) {
+ if (value < 0 || value > 16) {
+ CommandLineError::print(verbose,
+ "OptoLoopAlignment (" INTX_FORMAT ") "
+ "must be between 0 and 16\n",
+ value);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ if (!is_power_of_2(value)) {
+ CommandLineError::print(verbose,
+ "OptoLoopAlignment (" INTX_FORMAT ") "
+ "must be a power of two\n",
+ value);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+#ifdef SPARC
+ if (OptoLoopAlignment % relocInfo::addr_unit() != 0) {
+ CommandLineError::print(verbose,
+ "OptoLoopAlignment (" INTX_FORMAT ") must be "
+ "multiple of NOP size\n");
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+#endif
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose) {
+ if (value != 0) {
+ CommandLineError::print(verbose,
+ "ArraycopyDstPrefetchDistance (" INTX_FORMAT ") must be 0\n");
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error ArraycopySrcPrefetchDistanceConstraintFunc(uintx value, bool verbose) {
+ if (value != 0) {
+ CommandLineError::print(verbose,
+ "ArraycopySrcPrefetchDistance (" INTX_FORMAT ") must be 0\n");
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error TypeProfileLevelConstraintFunc(uintx value, bool verbose) {
+ for (int i = 0; i < 3; i++) {
+ if (value % 10 > 2) {
+ CommandLineError::print(verbose,
+ "Invalid value (" UINTX_FORMAT ") "
+ "in TypeProfileLevel at position %d\n", value, i);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+ value = value / 10;
+ }
+
+ return Flag::SUCCESS;
+}
+
+#ifdef COMPILER2
+Flag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose) {
+ if (InteriorEntryAlignment > CodeEntryAlignment) {
+ CommandLineError::print(verbose,
+ "InteriorEntryAlignment (" INTX_FORMAT ") must be "
+ "less than or equal to CodeEntryAlignment (" INTX_FORMAT ")\n",
+ InteriorEntryAlignment, CodeEntryAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+#ifdef SPARC
+ if (InteriorEntryAlignment % relocInfo::addr_unit() != 0) {
+ CommandLineError::print(verbose,
+ "InteriorEntryAlignment (" INTX_FORMAT ") must be "
+ "multiple of NOP size\n");
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+#endif
+
+ if (!is_power_of_2(value)) {
+ CommandLineError::print(verbose,
+ "InteriorEntryAlignment (" INTX_FORMAT ") must be "
+ "a power of two\n", InteriorEntryAlignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ int minimum_alignment = 16;
+#if defined(SPARC) || (defined(X86) && !defined(AMD64))
+ minimum_alignment = 4;
+#endif
+
+ if (InteriorEntryAlignment < minimum_alignment) {
+ CommandLineError::print(verbose,
+ "InteriorEntryAlignment (" INTX_FORMAT ") must be "
+ "greater than or equal to %d\n",
+ InteriorEntryAlignment, minimum_alignment);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+
+Flag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose) {
+ if (value < MaxNodeLimit * 2 / 100 || value > MaxNodeLimit * 40 / 100) {
+ CommandLineError::print(verbose,
+ "NodeLimitFudgeFactor must be between 2%% and 40%% "
+ "of MaxNodeLimit (" INTX_FORMAT ")\n",
+ MaxNodeLimit);
+ return Flag::VIOLATES_CONSTRAINT;
+ }
+
+ return Flag::SUCCESS;
+}
+#endif // COMPILER2
--- a/hotspot/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -38,4 +38,34 @@
Flag::Error CICompilerCountConstraintFunc(intx value, bool verbose);
+Flag::Error AllocatePrefetchDistanceConstraintFunc(intx value, bool verbose);
+
+Flag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose);
+
+Flag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose);
+
+Flag::Error CompileThresholdConstraintFunc(intx value, bool verbose);
+
+Flag::Error OnStackReplacePercentageConstraintFunc(intx value, bool verbose);
+
+Flag::Error CodeCacheSegmentSizeConstraintFunc(uintx value, bool verbose);
+
+Flag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose);
+
+Flag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose);
+
+Flag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose);
+
+Flag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose);
+
+Flag::Error ArraycopySrcPrefetchDistanceConstraintFunc(uintx value, bool verbose);
+
+Flag::Error TypeProfileLevelConstraintFunc(uintx value, bool verbose);
+
+#ifdef COMPILER2
+Flag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose);
+
+Flag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose);
+#endif
+
#endif /* SHARE_VM_RUNTIME_COMMANDLINEFLAGCONSTRAINTSCOMPILER_HPP */
--- a/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 09 14:21:26 2015 +0200
@@ -25,6 +25,7 @@
#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
#define SHARE_VM_RUNTIME_GLOBALS_HPP
+#include <float.h>
#include "utilities/debug.hpp"
// use this for flags that are true per default in the tiered build
@@ -528,7 +529,7 @@
// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version
// A flag must be declared with one of the following types:
-// bool, intx, uintx, size_t, ccstr, double, or uint64_t.
+// bool, int, uint, intx, uintx, size_t, ccstr, double, or uint64_t.
// The type "ccstr" is an alias for "const char*" and is used
// only in this file, because the macrology requires single-token type names.
@@ -701,6 +702,7 @@
\
product(intx, UseSSE, 99, \
"Highest supported SSE instructions set on x86/x64") \
+ range(0, 99) \
\
product(bool, UseAES, false, \
"Control whether AES instructions can be used on x86/x64") \
@@ -1255,6 +1257,7 @@
"Control emission of inline sync fast-path code") \
\
product(intx, MonitorBound, 0, "Bound Monitor population") \
+ range(0, max_jint) \
\
product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
\
@@ -2712,6 +2715,7 @@
diagnostic(intx, HotMethodDetectionLimit, 100000, \
"Number of compiled code invocations after which " \
"the method is considered as hot by the flusher") \
+ range(1, max_jint) \
\
diagnostic(intx, MinPassesBeforeFlush, 10, \
"Minimum number of sweeper passes before an nmethod " \
@@ -2870,13 +2874,16 @@
"Y: Type profiling of return value at call; " \
"X: Type profiling of parameters to methods; " \
"X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods") \
+ constraint(TypeProfileLevelConstraintFunc, AfterErgo) \
\
product(intx, TypeProfileArgsLimit, 2, \
"max number of call arguments to consider for type profiling") \
+ range(0, 16) \
\
product(intx, TypeProfileParmsLimit, 2, \
"max number of incoming parameters to consider for type profiling"\
", -1 for all") \
+ range(-1, 64) \
\
/* statistics */ \
develop(bool, CountCompiledCalls, false, \
@@ -3035,13 +3042,17 @@
"Analyze bytecodes to estimate escape state of arguments") \
\
product(intx, BCEATraceLevel, 0, \
- "How much tracing to do of bytecode escape analysis estimates") \
+ "How much tracing to do of bytecode escape analysis estimates " \
+ "(0-3)") \
+ range(0, 3) \
\
product(intx, MaxBCEAEstimateLevel, 5, \
"Maximum number of nested calls that are analyzed by BC EA") \
+ range(0, max_jint) \
\
product(intx, MaxBCEAEstimateSize, 150, \
"Maximum bytecode size of a method to be analyzed by BC EA") \
+ range(0, max_jint) \
\
product(intx, AllocatePrefetchStyle, 1, \
"0 = no prefetch, " \
@@ -3051,20 +3062,26 @@
range(0, 3) \
\
product(intx, AllocatePrefetchDistance, -1, \
- "Distance to prefetch ahead of allocation pointer") \
+ "Distance to prefetch ahead of allocation pointer. " \
+ "-1: use system-specific value (automatically determined") \
+ constraint(AllocatePrefetchDistanceConstraintFunc, AfterMemoryInit)\
\
product(intx, AllocatePrefetchLines, 3, \
"Number of lines to prefetch ahead of array allocation pointer") \
+ range(1, max_jint / 2) \
\
product(intx, AllocateInstancePrefetchLines, 1, \
"Number of lines to prefetch ahead of instance allocation " \
"pointer") \
+ range(1, max_jint / 2) \
\
product(intx, AllocatePrefetchStepSize, 16, \
"Step size in bytes of sequential prefetch instructions") \
+ constraint(AllocatePrefetchStepSizeConstraintFunc,AfterMemoryInit)\
\
product(intx, AllocatePrefetchInstr, 0, \
"Prefetch instruction to prefetch ahead of allocation pointer") \
+ constraint(AllocatePrefetchInstrConstraintFunc, AfterErgo) \
\
/* deoptimization */ \
develop(bool, TraceDeoptimization, false, \
@@ -3134,30 +3151,38 @@
\
product(intx, MaxInlineLevel, 9, \
"maximum number of nested calls that are inlined") \
+ range(0, max_jint) \
\
product(intx, MaxRecursiveInlineLevel, 1, \
"maximum number of nested recursive calls that are inlined") \
+ range(0, max_jint) \
\
develop(intx, MaxForceInlineLevel, 100, \
"maximum number of nested calls that are forced for inlining " \
"(using CompileCommand or marked w/ @ForceInline)") \
+ range(0, max_jint) \
\
product_pd(intx, InlineSmallCode, \
"Only inline already compiled methods if their code size is " \
"less than this") \
+ range(0, max_jint) \
\
product(intx, MaxInlineSize, 35, \
"The maximum bytecode size of a method to be inlined") \
+ range(0, max_jint) \
\
product_pd(intx, FreqInlineSize, \
"The maximum bytecode size of a frequent method to be inlined") \
+ range(0, max_jint) \
\
product(intx, MaxTrivialSize, 6, \
"The maximum bytecode size of a trivial method to be inlined") \
+ range(0, max_jint) \
\
product(intx, MinInliningThreshold, 250, \
"The minimum invocation count a method needs to have to be " \
"inlined") \
+ range(0, max_jint) \
\
develop(intx, MethodHistogramCutoff, 100, \
"The cutoff value for method invocation histogram (+CountCalls)") \
@@ -3221,6 +3246,7 @@
\
product(intx, TypeProfileWidth, 2, \
"Number of receiver types to record in call/cast profile") \
+ range(0, 4) \
\
experimental(intx, MethodProfileWidth, 0, \
"Number of methods to record in call profile") \
@@ -3238,32 +3264,40 @@
\
product(intx, PerMethodTrapLimit, 100, \
"Limit on traps (of one kind) in a method (includes inlines)") \
+ range(0, max_jint) \
\
experimental(intx, PerMethodSpecTrapLimit, 5000, \
"Limit on speculative traps (of one kind) in a method " \
"(includes inlines)") \
+ range(0, max_jint) \
\
product(intx, PerBytecodeTrapLimit, 4, \
"Limit on traps (of one kind) at a particular BCI") \
+ range(0, max_jint) \
\
experimental(intx, SpecTrapLimitExtraEntries, 3, \
"Extra method data trap entries for speculation") \
\
develop(intx, InlineFrequencyRatio, 20, \
"Ratio of call site execution to caller method invocation") \
+ range(0, max_jint) \
\
develop_pd(intx, InlineFrequencyCount, \
"Count of call site execution necessary to trigger frequent " \
"inlining") \
+ range(0, max_jint) \
\
develop(intx, InlineThrowCount, 50, \
"Force inlining of interpreted methods that throw this often") \
+ range(0, max_jint) \
\
develop(intx, InlineThrowMaxSize, 200, \
"Force inlining of throwing methods smaller than this") \
+ range(0, max_jint) \
\
develop(intx, ProfilerNodeSize, 1024, \
"Size in K to allocate for the Profile Nodes of each thread") \
+ range(0, 1024) \
\
/* gc parameters */ \
product(size_t, InitialHeapSize, 0, \
@@ -3467,6 +3501,7 @@
\
product_pd(intx, CompilerThreadStackSize, \
"Compiler Thread Stack Size (in Kbytes)") \
+ range(0, max_intx) \
\
develop_pd(size_t, JVMInvokeMethodSlack, \
"Stack space (bytes) required for JVM_InvokeMethod to complete") \
@@ -3477,36 +3512,46 @@
"Code cache segment size (in bytes) - smallest unit of " \
"allocation") \
range(1, 1024) \
+ constraint(CodeCacheSegmentSizeConstraintFunc, AfterErgo) \
\
develop_pd(intx, CodeEntryAlignment, \
"Code entry alignment for generated code (in bytes)") \
+ constraint(CodeEntryAlignmentConstraintFunc, AfterErgo) \
\
product_pd(intx, OptoLoopAlignment, \
"Align inner loops to zero relative to this modulus") \
+ constraint(OptoLoopAlignmentConstraintFunc, AfterErgo) \
\
product_pd(uintx, InitialCodeCacheSize, \
"Initial code cache size (in bytes)") \
+ range(0, max_uintx) \
\
develop_pd(uintx, CodeCacheMinimumUseSpace, \
"Minimum code cache size (in bytes) required to start VM.") \
+ range(0, max_uintx) \
\
product(bool, SegmentedCodeCache, false, \
"Use a segmented code cache") \
\
product_pd(uintx, ReservedCodeCacheSize, \
"Reserved code cache size (in bytes) - maximum code cache size") \
+ range(0, max_uintx) \
\
product_pd(uintx, NonProfiledCodeHeapSize, \
"Size of code heap with non-profiled methods (in bytes)") \
+ range(0, max_uintx) \
\
product_pd(uintx, ProfiledCodeHeapSize, \
"Size of code heap with profiled methods (in bytes)") \
+ range(0, max_uintx) \
\
product_pd(uintx, NonNMethodCodeHeapSize, \
"Size of code heap with non-nmethods (in bytes)") \
+ range(0, max_uintx) \
\
product_pd(uintx, CodeCacheExpansionSize, \
"Code cache expansion size (in bytes)") \
+ range(0, max_uintx) \
\
develop_pd(uintx, CodeCacheMinBlockLength, \
"Minimum number of segments in a code cache block") \
@@ -3636,6 +3681,7 @@
product(intx, CompilerThreadPriority, -1, \
"The native priority at which compiler threads should run " \
"(-1 means no change)") \
+ constraint(CompilerThreadPriorityConstraintFunc, AfterErgo) \
\
product(intx, VMThreadPriority, -1, \
"The native priority at which the VM thread should run " \
@@ -3708,6 +3754,7 @@
/* recompilation */ \
product_pd(intx, CompileThreshold, \
"number of interpreted method invocations before (re-)compiling") \
+ constraint(CompileThresholdConstraintFunc, AfterErgo) \
\
product(double, CompileThresholdScaling, 1.0, \
"Factor to control when first compilation happens " \
@@ -3721,90 +3768,115 @@
"If a value is specified for a method, compilation thresholds " \
"for that method are scaled by both the value of the global flag "\
"and the value of the per-method flag.") \
+ range(0.0, DBL_MAX) \
\
product(intx, Tier0InvokeNotifyFreqLog, 7, \
"Interpreter (tier 0) invocation notification frequency") \
+ range(0, 30) \
\
product(intx, Tier2InvokeNotifyFreqLog, 11, \
"C1 without MDO (tier 2) invocation notification frequency") \
+ range(0, 30) \
\
product(intx, Tier3InvokeNotifyFreqLog, 10, \
"C1 with MDO profiling (tier 3) invocation notification " \
"frequency") \
+ range(0, 30) \
\
product(intx, Tier23InlineeNotifyFreqLog, 20, \
"Inlinee invocation (tiers 2 and 3) notification frequency") \
+ range(0, 30) \
\
product(intx, Tier0BackedgeNotifyFreqLog, 10, \
"Interpreter (tier 0) invocation notification frequency") \
+ range(0, 30) \
\
product(intx, Tier2BackedgeNotifyFreqLog, 14, \
"C1 without MDO (tier 2) invocation notification frequency") \
+ range(0, 30) \
\
product(intx, Tier3BackedgeNotifyFreqLog, 13, \
"C1 with MDO profiling (tier 3) invocation notification " \
"frequency") \
+ range(0, 30) \
\
product(intx, Tier2CompileThreshold, 0, \
"threshold at which tier 2 compilation is invoked") \
+ range(0, max_jint) \
\
product(intx, Tier2BackEdgeThreshold, 0, \
"Back edge threshold at which tier 2 compilation is invoked") \
+ range(0, max_jint) \
\
product(intx, Tier3InvocationThreshold, 200, \
"Compile if number of method invocations crosses this " \
"threshold") \
+ range(0, max_jint) \
\
product(intx, Tier3MinInvocationThreshold, 100, \
"Minimum invocation to compile at tier 3") \
+ range(0, max_jint) \
\
product(intx, Tier3CompileThreshold, 2000, \
"Threshold at which tier 3 compilation is invoked (invocation " \
"minimum must be satisfied)") \
+ range(0, max_jint) \
\
product(intx, Tier3BackEdgeThreshold, 60000, \
"Back edge threshold at which tier 3 OSR compilation is invoked") \
+ range(0, max_jint) \
\
product(intx, Tier4InvocationThreshold, 5000, \
"Compile if number of method invocations crosses this " \
"threshold") \
+ range(0, max_jint) \
\
product(intx, Tier4MinInvocationThreshold, 600, \
"Minimum invocation to compile at tier 4") \
+ range(0, max_jint) \
\
product(intx, Tier4CompileThreshold, 15000, \
"Threshold at which tier 4 compilation is invoked (invocation " \
"minimum must be satisfied") \
+ range(0, max_jint) \
\
product(intx, Tier4BackEdgeThreshold, 40000, \
"Back edge threshold at which tier 4 OSR compilation is invoked") \
+ range(0, max_jint) \
\
product(intx, Tier3DelayOn, 5, \
"If C2 queue size grows over this amount per compiler thread " \
"stop compiling at tier 3 and start compiling at tier 2") \
+ range(0, max_jint) \
\
product(intx, Tier3DelayOff, 2, \
"If C2 queue size is less than this amount per compiler thread " \
"allow methods compiled at tier 2 transition to tier 3") \
+ range(0, max_jint) \
\
product(intx, Tier3LoadFeedback, 5, \
"Tier 3 thresholds will increase twofold when C1 queue size " \
"reaches this amount per compiler thread") \
+ range(0, max_jint) \
\
product(intx, Tier4LoadFeedback, 3, \
"Tier 4 thresholds will increase twofold when C2 queue size " \
"reaches this amount per compiler thread") \
+ range(0, max_jint) \
\
product(intx, TieredCompileTaskTimeout, 50, \
"Kill compile task if method was not used within " \
"given timeout in milliseconds") \
+ range(0, max_intx) \
\
product(intx, TieredStopAtLevel, 4, \
"Stop at given compilation level") \
+ range(0, 4) \
\
product(intx, Tier0ProfilingStartPercentage, 200, \
"Start profiling in interpreter if the counters exceed tier 3 " \
"thresholds by the specified percentage") \
+ range(0, max_jint) \
\
product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \
"Increase the compile threshold for C1 compilation if the code " \
@@ -3813,9 +3885,11 @@
\
product(intx, TieredRateUpdateMinTime, 1, \
"Minimum rate sampling interval (in milliseconds)") \
+ range(0, max_intx) \
\
product(intx, TieredRateUpdateMaxTime, 25, \
"Maximum rate sampling interval (in milliseconds)") \
+ range(0, max_intx) \
\
product_pd(bool, TieredCompilation, \
"Enable tiered compilation") \
@@ -3826,6 +3900,7 @@
product_pd(intx, OnStackReplacePercentage, \
"NON_TIERED number of method invocations/branches (expressed as " \
"% of CompileThreshold) before (re-)compiling OSR code") \
+ constraint(OnStackReplacePercentageConstraintFunc, AfterErgo) \
\
product(intx, InterpreterProfilePercentage, 33, \
"NON_TIERED number of method invocations/branches (expressed as " \
--- a/hotspot/test/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/test/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java Fri Oct 09 14:21:26 2015 +0200
@@ -51,6 +51,24 @@
*/
allOptionsAsMap.remove("CICompilerCount");
+ /*
+ * Remove parameters controlling the code cache. As these
+ * parameters have implications on the physical memory
+ * reserved by the VM, setting them to large values may hang
+ * the system and/or may cause concurrently executed tests to
+ * fail. These parameters are rigorously checked when the code
+ * cache is initialized (see
+ * hotspot/src/shared/vm/code/codeCache.cpp), therefore
+ * omitting testing for them does not pose a problem.
+ */
+ allOptionsAsMap.remove("InitialCodeCacheSize");
+ allOptionsAsMap.remove("CodeCacheMinimumUseSpace");
+ allOptionsAsMap.remove("ReservedCodeCacheSize");
+ allOptionsAsMap.remove("NonProfiledCodeHeapSize");
+ allOptionsAsMap.remove("ProfiledCodeHeapSize");
+ allOptionsAsMap.remove("NonNMethodCodeHeapSize");
+ allOptionsAsMap.remove("CodeCacheExpansionSize");
+
allOptions = new ArrayList<>(allOptionsAsMap.values());
Asserts.assertGT(allOptions.size(), 0, "Options with ranges not found!");
--- a/hotspot/test/testlibrary_tests/whitebox/vm_flags/DoubleTest.java Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/test/testlibrary_tests/whitebox/vm_flags/DoubleTest.java Fri Oct 09 14:21:26 2015 +0200
@@ -36,9 +36,7 @@
public class DoubleTest {
private static final String FLAG_NAME = "CompileThresholdScaling";
- private static final Double[] TESTS = {0d, -0d, -1d, 1d,
- Double.MAX_VALUE, Double.MIN_VALUE, Double.NaN,
- Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY};
+ private static final Double[] TESTS = {0d, -0d, 1d, Double.MAX_VALUE};
public static void main(String[] args) throws Exception {
VmFlagTest.runTest(FLAG_NAME, TESTS,
--- a/hotspot/test/testlibrary_tests/whitebox/vm_flags/IntxTest.java Fri Oct 09 11:28:11 2015 +0200
+++ b/hotspot/test/testlibrary_tests/whitebox/vm_flags/IntxTest.java Fri Oct 09 14:21:26 2015 +0200
@@ -29,7 +29,7 @@
* @build IntxTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
- * @run main/othervm/timeout=600 -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI IntxTest
+ * @run main/othervm/timeout=600 -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-ProfileInterpreter IntxTest
* @summary testing of WB::set/getIntxVMFlag()
* @author igor.ignatyev@oracle.com
*/
@@ -37,8 +37,7 @@
public class IntxTest {
private static final String FLAG_NAME = "OnStackReplacePercentage";
private static final String FLAG_DEBUG_NAME = "InlineFrequencyCount";
- private static final Long[] TESTS = {0L, 100L, -1L,
- (long) Integer.MAX_VALUE, (long) Integer.MIN_VALUE};
+ private static final Long[] TESTS = {0L, 100L, (long) Integer.MAX_VALUE};
public static void main(String[] args) throws Exception {
VmFlagTest.runTest(FLAG_NAME, TESTS,