--- old/src/cpu/sparc/vm/globals_sparc.hpp 2015-10-08 14:04:12.301644783 +0200 +++ new/src/cpu/sparc/vm/globals_sparc.hpp 2015-10-08 14:04:12.085644774 +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 --- old/src/cpu/sparc/vm/vm_version_sparc.cpp 2015-10-08 14:04:12.277644782 +0200 +++ new/src/cpu/sparc/vm/vm_version_sparc.cpp 2015-10-08 14:04:12.073644773 +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(); --- old/src/share/vm/opto/parse3.cpp 2015-10-08 14:04:12.241644780 +0200 +++ new/src/share/vm/opto/parse3.cpp 2015-10-08 14:04:12.053644773 +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++) { --- old/src/cpu/x86/vm/vm_version_x86.cpp 2015-10-08 14:04:12.385644787 +0200 +++ new/src/cpu/x86/vm/vm_version_x86.cpp 2015-10-08 14:04:12.085644774 +0200 @@ -1088,11 +1088,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; @@ -1131,7 +1126,6 @@ } #endif } - assert(AllocatePrefetchDistance % AllocatePrefetchStepSize == 0, "invalid value"); #ifdef _LP64 // Prefetch settings --- old/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp 2015-10-08 14:04:12.433644789 +0200 +++ new/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp 2015-10-08 14:04:12.261644781 +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 */ --- old/test/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java 2015-10-08 14:04:12.441644789 +0200 +++ new/test/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java 2015-10-08 14:04:12.081644774 +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!"); --- old/src/share/vm/oops/methodCounters.hpp 2015-10-08 14:04:12.433644789 +0200 +++ new/src/share/vm/oops/methodCounters.hpp 2015-10-08 14:04:12.109644775 +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 --- old/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp 2015-10-08 14:04:12.437644789 +0200 +++ new/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp 2015-10-08 14:04:12.081644774 +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 --- old/src/cpu/x86/vm/globals_x86.hpp 2015-10-08 14:04:12.461644790 +0200 +++ new/src/cpu/x86/vm/globals_x86.hpp 2015-10-08 14:04:12.173644778 +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") \ --- old/src/share/vm/c1/c1_globals.hpp 2015-10-08 14:04:12.429644788 +0200 +++ new/src/share/vm/c1/c1_globals.hpp 2015-10-08 14:04:12.141644776 +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)") \ --- old/src/share/vm/runtime/globals.hpp 2015-10-08 14:04:12.449644789 +0200 +++ new/src/share/vm/runtime/globals.hpp 2015-10-08 14:04:12.085644774 +0200 @@ -25,6 +25,7 @@ #ifndef SHARE_VM_RUNTIME_GLOBALS_HPP #define SHARE_VM_RUNTIME_GLOBALS_HPP +#include #include "utilities/debug.hpp" // use this for flags that are true per default in the tiered build @@ -527,7 +528,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. @@ -700,6 +701,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") \ @@ -1248,6 +1250,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") \ \ @@ -2705,6 +2708,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 " \ @@ -2863,13 +2867,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, \ @@ -3028,13 +3035,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, " \ @@ -3044,20 +3055,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, \ @@ -3124,30 +3141,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)") \ @@ -3211,6 +3236,7 @@ \ product(intx, TypeProfileWidth, 2, \ "Number of receiver types to record in call/cast profile") \ + range(0, 4) \ \ develop(intx, BciProfileWidth, 2, \ "Number of return bci's to record in ret profile") \ @@ -3225,32 +3251,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, \ @@ -3454,6 +3488,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") \ @@ -3464,36 +3499,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") \ @@ -3623,6 +3668,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 " \ @@ -3695,6 +3741,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 " \ @@ -3708,90 +3755,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 " \ @@ -3800,9 +3872,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") \ @@ -3813,6 +3887,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 " \ --- old/src/share/vm/opto/c2_globals.hpp 2015-10-08 14:04:12.429644788 +0200 +++ new/src/share/vm/opto/c2_globals.hpp 2015-10-08 14:04:12.077644774 +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") --- old/test/testlibrary_tests/whitebox/vm_flags/DoubleTest.java 2015-10-08 14:04:12.717644800 +0200 +++ new/test/testlibrary_tests/whitebox/vm_flags/DoubleTest.java 2015-10-08 14:04:12.653644798 +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, --- old/test/testlibrary_tests/whitebox/vm_flags/IntxTest.java 2015-10-08 14:04:13.905644850 +0200 +++ new/test/testlibrary_tests/whitebox/vm_flags/IntxTest.java 2015-10-08 14:04:13.837644848 +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,