archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-18 18:14:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8243208: Clean up JVMFlag implementation

Browse source 
Reviewed-by: dholmes, coleenp, gziemski
This commit is contained in:
Ioi Lam 2020-09-11 04:05:18 +00:00
parent 976acddeb5
commit 5144190ea0
45 changed files with 1586 additions and 1364 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/hotspot/cpu/aarch64/globals_aarch64.hpp
View file

@ -77,8 +77,6 @@ define_pd_global(intx, InlineSmallCode, 1000);
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -113,4 +111,6 @@ define_pd_global(intx, InlineSmallCode, 1000);
"Value -1 means off.") \ "Value -1 means off.") \
range(-1, 4096) range(-1, 4096)
// end of ARCH_FLAGS
#endif // CPU_AARCH64_GLOBALS_AARCH64_HPP #endif // CPU_AARCH64_GLOBALS_AARCH64_HPP

5
src/hotspot/cpu/arm/globals_arm.hpp
View file

@ -72,9 +72,10 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) constraint)
// end of ARCH_FLAGS
#endif // CPU_ARM_GLOBALS_ARM_HPP #endif // CPU_ARM_GLOBALS_ARM_HPP

22
src/hotspot/cpu/ppc/globals_ppc.hpp
View file

@ -77,8 +77,6 @@ define_pd_global(intx, InitArrayShortSize, 9*BytesPerLong);
// Platform dependent flag handling: flags only defined on this platform. // Platform dependent flag handling: flags only defined on this platform.
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -161,7 +159,7 @@ define_pd_global(intx, InitArrayShortSize, 9*BytesPerLong);
product(bool, UseRTMLocking, false, \ product(bool, UseRTMLocking, false, \
"Enable RTM lock eliding for inflated locks in compiled code") \ "Enable RTM lock eliding for inflated locks in compiled code") \
\ \
experimental(bool, UseRTMForStackLocks, false, \ product(bool, UseRTMForStackLocks, false, EXPERIMENTAL, \
"Enable RTM lock eliding for stack locks in compiled code") \ "Enable RTM lock eliding for stack locks in compiled code") \
\ \
product(bool, UseRTMDeopt, false, \ product(bool, UseRTMDeopt, false, \
@ -171,33 +169,35 @@ define_pd_global(intx, InitArrayShortSize, 9*BytesPerLong);
"Number of RTM retries on lock abort or busy") \ "Number of RTM retries on lock abort or busy") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMSpinLoopCount, 100, \ product(int, RTMSpinLoopCount, 100, EXPERIMENTAL, \
"Spin count for lock to become free before RTM retry") \ "Spin count for lock to become free before RTM retry") \
range(0, 32767) /* immediate operand limit on ppc */ \ range(0, 32767) /* immediate operand limit on ppc */ \
\ \
experimental(int, RTMAbortThreshold, 1000, \ product(int, RTMAbortThreshold, 1000, EXPERIMENTAL, \
"Calculate abort ratio after this number of aborts") \ "Calculate abort ratio after this number of aborts") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMLockingThreshold, 10000, \ product(int, RTMLockingThreshold, 10000, EXPERIMENTAL, \
"Lock count at which to do RTM lock eliding without " \ "Lock count at which to do RTM lock eliding without " \
"abort ratio calculation") \ "abort ratio calculation") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMAbortRatio, 50, \ product(int, RTMAbortRatio, 50, EXPERIMENTAL, \
"Lock abort ratio at which to stop use RTM lock eliding") \ "Lock abort ratio at which to stop use RTM lock eliding") \
range(0, 100) /* natural range */ \ range(0, 100) /* natural range */ \
\ \
experimental(int, RTMTotalCountIncrRate, 64, \ product(int, RTMTotalCountIncrRate, 64, EXPERIMENTAL, \
"Increment total RTM attempted lock count once every n times") \ "Increment total RTM attempted lock count once every n times") \
range(1, 32767) /* immediate operand limit on ppc */ \ range(1, 32767) /* immediate operand limit on ppc */ \
constraint(RTMTotalCountIncrRateConstraintFunc,AfterErgo) \ constraint(RTMTotalCountIncrRateConstraintFunc,AfterErgo) \
\ \
experimental(intx, RTMLockingCalculationDelay, 0, \ product(intx, RTMLockingCalculationDelay, 0, EXPERIMENTAL, \
"Number of milliseconds to wait before start calculating aborts " \ "Number of milliseconds to wait before start calculating aborts " \
"for RTM locking") \ "for RTM locking") \
\ \
experimental(bool, UseRTMXendForLockBusy, true, \ product(bool, UseRTMXendForLockBusy, true, EXPERIMENTAL, \
"Use RTM Xend instead of Xabort when lock busy") \ "Use RTM Xend instead of Xabort when lock busy")
// end of ARCH_FLAGS
#endif // CPU_PPC_GLOBALS_PPC_HPP #endif // CPU_PPC_GLOBALS_PPC_HPP

4
src/hotspot/cpu/s390/globals_s390.hpp
View file

@ -77,8 +77,6 @@ define_pd_global(intx, InitArrayShortSize, 1*BytesPerLong);
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -117,4 +115,6 @@ define_pd_global(intx, InitArrayShortSize, 1*BytesPerLong);
product(bool, TraceTraps, false, "Trace all traps the signal handler" \ product(bool, TraceTraps, false, "Trace all traps the signal handler" \
"handles.") "handles.")
// end of ARCH_FLAGS
#endif // CPU_S390_GLOBALS_S390_HPP #endif // CPU_S390_GLOBALS_S390_HPP

28
src/hotspot/cpu/x86/globals_x86.hpp
View file

@ -91,8 +91,6 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -114,7 +112,7 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
product(bool, UseCLMUL, false, \ product(bool, UseCLMUL, false, \
"Control whether CLMUL instructions can be used on x86/x64") \ "Control whether CLMUL instructions can be used on x86/x64") \
\ \
diagnostic(bool, UseIncDec, true, \ product(bool, UseIncDec, true, DIAGNOSTIC, \
"Use INC, DEC instructions on x86") \ "Use INC, DEC instructions on x86") \
\ \
product(bool, UseNewLongLShift, false, \ product(bool, UseNewLongLShift, false, \
@ -148,7 +146,7 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
product(bool, UseRTMLocking, false, \ product(bool, UseRTMLocking, false, \
"Enable RTM lock eliding for inflated locks in compiled code") \ "Enable RTM lock eliding for inflated locks in compiled code") \
\ \
experimental(bool, UseRTMForStackLocks, false, \ product(bool, UseRTMForStackLocks, false, EXPERIMENTAL, \
"Enable RTM lock eliding for stack locks in compiled code") \ "Enable RTM lock eliding for stack locks in compiled code") \
\ \
product(bool, UseRTMDeopt, false, \ product(bool, UseRTMDeopt, false, \
@ -158,33 +156,33 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
"Number of RTM retries on lock abort or busy") \ "Number of RTM retries on lock abort or busy") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMSpinLoopCount, 100, \ product(int, RTMSpinLoopCount, 100, EXPERIMENTAL, \
"Spin count for lock to become free before RTM retry") \ "Spin count for lock to become free before RTM retry") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMAbortThreshold, 1000, \ product(int, RTMAbortThreshold, 1000, EXPERIMENTAL, \
"Calculate abort ratio after this number of aborts") \ "Calculate abort ratio after this number of aborts") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMLockingThreshold, 10000, \ product(int, RTMLockingThreshold, 10000, EXPERIMENTAL, \
"Lock count at which to do RTM lock eliding without " \ "Lock count at which to do RTM lock eliding without " \
"abort ratio calculation") \ "abort ratio calculation") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(int, RTMAbortRatio, 50, \ product(int, RTMAbortRatio, 50, EXPERIMENTAL, \
"Lock abort ratio at which to stop use RTM lock eliding") \ "Lock abort ratio at which to stop use RTM lock eliding") \
range(0, 100) /* natural range */ \ range(0, 100) /* natural range */ \
\ \
experimental(int, RTMTotalCountIncrRate, 64, \ product(int, RTMTotalCountIncrRate, 64, EXPERIMENTAL, \
"Increment total RTM attempted lock count once every n times") \ "Increment total RTM attempted lock count once every n times") \
range(1, max_jint) \ range(1, max_jint) \
constraint(RTMTotalCountIncrRateConstraintFunc,AfterErgo) \ constraint(RTMTotalCountIncrRateConstraintFunc,AfterErgo) \
\ \
experimental(intx, RTMLockingCalculationDelay, 0, \ product(intx, RTMLockingCalculationDelay, 0, EXPERIMENTAL, \
"Number of milliseconds to wait before start calculating aborts " \ "Number of milliseconds to wait before start calculating aborts " \
"for RTM locking") \ "for RTM locking") \
\ \
experimental(bool, UseRTMXendForLockBusy, true, \ product(bool, UseRTMXendForLockBusy, true, EXPERIMENTAL, \
"Use RTM Xend instead of Xabort when lock busy") \ "Use RTM Xend instead of Xabort when lock busy") \
\ \
/* assembler */ \ /* assembler */ \
@ -203,21 +201,23 @@ define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
product(bool, UseBMI2Instructions, false, \ product(bool, UseBMI2Instructions, false, \
"Use BMI2 instructions") \ "Use BMI2 instructions") \
\ \
diagnostic(bool, UseLibmIntrinsic, true, \ product(bool, UseLibmIntrinsic, true, DIAGNOSTIC, \
"Use Libm Intrinsics") \ "Use Libm Intrinsics") \
\ \
/* Minimum array size in bytes to use AVX512 intrinsics */ \ /* Minimum array size in bytes to use AVX512 intrinsics */ \
/* for copy, inflate and fill which don't bail out early based on any */ \ /* for copy, inflate and fill which don't bail out early based on any */ \
/* condition. When this value is set to zero compare operations like */ \ /* condition. When this value is set to zero compare operations like */ \
/* compare, vectorizedMismatch, compress can also use AVX512 intrinsics.*/\ /* compare, vectorizedMismatch, compress can also use AVX512 intrinsics.*/\
diagnostic(int, AVX3Threshold, 4096, \ product(int, AVX3Threshold, 4096, DIAGNOSTIC, \
"Minimum array size in bytes to use AVX512 intrinsics" \ "Minimum array size in bytes to use AVX512 intrinsics" \
"for copy, inflate and fill. When this value is set as zero" \ "for copy, inflate and fill. When this value is set as zero" \
"compare operations can also use AVX512 intrinsics.") \ "compare operations can also use AVX512 intrinsics.") \
range(0, max_jint) \ range(0, max_jint) \
\ \
diagnostic(bool, IntelJccErratumMitigation, true, \ product(bool, IntelJccErratumMitigation, true, DIAGNOSTIC, \
"Turn off JVM mitigations related to Intel micro code " \ "Turn off JVM mitigations related to Intel micro code " \
"mitigations for the Intel JCC erratum") "mitigations for the Intel JCC erratum")
// end of ARCH_FLAGS
#endif // CPU_X86_GLOBALS_X86_HPP #endif // CPU_X86_GLOBALS_X86_HPP

7
src/hotspot/cpu/zero/globals_zero.hpp
View file

@ -75,8 +75,6 @@ define_pd_global(bool, CompactStrings, false);
#define ARCH_FLAGS(develop, \ #define ARCH_FLAGS(develop, \
product, \ product, \
diagnostic, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -85,7 +83,8 @@ define_pd_global(bool, CompactStrings, false);
"Use fast method entry code for empty methods") \ "Use fast method entry code for empty methods") \
\ \
product(bool, UseFastAccessorMethods, true, \ product(bool, UseFastAccessorMethods, true, \
"Use fast method entry code for accessor methods") \ "Use fast method entry code for accessor methods")
\
// end of ARCH_FLAGS
#endif // CPU_ZERO_GLOBALS_ZERO_HPP #endif // CPU_ZERO_GLOBALS_ZERO_HPP

8
src/hotspot/os/aix/globals_aix.hpp
View file

@ -27,15 +27,13 @@
#define OS_AIX_GLOBALS_AIX_HPP #define OS_AIX_GLOBALS_AIX_HPP
// //
// Defines Aix specific flags. They are not available on other platforms. // Declare Aix specific flags. They are not available on other platforms.
// //
// (Please keep the switches sorted alphabetically.) // (Please keep the switches sorted alphabetically.)
#define RUNTIME_OS_FLAGS(develop, \ #define RUNTIME_OS_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -77,9 +75,9 @@
/* explicit commit behaviour. This flag, if true, causes the VM to touch */ \ /* explicit commit behaviour. This flag, if true, causes the VM to touch */ \
/* memory on os::commit_memory() (which normally is a noop). */ \ /* memory on os::commit_memory() (which normally is a noop). */ \
product(bool, UseExplicitCommit, false, \ product(bool, UseExplicitCommit, false, \
"Explicit commit for virtual memory.") \ "Explicit commit for virtual memory.")
\
// end of RUNTIME_OS_FLAGS
// //
// Defines Aix-specific default values. The flags are available on all // Defines Aix-specific default values. The flags are available on all

6
src/hotspot/os/bsd/globals_bsd.hpp
View file

@ -26,18 +26,18 @@
#define OS_BSD_GLOBALS_BSD_HPP #define OS_BSD_GLOBALS_BSD_HPP
// //
// Defines Bsd specific flags. They are not available on other platforms. // Declare Bsd specific flags. They are not available on other platforms.
// //
#define RUNTIME_OS_FLAGS(develop, \ #define RUNTIME_OS_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) constraint)
// end of RUNTIME_OS_FLAGS
// //
// Defines Bsd-specific default values. The flags are available on all // Defines Bsd-specific default values. The flags are available on all
// platforms, but they may have different default values on other platforms. // platforms, but they may have different default values on other platforms.

12
src/hotspot/os/linux/globals_linux.hpp
View file

@ -26,14 +26,12 @@
#define OS_LINUX_GLOBALS_LINUX_HPP #define OS_LINUX_GLOBALS_LINUX_HPP
// //
// Defines Linux specific flags. They are not available on other platforms. // Declare Linux specific flags. They are not available on other platforms.
// //
#define RUNTIME_OS_FLAGS(develop, \ #define RUNTIME_OS_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -70,19 +68,21 @@
"Increase the thread stack size to include space for glibc " \ "Increase the thread stack size to include space for glibc " \
"static thread-local storage (TLS) if true") \ "static thread-local storage (TLS) if true") \
\ \
diagnostic(bool, DumpPrivateMappingsInCore, true, \ product(bool, DumpPrivateMappingsInCore, true, DIAGNOSTIC, \
"If true, sets bit 2 of /proc/PID/coredump_filter, thus " \ "If true, sets bit 2 of /proc/PID/coredump_filter, thus " \
"resulting in file-backed private mappings of the process to "\ "resulting in file-backed private mappings of the process to "\
"be dumped into the corefile.") \ "be dumped into the corefile.") \
\ \
diagnostic(bool, DumpSharedMappingsInCore, true, \ product(bool, DumpSharedMappingsInCore, true, DIAGNOSTIC, \
"If true, sets bit 3 of /proc/PID/coredump_filter, thus " \ "If true, sets bit 3 of /proc/PID/coredump_filter, thus " \
"resulting in file-backed shared mappings of the process to " \ "resulting in file-backed shared mappings of the process to " \
"be dumped into the corefile.") \ "be dumped into the corefile.") \
\ \
diagnostic(bool, UseCpuAllocPath, false, \ product(bool, UseCpuAllocPath, false, DIAGNOSTIC, \
"Use CPU_ALLOC code path in os::active_processor_count ") "Use CPU_ALLOC code path in os::active_processor_count ")
// end of RUNTIME_OS_FLAGS
// //
// Defines Linux-specific default values. The flags are available on all // Defines Linux-specific default values. The flags are available on all
// platforms, but they may have different default values on other platforms. // platforms, but they may have different default values on other platforms.

6
src/hotspot/os/windows/globals_windows.hpp
View file

@ -26,18 +26,18 @@
#define OS_WINDOWS_GLOBALS_WINDOWS_HPP #define OS_WINDOWS_GLOBALS_WINDOWS_HPP
// //
// Defines Windows specific flags. They are not available on other platforms. // Declare Windows specific flags. They are not available on other platforms.
// //
#define RUNTIME_OS_FLAGS(develop, \ #define RUNTIME_OS_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) constraint)
// end of RUNTIME_OS_FLAGS
// //
// Defines Windows-specific default values. The flags are available on all // Defines Windows-specific default values. The flags are available on all

11
src/hotspot/share/c1/c1_globals.hpp
View file

@ -32,14 +32,12 @@
#include OS_HEADER(c1_globals) #include OS_HEADER(c1_globals)
// //
// Defines all global flags used by the client compiler. // Declare all global flags used by the client compiler.
// //
#define C1_FLAGS(develop, \ #define C1_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -158,7 +156,7 @@
product(bool, InlineSynchronizedMethods, true, \ product(bool, InlineSynchronizedMethods, true, \
"Inline synchronized methods") \ "Inline synchronized methods") \
\ \
diagnostic(bool, InlineNIOCheckIndex, true, \ product(bool, InlineNIOCheckIndex, true, DIAGNOSTIC, \
"Intrinsify java.nio.Buffer.checkIndex") \ "Intrinsify java.nio.Buffer.checkIndex") \
\ \
develop(bool, CanonicalizeNodes, true, \ develop(bool, CanonicalizeNodes, true, \
@ -337,7 +335,8 @@
"Update MethodData*s in Tier1-generated code") \ "Update MethodData*s in Tier1-generated code") \
\ \
develop(bool, PrintCFGToFile, false, \ develop(bool, PrintCFGToFile, false, \
"print control flow graph to a separate file during compilation") \ "print control flow graph to a separate file during compilation")
\
// end of C1_FLAGS
#endif // SHARE_C1_C1_GLOBALS_HPP #endif // SHARE_C1_C1_GLOBALS_HPP

24
src/hotspot/share/gc/epsilon/epsilon_globals.hpp
View file

@ -36,62 +36,58 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
experimental(size_t, EpsilonPrintHeapSteps, 20, \ product(size_t, EpsilonPrintHeapSteps, 20, EXPERIMENTAL, \
"Print heap occupancy stats with this number of steps. " \ "Print heap occupancy stats with this number of steps. " \
"0 turns the printing off.") \ "0 turns the printing off.") \
range(0, max_intx) \ range(0, max_intx) \
\ \
experimental(size_t, EpsilonUpdateCountersStep, 1 * M, \ product(size_t, EpsilonUpdateCountersStep, 1 * M, EXPERIMENTAL, \
"Update heap occupancy counters after allocating this much " \ "Update heap occupancy counters after allocating this much " \
"memory. Higher values would make allocations faster at " \ "memory. Higher values would make allocations faster at " \
"the expense of lower resolution in heap counters.") \ "the expense of lower resolution in heap counters.") \
range(1, max_intx) \ range(1, max_intx) \
\ \
experimental(size_t, EpsilonMaxTLABSize, 4 * M, \ product(size_t, EpsilonMaxTLABSize, 4 * M, EXPERIMENTAL, \
"Max TLAB size to use with Epsilon GC. Larger value improves " \ "Max TLAB size to use with Epsilon GC. Larger value improves " \
"performance at the expense of per-thread memory waste. This " \ "performance at the expense of per-thread memory waste. This " \
"asks TLAB machinery to cap TLAB sizes at this value.") \ "asks TLAB machinery to cap TLAB sizes at this value.") \
range(1, max_intx) \ range(1, max_intx) \
\ \
experimental(bool, EpsilonElasticTLAB, true, \ product(bool, EpsilonElasticTLAB, true, EXPERIMENTAL, \
"Use elastic policy to manage TLAB sizes. This conserves memory " \ "Use elastic policy to manage TLAB sizes. This conserves memory " \
"for non-actively allocating threads, even when they request " \ "for non-actively allocating threads, even when they request " \
"large TLABs for themselves. Active threads would experience " \ "large TLABs for themselves. Active threads would experience " \
"smaller TLABs until policy catches up.") \ "smaller TLABs until policy catches up.") \
\ \
experimental(bool, EpsilonElasticTLABDecay, true, \ product(bool, EpsilonElasticTLABDecay, true, EXPERIMENTAL, \
"Use timed decays to shrik TLAB sizes. This conserves memory " \ "Use timed decays to shrik TLAB sizes. This conserves memory " \
"for the threads that allocate in bursts of different sizes, " \ "for the threads that allocate in bursts of different sizes, " \
"for example the small/rare allocations coming after the initial "\ "for example the small/rare allocations coming after the initial "\
"large burst.") \ "large burst.") \
\ \
experimental(double, EpsilonTLABElasticity, 1.1, \ product(double, EpsilonTLABElasticity, 1.1, EXPERIMENTAL, \
"Multiplier to use when deciding on next TLAB size. Larger value "\ "Multiplier to use when deciding on next TLAB size. Larger value "\
"improves performance at the expense of per-thread memory waste. "\ "improves performance at the expense of per-thread memory waste. "\
"Lower value improves memory footprint, but penalizes actively " \ "Lower value improves memory footprint, but penalizes actively " \
"allocating threads.") \ "allocating threads.") \
range(1.0, DBL_MAX) \ range(1.0, DBL_MAX) \
\ \
experimental(size_t, EpsilonTLABDecayTime, 1000, \ product(size_t, EpsilonTLABDecayTime, 1000, EXPERIMENTAL, \
"TLAB sizing policy decays to initial size after thread had not " \ "TLAB sizing policy decays to initial size after thread had not " \
"allocated for this long. Time is in milliseconds. Lower value " \ "allocated for this long. Time is in milliseconds. Lower value " \
"improves memory footprint, but penalizes actively allocating " \ "improves memory footprint, but penalizes actively allocating " \
"threads.") \ "threads.") \
range(1, max_intx) \ range(1, max_intx) \
\ \
experimental(size_t, EpsilonMinHeapExpand, 128 * M, \ product(size_t, EpsilonMinHeapExpand, 128 * M, EXPERIMENTAL, \
"Min expansion step for heap. Larger value improves performance " \ "Min expansion step for heap. Larger value improves performance " \
"at the potential expense of memory waste.") \ "at the potential expense of memory waste.") \
range(1, max_intx) range(1, max_intx)
// end of GC_EPSILON_FLAGS
#endif // SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP #endif // SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP

43
src/hotspot/share/gc/g1/g1_globals.hpp
View file

@ -35,13 +35,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
@ -51,7 +45,7 @@
"attempts to start marking in time based on application " \ "attempts to start marking in time based on application " \
"behavior.") \ "behavior.") \
\ \
experimental(size_t, G1AdaptiveIHOPNumInitialSamples, 3, \ product(size_t, G1AdaptiveIHOPNumInitialSamples, 3, EXPERIMENTAL, \
"How many completed time periods from concurrent start to first " \ "How many completed time periods from concurrent start to first " \
"mixed gc are required to use the input values for prediction " \ "mixed gc are required to use the input values for prediction " \
"of the optimal occupancy to start marking.") \ "of the optimal occupancy to start marking.") \
@ -61,7 +55,7 @@
"Confidence level for MMU/pause predictions") \ "Confidence level for MMU/pause predictions") \
range(0, 100) \ range(0, 100) \
\ \
diagnostic(intx, G1SummarizeRSetStatsPeriod, 0, \ product(intx, G1SummarizeRSetStatsPeriod, 0, DIAGNOSTIC, \
"The period (in number of GCs) at which we will generate " \ "The period (in number of GCs) at which we will generate " \
"update buffer processing info " \ "update buffer processing info " \
"(0 means do not periodically generate this info); " \ "(0 means do not periodically generate this info); " \
@ -79,11 +73,11 @@
"draining concurrent marking work queues.") \ "draining concurrent marking work queues.") \
range(1, INT_MAX) \ range(1, INT_MAX) \
\ \
experimental(bool, G1UseReferencePrecleaning, true, \ product(bool, G1UseReferencePrecleaning, true, EXPERIMENTAL, \
"Concurrently preclean java.lang.ref.references instances " \ "Concurrently preclean java.lang.ref.references instances " \
"before the Remark pause.") \ "before the Remark pause.") \
\ \
experimental(double, G1LastPLABAverageOccupancy, 50.0, \ product(double, G1LastPLABAverageOccupancy, 50.0, EXPERIMENTAL, \
"The expected average occupancy of the last PLAB in " \ "The expected average occupancy of the last PLAB in " \
"percent.") \ "percent.") \
range(0.001, 100.0) \ range(0.001, 100.0) \
@ -104,7 +98,7 @@
"specifies that mutator threads should not do such filtering.") \ "specifies that mutator threads should not do such filtering.") \
range(0, 100) \ range(0, 100) \
\ \
experimental(intx, G1ExpandByPercentOfAvailable, 20, \ product(intx, G1ExpandByPercentOfAvailable, 20, EXPERIMENTAL, \
"When expanding, % of uncommitted space to claim.") \ "When expanding, % of uncommitted space to claim.") \
range(0, 100) \ range(0, 100) \
\ \
@ -212,19 +206,19 @@
"Raise a fatal VM exit out of memory failure in the event " \ "Raise a fatal VM exit out of memory failure in the event " \
" that heap expansion fails due to running out of swap.") \ " that heap expansion fails due to running out of swap.") \
\ \
experimental(uintx, G1MaxNewSizePercent, 60, \ product(uintx, G1MaxNewSizePercent, 60, EXPERIMENTAL, \
"Percentage (0-100) of the heap size to use as default " \ "Percentage (0-100) of the heap size to use as default " \
" maximum young gen size.") \ " maximum young gen size.") \
range(0, 100) \ range(0, 100) \
constraint(G1MaxNewSizePercentConstraintFunc,AfterErgo) \ constraint(G1MaxNewSizePercentConstraintFunc,AfterErgo) \
\ \
experimental(uintx, G1NewSizePercent, 5, \ product(uintx, G1NewSizePercent, 5, EXPERIMENTAL, \
"Percentage (0-100) of the heap size to use as default " \ "Percentage (0-100) of the heap size to use as default " \
"minimum young gen size.") \ "minimum young gen size.") \
range(0, 100) \ range(0, 100) \
constraint(G1NewSizePercentConstraintFunc,AfterErgo) \ constraint(G1NewSizePercentConstraintFunc,AfterErgo) \
\ \
experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \ product(uintx, G1MixedGCLiveThresholdPercent, 85, EXPERIMENTAL, \
"Threshold for regions to be considered for inclusion in the " \ "Threshold for regions to be considered for inclusion in the " \
"collection set of mixed GCs. " \ "collection set of mixed GCs. " \
"Regions with live bytes exceeding this will not be collected.") \ "Regions with live bytes exceeding this will not be collected.") \
@ -239,18 +233,18 @@
"The target number of mixed GCs after a marking cycle.") \ "The target number of mixed GCs after a marking cycle.") \
range(0, max_uintx) \ range(0, max_uintx) \
\ \
experimental(bool, G1EagerReclaimHumongousObjects, true, \ product(bool, G1EagerReclaimHumongousObjects, true, EXPERIMENTAL, \
"Try to reclaim dead large objects at every young GC.") \ "Try to reclaim dead large objects at every young GC.") \
\ \
experimental(bool, G1EagerReclaimHumongousObjectsWithStaleRefs, true, \ product(bool, G1EagerReclaimHumongousObjectsWithStaleRefs, true, EXPERIMENTAL, \
"Try to reclaim dead large objects that have a few stale " \ "Try to reclaim dead large objects that have a few stale " \
"references at every young GC.") \ "references at every young GC.") \
\ \
experimental(size_t, G1RebuildRemSetChunkSize, 256 * K, \ product(size_t, G1RebuildRemSetChunkSize, 256 * K, EXPERIMENTAL, \
"Chunk size used for rebuilding the remembered set.") \ "Chunk size used for rebuilding the remembered set.") \
range(4 * K, 32 * M) \ range(4 * K, 32 * M) \
\ \
experimental(uintx, G1OldCSetRegionThresholdPercent, 10, \ product(uintx, G1OldCSetRegionThresholdPercent, 10, EXPERIMENTAL, \
"An upper bound for the number of old CSet regions expressed " \ "An upper bound for the number of old CSet regions expressed " \
"as a percentage of the heap size.") \ "as a percentage of the heap size.") \
range(0, 100) \ range(0, 100) \
@ -283,17 +277,17 @@
"Force use of evacuation failure handling during mixed " \ "Force use of evacuation failure handling during mixed " \
"evacuation pauses") \ "evacuation pauses") \
\ \
diagnostic(bool, G1VerifyRSetsDuringFullGC, false, \ product(bool, G1VerifyRSetsDuringFullGC, false, DIAGNOSTIC, \
"If true, perform verification of each heap region's " \ "If true, perform verification of each heap region's " \
"remembered set when verifying the heap during a full GC.") \ "remembered set when verifying the heap during a full GC.") \
\ \
diagnostic(bool, G1VerifyHeapRegionCodeRoots, false, \ product(bool, G1VerifyHeapRegionCodeRoots, false, DIAGNOSTIC, \
"Verify the code root lists attached to each heap region.") \ "Verify the code root lists attached to each heap region.") \
\ \
develop(bool, G1VerifyBitmaps, false, \ develop(bool, G1VerifyBitmaps, false, \
"Verifies the consistency of the marking bitmaps") \ "Verifies the consistency of the marking bitmaps") \
\ \
manageable(uintx, G1PeriodicGCInterval, 0, \ product(uintx, G1PeriodicGCInterval, 0, MANAGEABLE, \
"Number of milliseconds after a previous GC to wait before " \ "Number of milliseconds after a previous GC to wait before " \
"triggering a periodic gc. A value of zero disables periodically "\ "triggering a periodic gc. A value of zero disables periodically "\
"enforced gc cycles.") \ "enforced gc cycles.") \
@ -303,21 +297,22 @@
"perform a concurrent GC as periodic GC, otherwise use a STW " \ "perform a concurrent GC as periodic GC, otherwise use a STW " \
"Full GC.") \ "Full GC.") \
\ \
manageable(double, G1PeriodicGCSystemLoadThreshold, 0.0, \ product(double, G1PeriodicGCSystemLoadThreshold, 0.0, MANAGEABLE, \
"Maximum recent system wide load as returned by the 1m value " \ "Maximum recent system wide load as returned by the 1m value " \
"of getloadavg() at which G1 triggers a periodic GC. A load " \ "of getloadavg() at which G1 triggers a periodic GC. A load " \
"above this value cancels a given periodic GC. A value of zero " \ "above this value cancels a given periodic GC. A value of zero " \
"disables this check.") \ "disables this check.") \
range(0.0, (double)max_uintx) \ range(0.0, (double)max_uintx) \
\ \
experimental(uintx, G1YoungExpansionBufferPercent, 10, \ product(uintx, G1YoungExpansionBufferPercent, 10, EXPERIMENTAL, \
"When heterogenous heap is enabled by AllocateOldGenAt " \ "When heterogenous heap is enabled by AllocateOldGenAt " \
"option, after every GC, young gen is re-sized which " \ "option, after every GC, young gen is re-sized which " \
"involves system calls to commit/uncommit memory. To " \ "involves system calls to commit/uncommit memory. To " \
"reduce these calls, we keep a buffer of extra regions to " \ "reduce these calls, we keep a buffer of extra regions to " \
"absorb small changes in young gen length. This flag takes " \ "absorb small changes in young gen length. This flag takes " \
"the buffer size as an percentage of young gen length") \ "the buffer size as an percentage of young gen length") \
range(0, 100) \ range(0, 100)
// end of GC_G1_FLAGS
#endif // SHARE_GC_G1_G1_GLOBALS_HPP #endif // SHARE_GC_G1_G1_GLOBALS_HPP

27
src/hotspot/share/gc/g1/jvmFlagConstraintsG1.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -28,18 +28,21 @@
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "utilities/globalDefinitions.hpp" #include "utilities/globalDefinitions.hpp"
// G1 Flag Constraints #define G1_GC_CONSTRAINTS(f) \
JVMFlag::Error G1RSetRegionEntriesConstraintFunc(intx value, bool verbose); \
JVMFlag::Error G1RSetSparseRegionEntriesConstraintFunc(intx value, bool verbose); /* G1 Flag Constraints */ \
JVMFlag::Error G1HeapRegionSizeConstraintFunc(size_t value, bool verbose); f(intx, G1RSetRegionEntriesConstraintFunc) \
JVMFlag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose); f(intx, G1RSetSparseRegionEntriesConstraintFunc) \
JVMFlag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose); f(size_t, G1HeapRegionSizeConstraintFunc) \
f(uintx, G1NewSizePercentConstraintFunc) \
f(uintx, G1MaxNewSizePercentConstraintFunc) \
\
/* G1 Subconstraints */ \
f(uintx, MaxGCPauseMillisConstraintFuncG1) \
f(uintx, GCPauseIntervalMillisConstraintFuncG1) \
f(size_t, NewSizeConstraintFuncG1)
// G1 Subconstraints G1_GC_CONSTRAINTS(DECLARE_CONSTRAINT)
JVMFlag::Error MaxGCPauseMillisConstraintFuncG1(uintx value, bool verbose);
JVMFlag::Error GCPauseIntervalMillisConstraintFuncG1(uintx value, bool verbose);
JVMFlag::Error MaxSizeForHeapAlignmentG1(const char* name, size_t value, bool verbose);
JVMFlag::Error NewSizeConstraintFuncG1(size_t value, bool verbose);
size_t MaxSizeForHeapAlignmentG1(); size_t MaxSizeForHeapAlignmentG1();

11
src/hotspot/share/gc/parallel/jvmFlagConstraintsParallel.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -29,8 +29,11 @@
#include "utilities/globalDefinitions.hpp" #include "utilities/globalDefinitions.hpp"
// Parallel Subconstraints // Parallel Subconstraints
JVMFlag::Error ParallelGCThreadsConstraintFuncParallel(uint value, bool verbose); #define PARALLEL_GC_CONSTRAINTS(f) \
JVMFlag::Error InitialTenuringThresholdConstraintFuncParallel(uintx value, bool verbose); f(uint, ParallelGCThreadsConstraintFuncParallel) \
JVMFlag::Error MaxTenuringThresholdConstraintFuncParallel(uintx value, bool verbose); f(uintx, InitialTenuringThresholdConstraintFuncParallel) \
f(uintx, MaxTenuringThresholdConstraintFuncParallel)
PARALLEL_GC_CONSTRAINTS(DECLARE_CONSTRAINT)
#endif // SHARE_GC_PARALLEL_JVMFLAGCONSTRAINTSPARALLEL_HPP #endif // SHARE_GC_PARALLEL_JVMFLAGCONSTRAINTSPARALLEL_HPP

8
src/hotspot/share/gc/parallel/parallel_globals.hpp
View file

@ -29,13 +29,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
product(uintx, HeapMaximumCompactionInterval, 20, \ product(uintx, HeapMaximumCompactionInterval, 20, \
@ -67,4 +61,6 @@
product(bool, PSChunkLargeArrays, true, \ product(bool, PSChunkLargeArrays, true, \
"Process large arrays in chunks") "Process large arrays in chunks")
// end of GC_PARALLEL_FLAGS
#endif // SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP #endif // SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP

8
src/hotspot/share/gc/serial/serial_globals.hpp
View file

@ -29,14 +29,10 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) constraint)
// end of GC_SERIAL_FLAGS
#endif // SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP #endif // SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP

90
src/hotspot/share/gc/shared/gc_globals.hpp
View file

@ -50,13 +50,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
@ -65,13 +59,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -80,13 +68,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -95,13 +77,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -110,13 +86,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -125,13 +95,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -140,13 +104,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint)) \ constraint)) \
\ \
@ -161,7 +119,7 @@
product(bool, UseParallelGC, false, \ product(bool, UseParallelGC, false, \
"Use the Parallel garbage collector.") \ "Use the Parallel garbage collector.") \
\ \
experimental(bool, UseEpsilonGC, false, \ product(bool, UseEpsilonGC, false, EXPERIMENTAL, \
"Use the Epsilon (no-op) garbage collector") \ "Use the Epsilon (no-op) garbage collector") \
\ \
product(bool, UseZGC, false, \ product(bool, UseZGC, false, \
@ -179,14 +137,14 @@
"ParallelGCThreads parallel collectors will use for garbage " \ "ParallelGCThreads parallel collectors will use for garbage " \
"collection work") \ "collection work") \
\ \
diagnostic(bool, InjectGCWorkerCreationFailure, false, \ product(bool, InjectGCWorkerCreationFailure, false, DIAGNOSTIC, \
"Inject thread creation failures for " \ "Inject thread creation failures for " \
"UseDynamicNumberOfGCThreads") \ "UseDynamicNumberOfGCThreads") \
\ \
product(size_t, HeapSizePerGCThread, ScaleForWordSize(32*M), \ product(size_t, HeapSizePerGCThread, ScaleForWordSize(32*M), \
"Size of heap (bytes) per GC thread used in calculating the " \ "Size of heap (bytes) per GC thread used in calculating the " \
"number of GC threads") \ "number of GC threads") \
range((size_t)os::vm_page_size(), (size_t)max_uintx) \ constraint(VMPageSizeConstraintFunc, AtParse) \
\ \
product(uint, ConcGCThreads, 0, \ product(uint, ConcGCThreads, 0, \
"Number of threads concurrent gc will use") \ "Number of threads concurrent gc will use") \
@ -211,7 +169,7 @@
"is active (as a percentage)") \ "is active (as a percentage)") \
range(0, 100) \ range(0, 100) \
\ \
diagnostic(uintx, GCLockerRetryAllocationCount, 2, \ product(uintx, GCLockerRetryAllocationCount, 2, DIAGNOSTIC, \
"Number of times to retry allocations when " \ "Number of times to retry allocations when " \
"blocked by the GC locker") \ "blocked by the GC locker") \
range(0, max_uintx) \ range(0, max_uintx) \
@ -268,7 +226,7 @@
product(bool, ParallelRefProcBalancingEnabled, true, \ product(bool, ParallelRefProcBalancingEnabled, true, \
"Enable balancing of reference processing queues") \ "Enable balancing of reference processing queues") \
\ \
experimental(size_t, ReferencesPerThread, 1000, \ product(size_t, ReferencesPerThread, 1000, EXPERIMENTAL, \
"Ergonomically start one thread for this amount of " \ "Ergonomically start one thread for this amount of " \
"references for reference processing if " \ "references for reference processing if " \
"ParallelRefProcEnabled is true. Specify 0 to disable and " \ "ParallelRefProcEnabled is true. Specify 0 to disable and " \
@ -308,17 +266,17 @@
develop(uintx, PromotionFailureALotInterval, 5, \ develop(uintx, PromotionFailureALotInterval, 5, \
"Total collections between promotion failures a lot") \ "Total collections between promotion failures a lot") \
\ \
experimental(uintx, WorkStealingSleepMillis, 1, \ product(uintx, WorkStealingSleepMillis, 1, EXPERIMENTAL, \
"Sleep time when sleep is used for yields") \ "Sleep time when sleep is used for yields") \
\ \
experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \ product(uintx, WorkStealingYieldsBeforeSleep, 5000, EXPERIMENTAL, \
"Number of yields before a sleep is done during work stealing") \ "Number of yields before a sleep is done during work stealing") \
\ \
experimental(uintx, WorkStealingHardSpins, 4096, \ product(uintx, WorkStealingHardSpins, 4096, EXPERIMENTAL, \
"Number of iterations in a spin loop between checks on " \ "Number of iterations in a spin loop between checks on " \
"time out of hard spin") \ "time out of hard spin") \
\ \
experimental(uintx, WorkStealingSpinToYieldRatio, 10, \ product(uintx, WorkStealingSpinToYieldRatio, 10, EXPERIMENTAL, \
"Ratio of hard spins to calls to yield") \ "Ratio of hard spins to calls to yield") \
\ \
develop(uintx, ObjArrayMarkingStride, 2048, \ develop(uintx, ObjArrayMarkingStride, 2048, \
@ -563,27 +521,27 @@
"How many fields ahead to prefetch in oop scan (<= 0 means off)") \ "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
range(-1, max_jint) \ range(-1, max_jint) \
\ \
diagnostic(bool, VerifyDuringStartup, false, \ product(bool, VerifyDuringStartup, false, DIAGNOSTIC, \
"Verify memory system before executing any Java code " \ "Verify memory system before executing any Java code " \
"during VM initialization") \ "during VM initialization") \
\ \
diagnostic(bool, VerifyBeforeExit, trueInDebug, \ product(bool, VerifyBeforeExit, trueInDebug, DIAGNOSTIC, \
"Verify system before exiting") \ "Verify system before exiting") \
\ \
diagnostic(bool, VerifyBeforeGC, false, \ product(bool, VerifyBeforeGC, false, DIAGNOSTIC, \
"Verify memory system before GC") \ "Verify memory system before GC") \
\ \
diagnostic(bool, VerifyAfterGC, false, \ product(bool, VerifyAfterGC, false, DIAGNOSTIC, \
"Verify memory system after GC") \ "Verify memory system after GC") \
\ \
diagnostic(bool, VerifyDuringGC, false, \ product(bool, VerifyDuringGC, false, DIAGNOSTIC, \
"Verify memory system during GC (between phases)") \ "Verify memory system during GC (between phases)") \
\ \
diagnostic(ccstrlist, VerifyGCType, "", \ product(ccstrlist, VerifyGCType, "", DIAGNOSTIC, \
"GC type(s) to verify when Verify*GC is enabled." \ "GC type(s) to verify when Verify*GC is enabled." \
"Available types are collector specific.") \ "Available types are collector specific.") \
\ \
diagnostic(ccstrlist, VerifySubSet, "", \ product(ccstrlist, VerifySubSet, "", DIAGNOSTIC, \
"Memory sub-systems to verify when Verify*GC flag(s) " \ "Memory sub-systems to verify when Verify*GC flag(s) " \
"are enabled. One or more sub-systems can be specified " \ "are enabled. One or more sub-systems can be specified " \
"in a comma separated string. Sub-systems are: " \ "in a comma separated string. Sub-systems are: " \
@ -591,20 +549,20 @@
"dictionary, classloader_data_graph, metaspace, jni_handles, " \ "dictionary, classloader_data_graph, metaspace, jni_handles, " \
"codecache_oops") \ "codecache_oops") \
\ \
diagnostic(bool, GCParallelVerificationEnabled, true, \ product(bool, GCParallelVerificationEnabled, true, DIAGNOSTIC, \
"Enable parallel memory system verification") \ "Enable parallel memory system verification") \
\ \
diagnostic(bool, DeferInitialCardMark, false, \ product(bool, DeferInitialCardMark, false, DIAGNOSTIC, \
"When +ReduceInitialCardMarks, explicitly defer any that " \ "When +ReduceInitialCardMarks, explicitly defer any that " \
"may arise from new_pre_store_barrier") \ "may arise from new_pre_store_barrier") \
\ \
product(bool, UseCondCardMark, false, \ product(bool, UseCondCardMark, false, \
"Check for already marked card before updating card table") \ "Check for already marked card before updating card table") \
\ \
diagnostic(bool, VerifyRememberedSets, false, \ product(bool, VerifyRememberedSets, false, DIAGNOSTIC, \
"Verify GC remembered sets") \ "Verify GC remembered sets") \
\ \
diagnostic(bool, VerifyObjectStartArray, true, \ product(bool, VerifyObjectStartArray, true, DIAGNOSTIC, \
"Verify GC object start array if verify before/after") \ "Verify GC object start array if verify before/after") \
\ \
product(bool, DisableExplicitGC, false, \ product(bool, DisableExplicitGC, false, \
@ -649,7 +607,7 @@
"Maximum heap size (in bytes)") \ "Maximum heap size (in bytes)") \
constraint(MaxHeapSizeConstraintFunc,AfterErgo) \ constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
\ \
manageable(size_t, SoftMaxHeapSize, 0, \ product(size_t, SoftMaxHeapSize, 0, MANAGEABLE, \
"Soft limit for maximum heap size (in bytes)") \ "Soft limit for maximum heap size (in bytes)") \
constraint(SoftMaxHeapSizeConstraintFunc,AfterMemoryInit) \ constraint(SoftMaxHeapSizeConstraintFunc,AfterMemoryInit) \
\ \
@ -730,11 +688,11 @@
"will retry before printing a warning") \ "will retry before printing a warning") \
range(0, max_uintx) \ range(0, max_uintx) \
\ \
diagnostic(uintx, VerifyGCStartAt, 0, \ product(uintx, VerifyGCStartAt, 0, DIAGNOSTIC, \
"GC invoke count where +VerifyBefore/AfterGC kicks in") \ "GC invoke count where +VerifyBefore/AfterGC kicks in") \
range(0, max_uintx) \ range(0, max_uintx) \
\ \
diagnostic(intx, VerifyGCLevel, 0, \ product(intx, VerifyGCLevel, 0, DIAGNOSTIC, \
"Generation level at which to start +VerifyBefore/AfterGC") \ "Generation level at which to start +VerifyBefore/AfterGC") \
range(0, 1) \ range(0, 1) \
\ \
@ -775,4 +733,6 @@
"during parallel gc") \ "during parallel gc") \
range(0, max_juint) range(0, max_juint)
// end of GC_FLAGS
#endif // SHARE_GC_SHARED_GC_GLOBALS_HPP #endif // SHARE_GC_SHARED_GC_GLOBALS_HPP

68
src/hotspot/share/gc/shared/jvmFlagConstraintsGC.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -40,38 +40,44 @@
* whenever flag's value changes. If the constraint fails the function should return * whenever flag's value changes. If the constraint fails the function should return
* an appropriate error value. * an appropriate error value.
*/ */
#define SHARED_GC_CONSTRAINTS(f) \
f(uint, ParallelGCThreadsConstraintFunc) \
f(uint, ConcGCThreadsConstraintFunc) \
f(size_t, YoungPLABSizeConstraintFunc) \
f(size_t, OldPLABSizeConstraintFunc) \
f(uintx, MinHeapFreeRatioConstraintFunc) \
f(uintx, MaxHeapFreeRatioConstraintFunc) \
f(intx, SoftRefLRUPolicyMSPerMBConstraintFunc) \
f(size_t, MarkStackSizeConstraintFunc) \
f(uintx, MinMetaspaceFreeRatioConstraintFunc) \
f(uintx, MaxMetaspaceFreeRatioConstraintFunc) \
f(uintx, InitialTenuringThresholdConstraintFunc) \
f(uintx, MaxTenuringThresholdConstraintFunc) \
\
f(uintx, MaxGCPauseMillisConstraintFunc) \
f(uintx, GCPauseIntervalMillisConstraintFunc) \
f(size_t, InitialBootClassLoaderMetaspaceSizeConstraintFunc) \
f(size_t, MinHeapSizeConstraintFunc) \
f(size_t, InitialHeapSizeConstraintFunc) \
f(size_t, MaxHeapSizeConstraintFunc) \
f(size_t, SoftMaxHeapSizeConstraintFunc) \
f(size_t, HeapBaseMinAddressConstraintFunc) \
f(size_t, NewSizeConstraintFunc) \
f(size_t, MinTLABSizeConstraintFunc) \
f(size_t, TLABSizeConstraintFunc) \
f(uintx, TLABWasteIncrementConstraintFunc) \
f(uintx, SurvivorRatioConstraintFunc) \
f(size_t, MetaspaceSizeConstraintFunc) \
f(size_t, MaxMetaspaceSizeConstraintFunc) \
f(intx, SurvivorAlignmentInBytesConstraintFunc)
JVMFlag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose); SHARED_GC_CONSTRAINTS(DECLARE_CONSTRAINT)
JVMFlag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose);
JVMFlag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose);
JVMFlag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose);
JVMFlag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose);
JVMFlag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose);
JVMFlag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose);
JVMFlag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose);
JVMFlag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose);
JVMFlag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose);
JVMFlag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose);
JVMFlag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MinHeapSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error SoftMaxHeapSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error HeapBaseMinAddressConstraintFunc(size_t value, bool verbose);
JVMFlag::Error NewSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error TLABSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error TLABWasteIncrementConstraintFunc(uintx value, bool verbose);
JVMFlag::Error SurvivorRatioConstraintFunc(uintx value, bool verbose);
JVMFlag::Error MetaspaceSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose);
JVMFlag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose);
// Internal
JVMFlag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose); JVMFlag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose);
#define GC_CONSTRAINTS(f) \
SHARED_GC_CONSTRAINTS(f) \
G1GC_ONLY(G1_GC_CONSTRAINTS(f)) \
PARALLELGC_ONLY(PARALLEL_GC_CONSTRAINTS(f))
#endif // SHARE_GC_SHARED_JVMFLAGCONSTRAINTSGC_HPP #endif // SHARE_GC_SHARED_JVMFLAGCONSTRAINTSGC_HPP

121
src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp
View file

@ -30,33 +30,27 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
experimental(size_t, ShenandoahRegionSize, 0, \ product(size_t, ShenandoahRegionSize, 0, EXPERIMENTAL, \
"Static heap region size. Set zero to enable automatic sizing.") \ "Static heap region size. Set zero to enable automatic sizing.") \
\ \
experimental(size_t, ShenandoahTargetNumRegions, 2048, \ product(size_t, ShenandoahTargetNumRegions, 2048, EXPERIMENTAL, \
"With automatic region sizing, this is the approximate number " \ "With automatic region sizing, this is the approximate number " \
"of regions that would be used, within min/max region size " \ "of regions that would be used, within min/max region size " \
"limits.") \ "limits.") \
\ \
experimental(size_t, ShenandoahMinRegionSize, 256 * K, \ product(size_t, ShenandoahMinRegionSize, 256 * K, EXPERIMENTAL, \
"With automatic region sizing, the regions would be at least " \ "With automatic region sizing, the regions would be at least " \
"this large.") \ "this large.") \
\ \
experimental(size_t, ShenandoahMaxRegionSize, 32 * M, \ product(size_t, ShenandoahMaxRegionSize, 32 * M, EXPERIMENTAL, \
"With automatic region sizing, the regions would be at most " \ "With automatic region sizing, the regions would be at most " \
"this large.") \ "this large.") \
\ \
experimental(intx, ShenandoahHumongousThreshold, 100, \ product(intx, ShenandoahHumongousThreshold, 100, EXPERIMENTAL, \
"Humongous objects are allocated in separate regions. " \ "Humongous objects are allocated in separate regions. " \
"This setting defines how large the object should be to be " \ "This setting defines how large the object should be to be " \
"deemed humongous. Value is in percents of heap region size. " \ "deemed humongous. Value is in percents of heap region size. " \
@ -82,19 +76,19 @@
" compact - run GC more frequently and with deeper targets to " \ " compact - run GC more frequently and with deeper targets to " \
"free up more memory.") \ "free up more memory.") \
\ \
experimental(uintx, ShenandoahRefProcFrequency, 5, \ product(uintx, ShenandoahRefProcFrequency, 5, EXPERIMENTAL, \
"Process process weak (soft, phantom, finalizers) references " \ "Process process weak (soft, phantom, finalizers) references " \
"every Nth cycle. Normally affects concurrent GC cycles only, " \ "every Nth cycle. Normally affects concurrent GC cycles only, " \
"as degenerated and full GCs would try to process references " \ "as degenerated and full GCs would try to process references " \
"regardless. Set to zero to disable reference processing " \ "regardless. Set to zero to disable reference processing " \
"completely.") \ "completely.") \
\ \
experimental(uintx, ShenandoahUnloadClassesFrequency, 1, \ product(uintx, ShenandoahUnloadClassesFrequency, 1, EXPERIMENTAL, \
"Unload the classes every Nth cycle. Normally affects concurrent "\ "Unload the classes every Nth cycle. Normally affects concurrent "\
"GC cycles, as degenerated and full GCs would try to unload " \ "GC cycles, as degenerated and full GCs would try to unload " \
"classes regardless. Set to zero to disable class unloading.") \ "classes regardless. Set to zero to disable class unloading.") \
\ \
experimental(uintx, ShenandoahGarbageThreshold, 25, \ product(uintx, ShenandoahGarbageThreshold, 25, EXPERIMENTAL, \
"How much garbage a region has to contain before it would be " \ "How much garbage a region has to contain before it would be " \
"taken for collection. This a guideline only, as GC heuristics " \ "taken for collection. This a guideline only, as GC heuristics " \
"may select the region for collection even if it has little " \ "may select the region for collection even if it has little " \
@ -102,63 +96,63 @@
"collector accepts. In percents of heap region size.") \ "collector accepts. In percents of heap region size.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahInitFreeThreshold, 70, \ product(uintx, ShenandoahInitFreeThreshold, 70, EXPERIMENTAL, \
"How much heap should be free before some heuristics trigger the "\ "How much heap should be free before some heuristics trigger the "\
"initial (learning) cycles. Affects cycle frequency on startup " \ "initial (learning) cycles. Affects cycle frequency on startup " \
"and after drastic state changes, e.g. after degenerated/full " \ "and after drastic state changes, e.g. after degenerated/full " \
"GC cycles. In percents of (soft) max heap size.") \ "GC cycles. In percents of (soft) max heap size.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahMinFreeThreshold, 10, \ product(uintx, ShenandoahMinFreeThreshold, 10, EXPERIMENTAL, \
"How much heap should be free before most heuristics trigger the "\ "How much heap should be free before most heuristics trigger the "\
"collection, even without other triggers. Provides the safety " \ "collection, even without other triggers. Provides the safety " \
"margin for many heuristics. In percents of (soft) max heap size.")\ "margin for many heuristics. In percents of (soft) max heap size.")\
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahAllocationThreshold, 0, \ product(uintx, ShenandoahAllocationThreshold, 0, EXPERIMENTAL, \
"How many new allocations should happen since the last GC cycle " \ "How many new allocations should happen since the last GC cycle " \
"before some heuristics trigger the collection. In percents of " \ "before some heuristics trigger the collection. In percents of " \
"(soft) max heap size. Set to zero to effectively disable.") \ "(soft) max heap size. Set to zero to effectively disable.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahAllocSpikeFactor, 5, \ product(uintx, ShenandoahAllocSpikeFactor, 5, EXPERIMENTAL, \
"How much of heap should some heuristics reserve for absorbing " \ "How much of heap should some heuristics reserve for absorbing " \
"the allocation spikes. Larger value wastes more memory in " \ "the allocation spikes. Larger value wastes more memory in " \
"non-emergency cases, but provides more safety in emergency " \ "non-emergency cases, but provides more safety in emergency " \
"cases. In percents of (soft) max heap size.") \ "cases. In percents of (soft) max heap size.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahLearningSteps, 5, \ product(uintx, ShenandoahLearningSteps, 5, EXPERIMENTAL, \
"The number of cycles some heuristics take to collect in order " \ "The number of cycles some heuristics take to collect in order " \
"to learn application and GC performance.") \ "to learn application and GC performance.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahImmediateThreshold, 90, \ product(uintx, ShenandoahImmediateThreshold, 90, EXPERIMENTAL, \
"The cycle may shortcut when enough garbage can be reclaimed " \ "The cycle may shortcut when enough garbage can be reclaimed " \
"from the immediate garbage (completely garbage regions). " \ "from the immediate garbage (completely garbage regions). " \
"In percents of total garbage found. Setting this threshold " \ "In percents of total garbage found. Setting this threshold " \
"to 100 effectively disables the shortcut.") \ "to 100 effectively disables the shortcut.") \
range(0,100) \ range(0,100) \
\ \
experimental(uintx, ShenandoahGuaranteedGCInterval, 5*60*1000, \ product(uintx, ShenandoahGuaranteedGCInterval, 5*60*1000, EXPERIMENTAL, \
"Many heuristics would guarantee a concurrent GC cycle at " \ "Many heuristics would guarantee a concurrent GC cycle at " \
"least with this interval. This is useful when large idle " \ "least with this interval. This is useful when large idle " \
"intervals are present, where GC can run without stealing " \ "intervals are present, where GC can run without stealing " \
"time from active application. Time is in milliseconds. " \ "time from active application. Time is in milliseconds. " \
"Setting this to 0 disables the feature.") \ "Setting this to 0 disables the feature.") \
\ \
experimental(bool, ShenandoahAlwaysClearSoftRefs, false, \ product(bool, ShenandoahAlwaysClearSoftRefs, false, EXPERIMENTAL, \
"Unconditionally clear soft references, instead of using any " \ "Unconditionally clear soft references, instead of using any " \
"other cleanup policy. This minimizes footprint at expense of" \ "other cleanup policy. This minimizes footprint at expense of" \
"more soft reference churn in applications.") \ "more soft reference churn in applications.") \
\ \
experimental(bool, ShenandoahUncommit, true, \ product(bool, ShenandoahUncommit, true, EXPERIMENTAL, \
"Allow to uncommit memory under unused regions and metadata. " \ "Allow to uncommit memory under unused regions and metadata. " \
"This optimizes footprint at expense of allocation latency in " \ "This optimizes footprint at expense of allocation latency in " \
"regions that require committing back. Uncommits would be " \ "regions that require committing back. Uncommits would be " \
"disabled by some heuristics, or with static heap size.") \ "disabled by some heuristics, or with static heap size.") \
\ \
experimental(uintx, ShenandoahUncommitDelay, 5*60*1000, \ product(uintx, ShenandoahUncommitDelay, 5*60*1000, EXPERIMENTAL, \
"Uncommit memory for regions that were not used for more than " \ "Uncommit memory for regions that were not used for more than " \
"this time. First use after that would incur allocation stalls. " \ "this time. First use after that would incur allocation stalls. " \
"Actively used regions would never be uncommitted, because they " \ "Actively used regions would never be uncommitted, because they " \
@ -166,37 +160,37 @@
"milliseconds. Setting this delay to 0 effectively uncommits " \ "milliseconds. Setting this delay to 0 effectively uncommits " \
"regions almost immediately after they become unused.") \ "regions almost immediately after they become unused.") \
\ \
experimental(bool, ShenandoahRegionSampling, false, \ product(bool, ShenandoahRegionSampling, false, EXPERIMENTAL, \
"Provide heap region sampling data via jvmstat.") \ "Provide heap region sampling data via jvmstat.") \
\ \
experimental(int, ShenandoahRegionSamplingRate, 40, \ product(int, ShenandoahRegionSamplingRate, 40, EXPERIMENTAL, \
"Sampling rate for heap region sampling. In milliseconds between "\ "Sampling rate for heap region sampling. In milliseconds between "\
"the samples. Higher values provide more fidelity, at expense " \ "the samples. Higher values provide more fidelity, at expense " \
"of more sampling overhead.") \ "of more sampling overhead.") \
\ \
experimental(uintx, ShenandoahControlIntervalMin, 1, \ product(uintx, ShenandoahControlIntervalMin, 1, EXPERIMENTAL, \
"The minimum sleep interval for the control loop that drives " \ "The minimum sleep interval for the control loop that drives " \
"the cycles. Lower values would increase GC responsiveness " \ "the cycles. Lower values would increase GC responsiveness " \
"to changing heap conditions, at the expense of higher perf " \ "to changing heap conditions, at the expense of higher perf " \
"overhead. Time is in milliseconds.") \ "overhead. Time is in milliseconds.") \
\ \
experimental(uintx, ShenandoahControlIntervalMax, 10, \ product(uintx, ShenandoahControlIntervalMax, 10, EXPERIMENTAL, \
"The maximum sleep interval for control loop that drives " \ "The maximum sleep interval for control loop that drives " \
"the cycles. Lower values would increase GC responsiveness " \ "the cycles. Lower values would increase GC responsiveness " \
"to changing heap conditions, at the expense of higher perf " \ "to changing heap conditions, at the expense of higher perf " \
"overhead. Time is in milliseconds.") \ "overhead. Time is in milliseconds.") \
\ \
experimental(uintx, ShenandoahControlIntervalAdjustPeriod, 1000, \ product(uintx, ShenandoahControlIntervalAdjustPeriod, 1000, EXPERIMENTAL, \
"The time period for one step in control loop interval " \ "The time period for one step in control loop interval " \
"adjustment. Lower values make adjustments faster, at the " \ "adjustment. Lower values make adjustments faster, at the " \
"expense of higher perf overhead. Time is in milliseconds.") \ "expense of higher perf overhead. Time is in milliseconds.") \
\ \
diagnostic(bool, ShenandoahVerify, false, \ product(bool, ShenandoahVerify, false, DIAGNOSTIC, \
"Enable internal verification. This would catch many GC bugs, " \ "Enable internal verification. This would catch many GC bugs, " \
"but it would also stall the collector during the verification, " \ "but it would also stall the collector during the verification, " \
"which prolongs the pauses and might hide other bugs.") \ "which prolongs the pauses and might hide other bugs.") \
\ \
diagnostic(intx, ShenandoahVerifyLevel, 4, \ product(intx, ShenandoahVerifyLevel, 4, DIAGNOSTIC, \
"Verification level, higher levels check more, taking more time. "\ "Verification level, higher levels check more, taking more time. "\
"Accepted values are:" \ "Accepted values are:" \
" 0 = basic heap checks; " \ " 0 = basic heap checks; " \
@ -205,34 +199,34 @@
" 3 = previous level, plus all reachable objects; " \ " 3 = previous level, plus all reachable objects; " \
" 4 = previous level, plus all marked objects") \ " 4 = previous level, plus all marked objects") \
\ \
diagnostic(bool, ShenandoahElasticTLAB, true, \ product(bool, ShenandoahElasticTLAB, true, DIAGNOSTIC, \
"Use Elastic TLABs with Shenandoah") \ "Use Elastic TLABs with Shenandoah") \
\ \
experimental(uintx, ShenandoahEvacReserve, 5, \ product(uintx, ShenandoahEvacReserve, 5, EXPERIMENTAL, \
"How much of heap to reserve for evacuations. Larger values make "\ "How much of heap to reserve for evacuations. Larger values make "\
"GC evacuate more live objects on every cycle, while leaving " \ "GC evacuate more live objects on every cycle, while leaving " \
"less headroom for application to allocate in. In percents of " \ "less headroom for application to allocate in. In percents of " \
"total heap size.") \ "total heap size.") \
range(1,100) \ range(1,100) \
\ \
experimental(double, ShenandoahEvacWaste, 1.2, \ product(double, ShenandoahEvacWaste, 1.2, EXPERIMENTAL, \
"How much waste evacuations produce within the reserved space. " \ "How much waste evacuations produce within the reserved space. " \
"Larger values make evacuations more resilient against " \ "Larger values make evacuations more resilient against " \
"evacuation conflicts, at expense of evacuating less on each " \ "evacuation conflicts, at expense of evacuating less on each " \
"GC cycle.") \ "GC cycle.") \
range(1.0,100.0) \ range(1.0,100.0) \
\ \
experimental(bool, ShenandoahEvacReserveOverflow, true, \ product(bool, ShenandoahEvacReserveOverflow, true, EXPERIMENTAL, \
"Allow evacuations to overflow the reserved space. Enabling it " \ "Allow evacuations to overflow the reserved space. Enabling it " \
"will make evacuations more resilient when evacuation " \ "will make evacuations more resilient when evacuation " \
"reserve/waste is incorrect, at the risk that application " \ "reserve/waste is incorrect, at the risk that application " \
"runs out of memory too early.") \ "runs out of memory too early.") \
\ \
experimental(bool, ShenandoahPacing, true, \ product(bool, ShenandoahPacing, true, EXPERIMENTAL, \
"Pace application allocations to give GC chance to start " \ "Pace application allocations to give GC chance to start " \
"and complete before allocation failure is reached.") \ "and complete before allocation failure is reached.") \
\ \
experimental(uintx, ShenandoahPacingMaxDelay, 10, \ product(uintx, ShenandoahPacingMaxDelay, 10, EXPERIMENTAL, \
"Max delay for pacing application allocations. Larger values " \ "Max delay for pacing application allocations. Larger values " \
"provide more resilience against out of memory, at expense at " \ "provide more resilience against out of memory, at expense at " \
"hiding the GC latencies in the allocation path. Time is in " \ "hiding the GC latencies in the allocation path. Time is in " \
@ -240,7 +234,7 @@
"GC effectively stall the threads indefinitely instead of going " \ "GC effectively stall the threads indefinitely instead of going " \
"to degenerated or Full GC.") \ "to degenerated or Full GC.") \
\ \
experimental(uintx, ShenandoahPacingIdleSlack, 2, \ product(uintx, ShenandoahPacingIdleSlack, 2, EXPERIMENTAL, \
"How much of heap counted as non-taxable allocations during idle "\ "How much of heap counted as non-taxable allocations during idle "\
"phases. Larger value makes the pacing milder when collector is " \ "phases. Larger value makes the pacing milder when collector is " \
"idle, requiring less rendezvous with control thread. Lower " \ "idle, requiring less rendezvous with control thread. Lower " \
@ -248,101 +242,101 @@
"allocs. In percent of total heap size.") \ "allocs. In percent of total heap size.") \
range(0, 100) \ range(0, 100) \
\ \
experimental(uintx, ShenandoahPacingCycleSlack, 10, \ product(uintx, ShenandoahPacingCycleSlack, 10, EXPERIMENTAL, \
"How much of free space to take as non-taxable allocations " \ "How much of free space to take as non-taxable allocations " \
"the GC cycle. Larger value makes the pacing milder at the " \ "the GC cycle. Larger value makes the pacing milder at the " \
"beginning of the GC cycle. Lower value makes the pacing less " \ "beginning of the GC cycle. Lower value makes the pacing less " \
"uniform during the cycle. In percent of free space.") \ "uniform during the cycle. In percent of free space.") \
range(0, 100) \ range(0, 100) \
\ \
experimental(double, ShenandoahPacingSurcharge, 1.1, \ product(double, ShenandoahPacingSurcharge, 1.1, EXPERIMENTAL, \
"Additional pacing tax surcharge to help unclutter the heap. " \ "Additional pacing tax surcharge to help unclutter the heap. " \
"Larger values makes the pacing more aggressive. Lower values " \ "Larger values makes the pacing more aggressive. Lower values " \
"risk GC cycles finish with less memory than were available at " \ "risk GC cycles finish with less memory than were available at " \
"the beginning of it.") \ "the beginning of it.") \
range(1.0, 100.0) \ range(1.0, 100.0) \
\ \
experimental(uintx, ShenandoahCriticalFreeThreshold, 1, \ product(uintx, ShenandoahCriticalFreeThreshold, 1, EXPERIMENTAL, \
"How much of the heap needs to be free after recovery cycles, " \ "How much of the heap needs to be free after recovery cycles, " \
"either Degenerated or Full GC to be claimed successful. If this "\ "either Degenerated or Full GC to be claimed successful. If this "\
"much space is not available, next recovery step would be " \ "much space is not available, next recovery step would be " \
"triggered.") \ "triggered.") \
range(0, 100) \ range(0, 100) \
\ \
diagnostic(bool, ShenandoahDegeneratedGC, true, \ product(bool, ShenandoahDegeneratedGC, true, DIAGNOSTIC, \
"Enable Degenerated GC as the graceful degradation step. " \ "Enable Degenerated GC as the graceful degradation step. " \
"Disabling this option leads to degradation to Full GC instead. " \ "Disabling this option leads to degradation to Full GC instead. " \
"When running in passive mode, this can be toggled to measure " \ "When running in passive mode, this can be toggled to measure " \
"either Degenerated GC or Full GC costs.") \ "either Degenerated GC or Full GC costs.") \
\ \
experimental(uintx, ShenandoahFullGCThreshold, 3, \ product(uintx, ShenandoahFullGCThreshold, 3, EXPERIMENTAL, \
"How many back-to-back Degenerated GCs should happen before " \ "How many back-to-back Degenerated GCs should happen before " \
"going to a Full GC.") \ "going to a Full GC.") \
\ \
experimental(bool, ShenandoahImplicitGCInvokesConcurrent, false, \ product(bool, ShenandoahImplicitGCInvokesConcurrent, false, EXPERIMENTAL, \
"Should internally-caused GC requests invoke concurrent cycles, " \ "Should internally-caused GC requests invoke concurrent cycles, " \
"should they do the stop-the-world (Degenerated / Full GC)? " \ "should they do the stop-the-world (Degenerated / Full GC)? " \
"Many heuristics automatically enable this. This option is " \ "Many heuristics automatically enable this. This option is " \
"similar to global ExplicitGCInvokesConcurrent.") \ "similar to global ExplicitGCInvokesConcurrent.") \
\ \
diagnostic(bool, ShenandoahHumongousMoves, true, \ product(bool, ShenandoahHumongousMoves, true, DIAGNOSTIC, \
"Allow moving humongous regions. This makes GC more resistant " \ "Allow moving humongous regions. This makes GC more resistant " \
"to external fragmentation that may otherwise fail other " \ "to external fragmentation that may otherwise fail other " \
"humongous allocations, at the expense of higher GC copying " \ "humongous allocations, at the expense of higher GC copying " \
"costs. Currently affects stop-the-world (Full) cycle only.") \ "costs. Currently affects stop-the-world (Full) cycle only.") \
\ \
diagnostic(bool, ShenandoahOOMDuringEvacALot, false, \ product(bool, ShenandoahOOMDuringEvacALot, false, DIAGNOSTIC, \
"Testing: simulate OOM during evacuation.") \ "Testing: simulate OOM during evacuation.") \
\ \
diagnostic(bool, ShenandoahAllocFailureALot, false, \ product(bool, ShenandoahAllocFailureALot, false, DIAGNOSTIC, \
"Testing: make lots of artificial allocation failures.") \ "Testing: make lots of artificial allocation failures.") \
\ \
experimental(intx, ShenandoahMarkScanPrefetch, 32, \ product(intx, ShenandoahMarkScanPrefetch, 32, EXPERIMENTAL, \
"How many objects to prefetch ahead when traversing mark bitmaps."\ "How many objects to prefetch ahead when traversing mark bitmaps."\
"Set to 0 to disable prefetching.") \ "Set to 0 to disable prefetching.") \
range(0, 256) \ range(0, 256) \
\ \
experimental(uintx, ShenandoahMarkLoopStride, 1000, \ product(uintx, ShenandoahMarkLoopStride, 1000, EXPERIMENTAL, \
"How many items to process during one marking iteration before " \ "How many items to process during one marking iteration before " \
"checking for cancellation, yielding, etc. Larger values improve "\ "checking for cancellation, yielding, etc. Larger values improve "\
"marking performance at expense of responsiveness.") \ "marking performance at expense of responsiveness.") \
\ \
experimental(uintx, ShenandoahParallelRegionStride, 1024, \ product(uintx, ShenandoahParallelRegionStride, 1024, EXPERIMENTAL, \
"How many regions to process at once during parallel region " \ "How many regions to process at once during parallel region " \
"iteration. Affects heaps with lots of regions.") \ "iteration. Affects heaps with lots of regions.") \
\ \
experimental(size_t, ShenandoahSATBBufferSize, 1 * K, \ product(size_t, ShenandoahSATBBufferSize, 1 * K, EXPERIMENTAL, \
"Number of entries in an SATB log buffer.") \ "Number of entries in an SATB log buffer.") \
range(1, max_uintx) \ range(1, max_uintx) \
\ \
experimental(uintx, ShenandoahSATBBufferFlushInterval, 100, \ product(uintx, ShenandoahSATBBufferFlushInterval, 100, EXPERIMENTAL, \
"Forcefully flush non-empty SATB buffers at this interval. " \ "Forcefully flush non-empty SATB buffers at this interval. " \
"Time is in milliseconds.") \ "Time is in milliseconds.") \
\ \
diagnostic(bool, ShenandoahPreclean, true, \ product(bool, ShenandoahPreclean, true, DIAGNOSTIC, \
"Do concurrent preclean phase before final mark: process " \ "Do concurrent preclean phase before final mark: process " \
"definitely alive references to avoid dealing with them during " \ "definitely alive references to avoid dealing with them during " \
"pause.") \ "pause.") \
\ \
experimental(bool, ShenandoahSuspendibleWorkers, false, \ product(bool, ShenandoahSuspendibleWorkers, false, EXPERIMENTAL, \
"Suspend concurrent GC worker threads at safepoints") \ "Suspend concurrent GC worker threads at safepoints") \
\ \
diagnostic(bool, ShenandoahSATBBarrier, true, \ product(bool, ShenandoahSATBBarrier, true, DIAGNOSTIC, \
"Turn on/off SATB barriers in Shenandoah") \ "Turn on/off SATB barriers in Shenandoah") \
\ \
diagnostic(bool, ShenandoahStoreValEnqueueBarrier, false, \ product(bool, ShenandoahStoreValEnqueueBarrier, false, DIAGNOSTIC, \
"Turn on/off enqueuing of oops for storeval barriers") \ "Turn on/off enqueuing of oops for storeval barriers") \
\ \
diagnostic(bool, ShenandoahCASBarrier, true, \ product(bool, ShenandoahCASBarrier, true, DIAGNOSTIC, \
"Turn on/off CAS barriers in Shenandoah") \ "Turn on/off CAS barriers in Shenandoah") \
\ \
diagnostic(bool, ShenandoahCloneBarrier, true, \ product(bool, ShenandoahCloneBarrier, true, DIAGNOSTIC, \
"Turn on/off clone barriers in Shenandoah") \ "Turn on/off clone barriers in Shenandoah") \
\ \
diagnostic(bool, ShenandoahLoadRefBarrier, true, \ product(bool, ShenandoahLoadRefBarrier, true, DIAGNOSTIC, \
"Turn on/off load-reference barriers in Shenandoah") \ "Turn on/off load-reference barriers in Shenandoah") \
\ \
diagnostic(uintx, ShenandoahCodeRootsStyle, 2, \ product(uintx, ShenandoahCodeRootsStyle, 2, DIAGNOSTIC, \
"Use this style to scan the code cache roots:" \ "Use this style to scan the code cache roots:" \
" 0 - sequential iterator;" \ " 0 - sequential iterator;" \
" 1 - parallel iterator;" \ " 1 - parallel iterator;" \
@ -351,12 +345,13 @@
develop(bool, ShenandoahVerifyOptoBarriers, false, \ develop(bool, ShenandoahVerifyOptoBarriers, false, \
"Verify no missing barriers in C2.") \ "Verify no missing barriers in C2.") \
\ \
diagnostic(bool, ShenandoahLoopOptsAfterExpansion, true, \ product(bool, ShenandoahLoopOptsAfterExpansion, true, DIAGNOSTIC, \
"Attempt more loop opts after barrier expansion.") \ "Attempt more loop opts after barrier expansion.") \
\ \
diagnostic(bool, ShenandoahSelfFixing, true, \ product(bool, ShenandoahSelfFixing, true, DIAGNOSTIC, \
"Fix references with load reference barrier. Disabling this " \ "Fix references with load reference barrier. Disabling this " \
"might degrade performance.") \ "might degrade performance.")
// end of GC_SHENANDOAH_FLAGS
#endif // SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP #endif // SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP

20
src/hotspot/share/gc/z/z_globals.hpp
View file

@ -28,13 +28,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
@ -61,23 +55,25 @@
"Uncommit memory if it has been unused for the specified " \ "Uncommit memory if it has been unused for the specified " \
"amount of time (in seconds)") \ "amount of time (in seconds)") \
\ \
diagnostic(uint, ZStatisticsInterval, 10, \ product(uint, ZStatisticsInterval, 10, DIAGNOSTIC, \
"Time between statistics print outs (in seconds)") \ "Time between statistics print outs (in seconds)") \
range(1, (uint)-1) \ range(1, (uint)-1) \
\ \
diagnostic(bool, ZVerifyViews, false, \ product(bool, ZVerifyViews, false, DIAGNOSTIC, \
"Verify heap view accesses") \ "Verify heap view accesses") \
\ \
diagnostic(bool, ZVerifyRoots, trueInDebug, \ product(bool, ZVerifyRoots, trueInDebug, DIAGNOSTIC, \
"Verify roots") \ "Verify roots") \
\ \
diagnostic(bool, ZVerifyObjects, false, \ product(bool, ZVerifyObjects, false, DIAGNOSTIC, \
"Verify objects") \ "Verify objects") \
\ \
diagnostic(bool, ZVerifyMarking, trueInDebug, \ product(bool, ZVerifyMarking, trueInDebug, DIAGNOSTIC, \
"Verify marking stacks") \ "Verify marking stacks") \
\ \
diagnostic(bool, ZVerifyForwarding, false, \ product(bool, ZVerifyForwarding, false, DIAGNOSTIC, \
"Verify forwarding tables") "Verify forwarding tables")
// end of GC_Z_FLAGS
#endif // SHARE_GC_Z_Z_GLOBALS_HPP #endif // SHARE_GC_Z_Z_GLOBALS_HPP

10
src/hotspot/share/jvmci/jvmci_globals.cpp
View file

@ -38,9 +38,9 @@ bool JVMCIGlobals::check_jvmci_flags_are_consistent() {
#ifndef PRODUCT #ifndef PRODUCT
#define APPLY_JVMCI_FLAGS(params3, params4) \ #define APPLY_JVMCI_FLAGS(params3, params4) \
JVMCI_FLAGS(params4, params3, params4, params3, params4, params3, params4, params4, IGNORE_RANGE, IGNORE_CONSTRAINT) JVMCI_FLAGS(params4, params3, params4, params3, params4, IGNORE_RANGE, IGNORE_CONSTRAINT)
#define JVMCI_DECLARE_CHECK4(type, name, value, doc) bool name##checked = false; #define JVMCI_DECLARE_CHECK4(type, name, value, ...) bool name##checked = false;
#define JVMCI_DECLARE_CHECK3(type, name, doc) bool name##checked = false; #define JVMCI_DECLARE_CHECK3(type, name, ...) bool name##checked = false;
#define JVMCI_FLAG_CHECKED(name) name##checked = true; #define JVMCI_FLAG_CHECKED(name) name##checked = true;
APPLY_JVMCI_FLAGS(JVMCI_DECLARE_CHECK3, JVMCI_DECLARE_CHECK4) APPLY_JVMCI_FLAGS(JVMCI_DECLARE_CHECK3, JVMCI_DECLARE_CHECK4)
#else #else
@ -131,8 +131,8 @@ bool JVMCIGlobals::check_jvmci_flags_are_consistent() {
#endif // !COMPILER2 #endif // !COMPILER2
#ifndef PRODUCT #ifndef PRODUCT
#define JVMCI_CHECK4(type, name, value, doc) assert(name##checked, #name " flag not checked"); #define JVMCI_CHECK4(type, name, value, ...) assert(name##checked, #name " flag not checked");
#define JVMCI_CHECK3(type, name, doc) assert(name##checked, #name " flag not checked"); #define JVMCI_CHECK3(type, name, ...) assert(name##checked, #name " flag not checked");
// Ensures that all JVMCI flags are checked by this method. // Ensures that all JVMCI flags are checked by this method.
APPLY_JVMCI_FLAGS(JVMCI_CHECK3, JVMCI_CHECK4) APPLY_JVMCI_FLAGS(JVMCI_CHECK3, JVMCI_CHECK4)
#undef APPLY_JVMCI_FLAGS #undef APPLY_JVMCI_FLAGS

51
src/hotspot/share/jvmci/jvmci_globals.hpp
View file

@ -30,54 +30,51 @@
class fileStream; class fileStream;
// //
// Defines all global flags used by the JVMCI compiler. Only flags that need // Declare all global flags used by the JVMCI compiler. Only flags that need
// to be accessible to the JVMCI C++ code should be defined here. // to be accessible to the JVMCI C++ code should be defined here.
// //
#define JVMCI_FLAGS(develop, \ #define JVMCI_FLAGS(develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
\ \
experimental(bool, EnableJVMCI, false, \ product(bool, EnableJVMCI, false, EXPERIMENTAL, \
"Enable JVMCI") \ "Enable JVMCI") \
\ \
experimental(bool, EnableJVMCIProduct, false, \ product(bool, EnableJVMCIProduct, false, EXPERIMENTAL, \
"Allow JVMCI to be used in product mode. This alters a subset of "\ "Allow JVMCI to be used in product mode. This alters a subset of "\
"JVMCI flags to be non-experimental, defaults UseJVMCICompiler " \ "JVMCI flags to be non-experimental, defaults UseJVMCICompiler " \
"and EnableJVMCI to true and defaults UseJVMCINativeLibrary " \ "and EnableJVMCI to true and defaults UseJVMCINativeLibrary " \
"to true if a JVMCI native library is available.") \ "to true if a JVMCI native library is available.") \
\ \
experimental(bool, UseJVMCICompiler, false, \ product(bool, UseJVMCICompiler, false, EXPERIMENTAL, \
"Use JVMCI as the default compiler. Defaults to true if " \ "Use JVMCI as the default compiler. Defaults to true if " \
"EnableJVMCIProduct is true.") \ "EnableJVMCIProduct is true.") \
\ \
experimental(bool, JVMCIPrintProperties, false, \ product(bool, JVMCIPrintProperties, false, EXPERIMENTAL, \
"Prints properties used by the JVMCI compiler and exits") \ "Prints properties used by the JVMCI compiler and exits") \
\ \
experimental(bool, BootstrapJVMCI, false, \ product(bool, BootstrapJVMCI, false, EXPERIMENTAL, \
"Bootstrap JVMCI before running Java main method. This " \ "Bootstrap JVMCI before running Java main method. This " \
"initializes the compile queue with a small set of methods " \ "initializes the compile queue with a small set of methods " \
"and processes the queue until it is empty. Combining this with " \ "and processes the queue until it is empty. Combining this with " \
"-XX:-TieredCompilation makes JVMCI compile more of itself.") \ "-XX:-TieredCompilation makes JVMCI compile more of itself.") \
\ \
experimental(bool, EagerJVMCI, false, \ product(bool, EagerJVMCI, false, EXPERIMENTAL, \
"Force eager JVMCI initialization") \ "Force eager JVMCI initialization") \
\ \
experimental(bool, PrintBootstrap, true, \ product(bool, PrintBootstrap, true, EXPERIMENTAL, \
"Print JVMCI bootstrap progress and summary") \ "Print JVMCI bootstrap progress and summary") \
\ \
experimental(intx, JVMCIThreads, 1, \ product(intx, JVMCIThreads, 1, EXPERIMENTAL, \
"Force number of JVMCI compiler threads to use. Ignored if " \ "Force number of JVMCI compiler threads to use. Ignored if " \
"UseJVMCICompiler is false.") \ "UseJVMCICompiler is false.") \
range(1, max_jint) \ range(1, max_jint) \
\ \
experimental(intx, JVMCIHostThreads, 1, \ product(intx, JVMCIHostThreads, 1, EXPERIMENTAL, \
"Force number of C1 compiler threads. Ignored if " \ "Force number of C1 compiler threads. Ignored if " \
"UseJVMCICompiler is false.") \ "UseJVMCICompiler is false.") \
range(1, max_jint) \ range(1, max_jint) \
@ -90,56 +87,58 @@ class fileStream;
NOT_COMPILER2(product(bool, ReduceInitialCardMarks, true, \ NOT_COMPILER2(product(bool, ReduceInitialCardMarks, true, \
"Defer write barriers of young objects")) \ "Defer write barriers of young objects")) \
\ \
experimental(intx, JVMCIEventLogLevel, 1, \ product(intx, JVMCIEventLogLevel, 1, EXPERIMENTAL, \
"Event log level for JVMCI") \ "Event log level for JVMCI") \
range(0, 4) \ range(0, 4) \
\ \
experimental(intx, JVMCITraceLevel, 0, \ product(intx, JVMCITraceLevel, 0, EXPERIMENTAL, \
"Trace level for JVMCI") \ "Trace level for JVMCI") \
range(0, 4) \ range(0, 4) \
\ \
experimental(intx, JVMCICounterSize, 0, \ product(intx, JVMCICounterSize, 0, EXPERIMENTAL, \
"Reserved size for benchmark counters") \ "Reserved size for benchmark counters") \
range(0, 1000000) \ range(0, 1000000) \
\ \
experimental(bool, JVMCICountersExcludeCompiler, true, \ product(bool, JVMCICountersExcludeCompiler, true, EXPERIMENTAL, \
"Exclude JVMCI compiler threads from benchmark counters") \ "Exclude JVMCI compiler threads from benchmark counters") \
\ \
develop(bool, JVMCIUseFastLocking, true, \ develop(bool, JVMCIUseFastLocking, true, \
"Use fast inlined locking code") \ "Use fast inlined locking code") \
\ \
experimental(intx, JVMCINMethodSizeLimit, (80*K)*wordSize, \ product(intx, JVMCINMethodSizeLimit, (80*K)*wordSize, EXPERIMENTAL, \
"Maximum size of a compiled method.") \ "Maximum size of a compiled method.") \
range(0, max_jint) \ range(0, max_jint) \
\ \
experimental(ccstr, JVMCILibPath, NULL, \ product(ccstr, JVMCILibPath, NULL, EXPERIMENTAL, \
"LD path for loading the JVMCI shared library") \ "LD path for loading the JVMCI shared library") \
\ \
experimental(ccstr, JVMCILibDumpJNIConfig, NULL, \ product(ccstr, JVMCILibDumpJNIConfig, NULL, EXPERIMENTAL, \
"Dumps to the given file a description of the classes, fields " \ "Dumps to the given file a description of the classes, fields " \
"and methods the JVMCI shared library must provide") \ "and methods the JVMCI shared library must provide") \
\ \
experimental(bool, UseJVMCINativeLibrary, false, \ product(bool, UseJVMCINativeLibrary, false, EXPERIMENTAL, \
"Execute JVMCI Java code from a shared library " \ "Execute JVMCI Java code from a shared library " \
"instead of loading it from class files and executing it " \ "instead of loading it from class files and executing it " \
"on the HotSpot heap. Defaults to true if EnableJVMCIProduct is " \ "on the HotSpot heap. Defaults to true if EnableJVMCIProduct is " \
"true and a JVMCI native library is available.") \ "true and a JVMCI native library is available.") \
\ \
NOT_COMPILER2(diagnostic(bool, UseMultiplyToLenIntrinsic, false, \ NOT_COMPILER2(product(bool, UseMultiplyToLenIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.multiplyToLen()")) \ "Enables intrinsification of BigInteger.multiplyToLen()")) \
\ \
NOT_COMPILER2(diagnostic(bool, UseSquareToLenIntrinsic, false, \ NOT_COMPILER2(product(bool, UseSquareToLenIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.squareToLen()")) \ "Enables intrinsification of BigInteger.squareToLen()")) \
\ \
NOT_COMPILER2(diagnostic(bool, UseMulAddIntrinsic, false, \ NOT_COMPILER2(product(bool, UseMulAddIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.mulAdd()")) \ "Enables intrinsification of BigInteger.mulAdd()")) \
\ \
NOT_COMPILER2(diagnostic(bool, UseMontgomeryMultiplyIntrinsic, false, \ NOT_COMPILER2(product(bool, UseMontgomeryMultiplyIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.montgomeryMultiply()")) \ "Enables intrinsification of BigInteger.montgomeryMultiply()")) \
\ \
NOT_COMPILER2(diagnostic(bool, UseMontgomerySquareIntrinsic, false, \ NOT_COMPILER2(product(bool, UseMontgomerySquareIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.montgomerySquare()")) "Enables intrinsification of BigInteger.montgomerySquare()"))
// end of JVMCI_FLAGS
// The base name for the shared library containing the JVMCI based compiler // The base name for the shared library containing the JVMCI based compiler
#define JVMCI_SHARED_LIBRARY_NAME "jvmcicompiler" #define JVMCI_SHARED_LIBRARY_NAME "jvmcicompiler"

6
src/hotspot/share/jvmci/vmStructs_jvmci.cpp
View file

@ -149,12 +149,6 @@
nonstatic_field(ExceptionTableElement, handler_pc, u2) \ nonstatic_field(ExceptionTableElement, handler_pc, u2) \
nonstatic_field(ExceptionTableElement, catch_type_index, u2) \ nonstatic_field(ExceptionTableElement, catch_type_index, u2) \
\ \
nonstatic_field(JVMFlag, _type, const char*) \
nonstatic_field(JVMFlag, _name, const char*) \
unchecked_nonstatic_field(JVMFlag, _addr, sizeof(void*)) \
nonstatic_field(JVMFlag, _flags, JVMFlag::Flags) \
static_field(JVMFlag, flags, JVMFlag*) \
\
nonstatic_field(InstanceKlass, _fields, Array<u2>*) \ nonstatic_field(InstanceKlass, _fields, Array<u2>*) \
nonstatic_field(InstanceKlass, _constants, ConstantPool*) \ nonstatic_field(InstanceKlass, _constants, ConstantPool*) \
nonstatic_field(InstanceKlass, _init_state, u1) \ nonstatic_field(InstanceKlass, _init_state, u1) \

71
src/hotspot/share/opto/c2_globals.hpp
View file

@ -39,17 +39,14 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
\ \
diagnostic(bool, StressLCM, false, \ product(bool, StressLCM, false, DIAGNOSTIC, \
"Randomize instruction scheduling in LCM") \ "Randomize instruction scheduling in LCM") \
\ \
diagnostic(bool, StressGCM, false, \ product(bool, StressGCM, false, DIAGNOSTIC, \
"Randomize instruction scheduling in GCM") \ "Randomize instruction scheduling in GCM") \
\ \
develop(bool, StressMethodHandleLinkerInlining, false, \ develop(bool, StressMethodHandleLinkerInlining, false, \
@ -116,7 +113,7 @@
"Check performance difference allowing FP " \ "Check performance difference allowing FP " \
"associativity and commutativity...") \ "associativity and commutativity...") \
\ \
diagnostic_pd(bool, IdealizeClearArrayNode, \ product_pd(bool, IdealizeClearArrayNode, DIAGNOSTIC, \
"Replace ClearArrayNode by subgraph of basic operations.") \ "Replace ClearArrayNode by subgraph of basic operations.") \
\ \
develop(bool, OptoBreakpoint, false, \ develop(bool, OptoBreakpoint, false, \
@ -137,7 +134,7 @@
notproduct(bool, PrintOptoStatistics, false, \ notproduct(bool, PrintOptoStatistics, false, \
"Print New compiler statistics") \ "Print New compiler statistics") \
\ \
diagnostic(bool, PrintOptoAssembly, false, \ product(bool, PrintOptoAssembly, false, DIAGNOSTIC, \
"Print New compiler assembly output") \ "Print New compiler assembly output") \
\ \
develop_pd(bool, OptoPeephole, \ develop_pd(bool, OptoPeephole, \
@ -177,13 +174,13 @@
"Map number of unrolls for main loop via " \ "Map number of unrolls for main loop via " \
"Superword Level Parallelism analysis") \ "Superword Level Parallelism analysis") \
\ \
experimental(bool, PostLoopMultiversioning, false, \ product(bool, PostLoopMultiversioning, false, EXPERIMENTAL, \
"Multi versioned post loops to eliminate range checks") \ "Multi versioned post loops to eliminate range checks") \
\ \
notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false, \ notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false, \
"Trace what Superword Level Parallelism analysis applies") \ "Trace what Superword Level Parallelism analysis applies") \
\ \
diagnostic(bool, UseVectorMacroLogic, true, \ product(bool, UseVectorMacroLogic, true, DIAGNOSTIC, \
"Use ternary macro logic instructions") \ "Use ternary macro logic instructions") \
\ \
product(intx, LoopUnrollMin, 4, \ product(intx, LoopUnrollMin, 4, \
@ -482,11 +479,11 @@
notproduct(bool, PrintLockStatistics, false, \ notproduct(bool, PrintLockStatistics, false, \
"Print precise statistics on the dynamic lock usage") \ "Print precise statistics on the dynamic lock usage") \
\ \
diagnostic(bool, PrintPreciseBiasedLockingStatistics, false, \ product(bool, PrintPreciseBiasedLockingStatistics, false, DIAGNOSTIC, \
"(Deprecated) Print per-lock-site statistics of biased locking " \ "(Deprecated) Print per-lock-site statistics of biased locking " \
"in JVM") \ "in JVM") \
\ \
diagnostic(bool, PrintPreciseRTMLockingStatistics, false, \ product(bool, PrintPreciseRTMLockingStatistics, false, DIAGNOSTIC, \
"Print per-lock-site statistics of rtm locking in JVM") \ "Print per-lock-site statistics of rtm locking in JVM") \
\ \
notproduct(bool, PrintEliminateLocks, false, \ notproduct(bool, PrintEliminateLocks, false, \
@ -499,7 +496,7 @@
"Sets max value cached by the java.lang.Integer autobox cache") \ "Sets max value cached by the java.lang.Integer autobox cache") \
range(0, max_jint) \ range(0, max_jint) \
\ \
diagnostic(bool, AggressiveUnboxing, true, \ product(bool, AggressiveUnboxing, true, DIAGNOSTIC, \
"Control optimizations for aggressive boxing elimination") \ "Control optimizations for aggressive boxing elimination") \
\ \
develop(bool, TracePostallocExpand, false, "Trace expanding nodes after" \ develop(bool, TracePostallocExpand, false, "Trace expanding nodes after" \
@ -554,7 +551,7 @@
"Maximum times call Label_Root to prevent stack overflow") \ "Maximum times call Label_Root to prevent stack overflow") \
range(100, max_jint) \ range(100, max_jint) \
\ \
diagnostic(intx, DominatorSearchLimit, 1000, \ product(intx, DominatorSearchLimit, 1000, DIAGNOSTIC, \
"Iterations limit in Node::dominates") \ "Iterations limit in Node::dominates") \
range(0, max_jint) \ range(0, max_jint) \
\ \
@ -569,26 +566,26 @@
product(bool, BlockLayoutRotateLoops, true, \ product(bool, BlockLayoutRotateLoops, true, \
"Allow back branches to be fall throughs in the block layout") \ "Allow back branches to be fall throughs in the block layout") \
\ \
diagnostic(bool, InlineReflectionGetCallerClass, true, \ product(bool, InlineReflectionGetCallerClass, true, DIAGNOSTIC, \
"inline sun.reflect.Reflection.getCallerClass(), known to be " \ "inline sun.reflect.Reflection.getCallerClass(), known to be " \
"part of base library DLL") \ "part of base library DLL") \
\ \
diagnostic(bool, InlineObjectCopy, true, \ product(bool, InlineObjectCopy, true, DIAGNOSTIC, \
"inline Object.clone and Arrays.copyOf[Range] intrinsics") \ "inline Object.clone and Arrays.copyOf[Range] intrinsics") \
\ \
diagnostic(bool, SpecialStringCompareTo, true, \ product(bool, SpecialStringCompareTo, true, DIAGNOSTIC, \
"special version of string compareTo") \ "special version of string compareTo") \
\ \
diagnostic(bool, SpecialStringIndexOf, true, \ product(bool, SpecialStringIndexOf, true, DIAGNOSTIC, \
"special version of string indexOf") \ "special version of string indexOf") \
\ \
diagnostic(bool, SpecialStringEquals, true, \ product(bool, SpecialStringEquals, true, DIAGNOSTIC, \
"special version of string equals") \ "special version of string equals") \
\ \
diagnostic(bool, SpecialArraysEquals, true, \ product(bool, SpecialArraysEquals, true, DIAGNOSTIC, \
"special version of Arrays.equals(char[],char[])") \ "special version of Arrays.equals(char[],char[])") \
\ \
diagnostic(bool, SpecialEncodeISOArray, true, \ product(bool, SpecialEncodeISOArray, true, DIAGNOSTIC, \
"special version of ISO_8859_1$Encoder.encodeISOArray") \ "special version of ISO_8859_1$Encoder.encodeISOArray") \
\ \
develop(bool, BailoutToInterpreterForThrows, false, \ develop(bool, BailoutToInterpreterForThrows, false, \
@ -610,10 +607,10 @@
develop(bool, PrintDominators, false, \ develop(bool, PrintDominators, false, \
"Print out dominator trees for GVN") \ "Print out dominator trees for GVN") \
\ \
diagnostic(bool, TraceSpilling, false, \ product(bool, TraceSpilling, false, DIAGNOSTIC, \
"Trace spilling") \ "Trace spilling") \
\ \
diagnostic(bool, TraceTypeProfile, false, \ product(bool, TraceTypeProfile, false, DIAGNOSTIC, \
"Trace type profile") \ "Trace type profile") \
\ \
develop(bool, PoisonOSREntry, true, \ develop(bool, PoisonOSREntry, true, \
@ -629,19 +626,19 @@
"% of major receiver type to all profiled receivers") \ "% of major receiver type to all profiled receivers") \
range(0, 100) \ range(0, 100) \
\ \
diagnostic(bool, PrintIntrinsics, false, \ product(bool, PrintIntrinsics, false, DIAGNOSTIC, \
"prints attempted and successful inlining of intrinsics") \ "prints attempted and successful inlining of intrinsics") \
\ \
develop(bool, StressReflectiveCode, false, \ develop(bool, StressReflectiveCode, false, \
"Use inexact types at allocations, etc., to test reflection") \ "Use inexact types at allocations, etc., to test reflection") \
\ \
diagnostic(bool, DebugInlinedCalls, true, \ product(bool, DebugInlinedCalls, true, DIAGNOSTIC, \
"If false, restricts profiled locations to the root method only") \ "If false, restricts profiled locations to the root method only") \
\ \
notproduct(bool, VerifyLoopOptimizations, false, \ notproduct(bool, VerifyLoopOptimizations, false, \
"verify major loop optimizations") \ "verify major loop optimizations") \
\ \
diagnostic(bool, ProfileDynamicTypes, true, \ product(bool, ProfileDynamicTypes, true, DIAGNOSTIC, \
"do extra type profiling and use it more aggressively") \ "do extra type profiling and use it more aggressively") \
\ \
develop(bool, TraceIterativeGVN, false, \ develop(bool, TraceIterativeGVN, false, \
@ -710,34 +707,34 @@
"max number of live nodes in a method") \ "max number of live nodes in a method") \
range(0, max_juint / 8) \ range(0, max_juint / 8) \
\ \
diagnostic(bool, OptimizeExpensiveOps, true, \ product(bool, OptimizeExpensiveOps, true, DIAGNOSTIC, \
"Find best control for expensive operations") \ "Find best control for expensive operations") \
\ \
diagnostic(bool, UseMathExactIntrinsics, true, \ product(bool, UseMathExactIntrinsics, true, DIAGNOSTIC, \
"Enables intrinsification of various java.lang.Math functions") \ "Enables intrinsification of various java.lang.Math functions") \
\ \
diagnostic(bool, UseCharacterCompareIntrinsics, false, \ product(bool, UseCharacterCompareIntrinsics, false, DIAGNOSTIC, \
"Enables intrinsification of java.lang.Character functions") \ "Enables intrinsification of java.lang.Character functions") \
\ \
diagnostic(bool, UseMultiplyToLenIntrinsic, false, \ product(bool, UseMultiplyToLenIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.multiplyToLen()") \ "Enables intrinsification of BigInteger.multiplyToLen()") \
\ \
diagnostic(bool, UseSquareToLenIntrinsic, false, \ product(bool, UseSquareToLenIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.squareToLen()") \ "Enables intrinsification of BigInteger.squareToLen()") \
\ \
diagnostic(bool, UseMulAddIntrinsic, false, \ product(bool, UseMulAddIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.mulAdd()") \ "Enables intrinsification of BigInteger.mulAdd()") \
\ \
diagnostic(bool, UseMontgomeryMultiplyIntrinsic, false, \ product(bool, UseMontgomeryMultiplyIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.montgomeryMultiply()") \ "Enables intrinsification of BigInteger.montgomeryMultiply()") \
\ \
diagnostic(bool, UseMontgomerySquareIntrinsic, false, \ product(bool, UseMontgomerySquareIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of BigInteger.montgomerySquare()") \ "Enables intrinsification of BigInteger.montgomerySquare()") \
\ \
product(bool, UseTypeSpeculation, true, \ product(bool, UseTypeSpeculation, true, \
"Speculatively propagate types from profiles") \ "Speculatively propagate types from profiles") \
\ \
diagnostic(bool, UseInlineDepthForSpeculativeTypes, true, \ product(bool, UseInlineDepthForSpeculativeTypes, true, DIAGNOSTIC, \
"Carry inline depth of profile point with speculative type " \ "Carry inline depth of profile point with speculative type " \
"and give priority to profiling from lower inline depth") \ "and give priority to profiling from lower inline depth") \
\ \
@ -768,7 +765,9 @@
product(bool, UseProfiledLoopPredicate, true, \ product(bool, UseProfiledLoopPredicate, true, \
"Move predicates out of loops based on profiling data") \ "Move predicates out of loops based on profiling data") \
\ \
diagnostic(bool, ExpandSubTypeCheckAtParseTime, false, \ product(bool, ExpandSubTypeCheckAtParseTime, false, DIAGNOSTIC, \
"Do not use subtype check macro node") \ "Do not use subtype check macro node")
// end of C2_FLAGS
#endif // SHARE_OPTO_C2_GLOBALS_HPP #endif // SHARE_OPTO_C2_GLOBALS_HPP

5
src/hotspot/share/runtime/arguments.cpp
View file

@ -3898,10 +3898,7 @@ bool Arguments::handle_deprecated_print_gc_flags() {
jint Arguments::parse(const JavaVMInitArgs* initial_cmd_args) { jint Arguments::parse(const JavaVMInitArgs* initial_cmd_args) {
assert(verify_special_jvm_flags(false), "deprecated and obsolete flag table inconsistent"); assert(verify_special_jvm_flags(false), "deprecated and obsolete flag table inconsistent");
JVMFlag::check_all_flag_declarations();
// Initialize ranges and constraints
JVMFlagRangeList::init();
JVMFlagConstraintList::init();
// If flag "-XX:Flags=flags-file" is used it will be the first option to be processed. // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed.
const char* hotspotrc = ".hotspotrc"; const char* hotspotrc = ".hotspotrc";

377
src/hotspot/share/runtime/flags/jvmFlag.cpp
View file

@ -28,6 +28,7 @@
#include "runtime/arguments.hpp" #include "runtime/arguments.hpp"
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagConstraintList.hpp" #include "runtime/flags/jvmFlagConstraintList.hpp"
#include "runtime/flags/jvmFlagLookup.hpp"
#include "runtime/flags/jvmFlagRangeList.hpp" #include "runtime/flags/jvmFlagRangeList.hpp"
#include "runtime/globals_extension.hpp" #include "runtime/globals_extension.hpp"
#include "utilities/defaultStream.hpp" #include "utilities/defaultStream.hpp"
@ -131,7 +132,7 @@ bool JVMFlag::ccstr_accumulates() const {
return strcmp(_type, "ccstrlist") == 0; return strcmp(_type, "ccstrlist") == 0;
} }
JVMFlag::Flags JVMFlag::get_origin() { JVMFlag::Flags JVMFlag::get_origin() const {
return Flags(_flags & VALUE_ORIGIN_MASK); return Flags(_flags & VALUE_ORIGIN_MASK);
} }
@ -141,19 +142,19 @@ void JVMFlag::set_origin(Flags origin) {
_flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | new_origin); _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | new_origin);
} }
bool JVMFlag::is_default() { bool JVMFlag::is_default() const {
return (get_origin() == DEFAULT); return (get_origin() == DEFAULT);
} }
bool JVMFlag::is_ergonomic() { bool JVMFlag::is_ergonomic() const {
return (get_origin() == ERGONOMIC); return (get_origin() == ERGONOMIC);
} }
bool JVMFlag::is_command_line() { bool JVMFlag::is_command_line() const {
return (_flags & ORIG_COMMAND_LINE) != 0; return (_flags & ORIG_COMMAND_LINE) != 0;
} }
bool JVMFlag::is_jimage_resource() { bool JVMFlag::is_jimage_resource() const {
return (get_origin() == JIMAGE_RESOURCE); return (get_origin() == JIMAGE_RESOURCE);
} }
@ -185,10 +186,6 @@ bool JVMFlag::is_develop() const {
return (_flags & KIND_DEVELOP) != 0; return (_flags & KIND_DEVELOP) != 0;
} }
bool JVMFlag::is_read_write() const {
return (_flags & KIND_READ_WRITE) != 0;
}
/** /**
* Returns if this flag is a constant in the binary. Right now this is * Returns if this flag is a constant in the binary. Right now this is
* true for notproduct and develop flags in product builds. * true for notproduct and develop flags in product builds.
@ -266,7 +263,7 @@ JVMFlag::MsgType JVMFlag::get_locked_message(char* buf, int buflen) const {
} }
bool JVMFlag::is_writeable() const { bool JVMFlag::is_writeable() const {
return is_manageable() || (is_product() && is_read_write()); return is_manageable();
} }
// All flags except "manageable" are assumed to be internal flags. // All flags except "manageable" are assumed to be internal flags.
@ -288,7 +285,7 @@ void fill_to_pos(outputStream* st, unsigned int req_pos) {
} }
} }
void JVMFlag::print_on(outputStream* st, bool withComments, bool printRanges) { void JVMFlag::print_on(outputStream* st, bool withComments, bool printRanges) const {
// Don't print notproduct and develop flags in a product build. // Don't print notproduct and develop flags in a product build.
if (is_constant_in_binary()) { if (is_constant_in_binary()) {
return; return;
@ -496,7 +493,7 @@ void JVMFlag::print_on(outputStream* st, bool withComments, bool printRanges) {
} }
} }
void JVMFlag::print_kind(outputStream* st, unsigned int width) { void JVMFlag::print_kind(outputStream* st, unsigned int width) const {
struct Data { struct Data {
int flag; int flag;
const char* name; const char* name;
@ -515,7 +512,6 @@ void JVMFlag::print_kind(outputStream* st, unsigned int width) {
{ KIND_NOT_PRODUCT, "notproduct" }, { KIND_NOT_PRODUCT, "notproduct" },
{ KIND_DEVELOP, "develop" }, { KIND_DEVELOP, "develop" },
{ KIND_LP64_PRODUCT, "lp64_product" }, { KIND_LP64_PRODUCT, "lp64_product" },
{ KIND_READ_WRITE, "rw" },
{ -1, "" } { -1, "" }
}; };
@ -549,7 +545,7 @@ void JVMFlag::print_kind(outputStream* st, unsigned int width) {
} }
} }
void JVMFlag::print_origin(outputStream* st, unsigned int width) { void JVMFlag::print_origin(outputStream* st, unsigned int width) const {
int origin = _flags & VALUE_ORIGIN_MASK; int origin = _flags & VALUE_ORIGIN_MASK;
st->print("{"); st->print("{");
switch(origin) { switch(origin) {
@ -578,7 +574,7 @@ void JVMFlag::print_origin(outputStream* st, unsigned int width) {
st->print("}"); st->print("}");
} }
void JVMFlag::print_as_flag(outputStream* st) { void JVMFlag::print_as_flag(outputStream* st) const {
if (is_bool()) { if (is_bool()) {
st->print("-XX:%s%s", get_bool() ? "+" : "-", _name); st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
} else if (is_int()) { } else if (is_int()) {
@ -633,167 +629,125 @@ const char* JVMFlag::flag_error_str(JVMFlag::Error error) {
} }
} }
// 4991491 do not "optimize out" the was_set false values: omitting them //----------------------------------------------------------------------
// tickles a Microsoft compiler bug causing flagTable to be malformed // Build flagTable[]
#define RUNTIME_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_PRODUCT) }, // Find out the number of LP64/JVMCI/COMPILER1/COMPILER1/ARCH flags,
#define RUNTIME_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT) }, // for JVMFlag::flag_group()
#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_DIAGNOSTIC) },
#define RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_PLATFORM_DEPENDENT) },
#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_EXPERIMENTAL) },
#define RUNTIME_MANAGEABLE_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_MANAGEABLE) },
#define RUNTIME_PRODUCT_RW_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_PRODUCT | JVMFlag::KIND_READ_WRITE) },
#define RUNTIME_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_DEVELOP) },
#define RUNTIME_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT) },
#define RUNTIME_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_NOT_PRODUCT) },
#define JVMCI_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_PRODUCT) }, #define ENUM_F(type, name, ...) enum_##name,
#define JVMCI_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT) }, #define IGNORE_F(...)
#define JVMCI_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_DIAGNOSTIC) },
#define JVMCI_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_PLATFORM_DEPENDENT) },
#define JVMCI_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_EXPERIMENTAL) },
#define JVMCI_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_DEVELOP) },
#define JVMCI_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT) },
#define JVMCI_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_JVMCI | JVMFlag::KIND_NOT_PRODUCT) },
#ifdef _LP64 // dev dev-pd pro pro-pd notpro range constraint
#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_LP64_PRODUCT) }, enum FlagCounter_LP64 { LP64_RUNTIME_FLAGS( ENUM_F, ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F) num_flags_LP64 };
#else enum FlagCounter_JVMCI { JVMCI_ONLY(JVMCI_FLAGS( ENUM_F, ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_JVMCI };
#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ enum FlagCounter_C1 { COMPILER1_PRESENT(C1_FLAGS(ENUM_F, ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_C1 };
#endif // _LP64 enum FlagCounter_C2 { COMPILER2_PRESENT(C2_FLAGS(ENUM_F, ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_C2 };
enum FlagCounter_ARCH { ARCH_FLAGS( ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F) num_flags_ARCH };
#define C1_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_PRODUCT) }, const int first_flag_enum_LP64 = 0;
#define C1_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT) }, const int first_flag_enum_JVMCI = first_flag_enum_LP64 + num_flags_LP64;
#define C1_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_DIAGNOSTIC) }, const int first_flag_enum_C1 = first_flag_enum_JVMCI + num_flags_JVMCI;
#define C1_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_PLATFORM_DEPENDENT) }, const int first_flag_enum_C2 = first_flag_enum_C1 + num_flags_C1;
#define C1_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_DEVELOP) }, const int first_flag_enum_ARCH = first_flag_enum_C2 + num_flags_C2;
#define C1_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT) }, const int first_flag_enum_other = first_flag_enum_ARCH + num_flags_ARCH;
#define C1_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C1 | JVMFlag::KIND_NOT_PRODUCT) },
#define C2_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_PRODUCT) }, static constexpr int flag_group(int flag_enum) {
#define C2_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT) }, if (flag_enum < first_flag_enum_JVMCI) return JVMFlag::KIND_LP64_PRODUCT;
#define C2_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_DIAGNOSTIC) }, if (flag_enum < first_flag_enum_C1) return JVMFlag::KIND_JVMCI;
#define C2_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_PLATFORM_DEPENDENT) }, if (flag_enum < first_flag_enum_C2) return JVMFlag::KIND_C1;
#define C2_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_EXPERIMENTAL) }, if (flag_enum < first_flag_enum_ARCH) return JVMFlag::KIND_C2;
#define C2_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_DEVELOP) }, if (flag_enum < first_flag_enum_other) return JVMFlag::KIND_ARCH;
#define C2_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT) },
#define C2_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_C2 | JVMFlag::KIND_NOT_PRODUCT) },
#define ARCH_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_ARCH | JVMFlag::KIND_PRODUCT) }, return 0;
#define ARCH_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_ARCH | JVMFlag::KIND_DIAGNOSTIC) }, }
#define ARCH_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_ARCH | JVMFlag::KIND_EXPERIMENTAL) },
#define ARCH_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_ARCH | JVMFlag::KIND_DEVELOP) },
#define ARCH_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) JVMFlag::Flags(JVMFlag::DEFAULT | JVMFlag::KIND_ARCH | JVMFlag::KIND_NOT_PRODUCT) },
static JVMFlag flagTable[] = { constexpr JVMFlag::JVMFlag(int flag_enum, const char* type, const char* name,
VM_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ void* addr, int flags, int extra_flags, const char* doc) :
RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ _type(type), _name(name), _addr(addr), _flags() NOT_PRODUCT(COMMA _doc(doc)) {
RUNTIME_PRODUCT_FLAG_STRUCT, \ flags = flags | extra_flags | JVMFlag::DEFAULT | flag_group(flag_enum);
RUNTIME_PD_PRODUCT_FLAG_STRUCT, \ if ((flags & JVMFlag::KIND_PRODUCT) != 0) {
RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \ if (flags & (JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL)) {
RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \ // Backwards compatibility. This will be relaxed in JDK-7123237.
RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \ flags &= ~(JVMFlag::KIND_PRODUCT);
RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ }
RUNTIME_MANAGEABLE_FLAG_STRUCT, \ }
RUNTIME_PRODUCT_RW_FLAG_STRUCT, \ _flags = static_cast<Flags>(flags);
RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \ }
constexpr JVMFlag::JVMFlag(int flag_enum, const char* type, const char* name,
void* addr, int flags, const char* doc) :
JVMFlag(flag_enum, type, name, addr, flags, /*extra_flags*/0, doc) {}
const int PRODUCT_KIND = JVMFlag::KIND_PRODUCT;
const int PRODUCT_KIND_PD = JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT;
const int DEVELOP_KIND = JVMFlag::KIND_DEVELOP;
const int DEVELOP_KIND_PD = JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT;
const int NOTPROD_KIND = JVMFlag::KIND_NOT_PRODUCT;
#define DEVELOP_FLAG_INIT( type, name, value, ...) JVMFlag(FLAG_MEMBER_ENUM(name), #type, XSTR(name), (void*)&name, DEVELOP_KIND, __VA_ARGS__),
#define DEVELOP_FLAG_INIT_PD(type, name, ...) JVMFlag(FLAG_MEMBER_ENUM(name), #type, XSTR(name), (void*)&name, DEVELOP_KIND_PD, __VA_ARGS__),
#define PRODUCT_FLAG_INIT( type, name, value, ...) JVMFlag(FLAG_MEMBER_ENUM(name), #type, XSTR(name), (void*)&name, PRODUCT_KIND, __VA_ARGS__),
#define PRODUCT_FLAG_INIT_PD(type, name, ...) JVMFlag(FLAG_MEMBER_ENUM(name), #type, XSTR(name), (void*)&name, PRODUCT_KIND_PD, __VA_ARGS__),
#define NOTPROD_FLAG_INIT( type, name, value, ...) JVMFlag(FLAG_MEMBER_ENUM(name), #type, XSTR(name), (void*)&name, NOTPROD_KIND, __VA_ARGS__),
// Handy aliases to match the symbols used in the flag specification macros.
const int DIAGNOSTIC = JVMFlag::KIND_DIAGNOSTIC;
const int MANAGEABLE = JVMFlag::KIND_MANAGEABLE;
const int EXPERIMENTAL = JVMFlag::KIND_EXPERIMENTAL;
#define MATERIALIZE_ALL_FLAGS \
ALL_FLAGS(DEVELOP_FLAG_INIT, \
DEVELOP_FLAG_INIT_PD, \
PRODUCT_FLAG_INIT, \
PRODUCT_FLAG_INIT_PD, \
NOTPROD_FLAG_INIT, \
IGNORE_RANGE, \ IGNORE_RANGE, \
IGNORE_CONSTRAINT) IGNORE_CONSTRAINT)
RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ static JVMFlag flagTable[NUM_JVMFlagsEnum + 1] = {
RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ MATERIALIZE_ALL_FLAGS
RUNTIME_PRODUCT_FLAG_STRUCT, \ JVMFlag() // The iteration code wants a flag with a NULL name at the end of the table.
RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT)
#if INCLUDE_JVMCI
JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \
JVMCI_PD_DEVELOP_FLAG_STRUCT, \
JVMCI_PRODUCT_FLAG_STRUCT, \
JVMCI_PD_PRODUCT_FLAG_STRUCT, \
JVMCI_DIAGNOSTIC_FLAG_STRUCT, \
JVMCI_PD_DIAGNOSTIC_FLAG_STRUCT, \
JVMCI_EXPERIMENTAL_FLAG_STRUCT, \
JVMCI_NOTPRODUCT_FLAG_STRUCT, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT)
#endif // INCLUDE_JVMCI
#ifdef COMPILER1
C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, \
C1_PD_DEVELOP_FLAG_STRUCT, \
C1_PRODUCT_FLAG_STRUCT, \
C1_PD_PRODUCT_FLAG_STRUCT, \
C1_DIAGNOSTIC_FLAG_STRUCT, \
C1_PD_DIAGNOSTIC_FLAG_STRUCT, \
C1_NOTPRODUCT_FLAG_STRUCT, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT)
#endif // COMPILER1
#ifdef COMPILER2
C2_FLAGS(C2_DEVELOP_FLAG_STRUCT, \
C2_PD_DEVELOP_FLAG_STRUCT, \
C2_PRODUCT_FLAG_STRUCT, \
C2_PD_PRODUCT_FLAG_STRUCT, \
C2_DIAGNOSTIC_FLAG_STRUCT, \
C2_PD_DIAGNOSTIC_FLAG_STRUCT, \
C2_EXPERIMENTAL_FLAG_STRUCT, \
C2_NOTPRODUCT_FLAG_STRUCT, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT)
#endif // COMPILER2
ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, \
ARCH_PRODUCT_FLAG_STRUCT, \
ARCH_DIAGNOSTIC_FLAG_STRUCT, \
ARCH_EXPERIMENTAL_FLAG_STRUCT, \
ARCH_NOTPRODUCT_FLAG_STRUCT, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT)
{0, NULL, NULL}
}; };
// We want flagTable[] to be completely initialized at C++ compilation time, which requires
// that all arguments passed to JVMFlag() constructors be constexpr. The following line
// checks for this -- if any non-constexpr arguments are passed, the C++ compiler will
// generate an error.
//
// constexpr implies internal linkage. This means the flagTable_verify_constexpr[] variable
// will not be included in jvmFlag.o, so there's no footprint cost for having this variable.
//
// Note that we cannot declare flagTable[] as constexpr because JVMFlag::_flags is modified
// at runtime.
constexpr JVMFlag flagTable_verify_constexpr[] = { MATERIALIZE_ALL_FLAGS };
JVMFlag* JVMFlag::flags = flagTable; JVMFlag* JVMFlag::flags = flagTable;
size_t JVMFlag::numFlags = (sizeof(flagTable) / sizeof(JVMFlag)); size_t JVMFlag::numFlags = (sizeof(flagTable) / sizeof(JVMFlag));
inline bool str_equal(const char* s, size_t s_len, const char* q, size_t q_len) {
if (s_len != q_len) return false;
return memcmp(s, q, q_len) == 0;
}
// Search the flag table for a named flag // Search the flag table for a named flag
JVMFlag* JVMFlag::find_flag(const char* name, size_t length, bool allow_locked, bool return_flag) { JVMFlag* JVMFlag::find_flag(const char* name, size_t length, bool allow_locked, bool return_flag) {
for (JVMFlag* current = &flagTable[0]; current->_name != NULL; current++) { JVMFlag* flag = JVMFlagLookup::find(name, length);
if (str_equal(current->_name, current->get_name_length(), name, length)) { if (flag != NULL) {
// Found a matching entry. // Found a matching entry.
// Don't report notproduct and develop flags in product builds. // Don't report notproduct and develop flags in product builds.
if (current->is_constant_in_binary()) { if (flag->is_constant_in_binary()) {
return (return_flag ? current : NULL); return (return_flag ? flag : NULL);
} }
// Report locked flags only if allowed. // Report locked flags only if allowed.
if (!(current->is_unlocked() || current->is_unlocker())) { if (!(flag->is_unlocked() || flag->is_unlocker())) {
if (!allow_locked) { if (!allow_locked) {
// disable use of locked flags, e.g. diagnostic, experimental, // disable use of locked flags, e.g. diagnostic, experimental,
// etc. until they are explicitly unlocked // etc. until they are explicitly unlocked
return NULL; return NULL;
} }
} }
return current; return flag;
}
} }
// JVMFlag name is not in the flag table // JVMFlag name is not in the flag table
return NULL; return NULL;
} }
// Get or compute the flag name length
size_t JVMFlag::get_name_length() {
if (_name_len == 0) {
_name_len = strlen(_name);
}
return _name_len;
}
JVMFlag* JVMFlag::fuzzy_match(const char* name, size_t length, bool allow_locked) { JVMFlag* JVMFlag::fuzzy_match(const char* name, size_t length, bool allow_locked) {
float VMOptionsFuzzyMatchSimilarity = 0.7f; float VMOptionsFuzzyMatchSimilarity = 0.7f;
JVMFlag* match = NULL; JVMFlag* match = NULL;
@ -856,7 +810,7 @@ void JVMFlagEx::setOnCmdLine(JVMFlagsEnum flag) {
} }
template<class E, class T> template<class E, class T>
static void trace_flag_changed(const JVMFlag* flag, const T old_value, const T new_value, const JVMFlag::Flags origin) { static void trace_flag_changed(JVMFlag* flag, const T old_value, const T new_value, const JVMFlag::Flags origin) {
E e; E e;
e.set_name(flag->_name); e.set_name(flag->_name);
e.set_oldValue(old_value); e.set_oldValue(old_value);
@ -865,11 +819,11 @@ static void trace_flag_changed(const JVMFlag* flag, const T old_value, const T n
e.commit(); e.commit();
} }
static JVMFlag::Error apply_constraint_and_check_range_bool(const JVMFlag* flag, bool new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_bool(JVMFlag* flag, bool new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_bool(new_value, verbose); status = constraint.apply_bool(new_value, verbose);
} }
return status; return status;
} }
@ -900,16 +854,16 @@ JVMFlag::Error JVMFlagEx::boolAtPut(JVMFlagsEnum flag, bool value, JVMFlag::Flag
return JVMFlag::boolAtPut(faddr, &value, origin); return JVMFlag::boolAtPut(faddr, &value, origin);
} }
static JVMFlag::Error apply_constraint_and_check_range_int(const JVMFlag* flag, int new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_int(JVMFlag* flag, int new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_int(new_value, verbose); status = range.check_int(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_int(new_value, verbose); status = constraint.apply_int(new_value, verbose);
} }
} }
return status; return status;
@ -941,16 +895,16 @@ JVMFlag::Error JVMFlagEx::intAtPut(JVMFlagsEnum flag, int value, JVMFlag::Flags
return JVMFlag::intAtPut(faddr, &value, origin); return JVMFlag::intAtPut(faddr, &value, origin);
} }
static JVMFlag::Error apply_constraint_and_check_range_uint(const JVMFlag* flag, uint new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_uint(JVMFlag* flag, uint new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_uint(new_value, verbose); status = range.check_uint(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_uint(new_value, verbose); status = constraint.apply_uint(new_value, verbose);
} }
} }
return status; return status;
@ -989,16 +943,16 @@ JVMFlag::Error JVMFlag::intxAt(const JVMFlag* flag, intx* value) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
static JVMFlag::Error apply_constraint_and_check_range_intx(const JVMFlag* flag, intx new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_intx(JVMFlag* flag, intx new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_intx(new_value, verbose); status = range.check_intx(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_intx(new_value, verbose); status = constraint.apply_intx(new_value, verbose);
} }
} }
return status; return status;
@ -1030,16 +984,16 @@ JVMFlag::Error JVMFlag::uintxAt(const JVMFlag* flag, uintx* value) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
static JVMFlag::Error apply_constraint_and_check_range_uintx(const JVMFlag* flag, uintx new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_uintx(JVMFlag* flag, uintx new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_uintx(new_value, verbose); status = range.check_uintx(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_uintx(new_value, verbose); status = constraint.apply_uintx(new_value, verbose);
} }
} }
return status; return status;
@ -1071,16 +1025,16 @@ JVMFlag::Error JVMFlag::uint64_tAt(const JVMFlag* flag, uint64_t* value) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
static JVMFlag::Error apply_constraint_and_check_range_uint64_t(const JVMFlag* flag, uint64_t new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_uint64_t(JVMFlag* flag, uint64_t new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_uint64_t(new_value, verbose); status = range.check_uint64_t(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_uint64_t(new_value, verbose); status = constraint.apply_uint64_t(new_value, verbose);
} }
} }
return status; return status;
@ -1112,16 +1066,16 @@ JVMFlag::Error JVMFlag::size_tAt(const JVMFlag* flag, size_t* value) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
static JVMFlag::Error apply_constraint_and_check_range_size_t(const JVMFlag* flag, size_t new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_size_t(JVMFlag* flag, size_t new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_size_t(new_value, verbose); status = range.check_size_t(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_size_t(new_value, verbose); status = constraint.apply_size_t(new_value, verbose);
} }
} }
return status; return status;
@ -1154,16 +1108,16 @@ JVMFlag::Error JVMFlag::doubleAt(const JVMFlag* flag, double* value) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
static JVMFlag::Error apply_constraint_and_check_range_double(const JVMFlag* flag, double new_value, bool verbose) { static JVMFlag::Error apply_constraint_and_check_range_double(JVMFlag* flag, double new_value, bool verbose) {
JVMFlag::Error status = JVMFlag::SUCCESS; JVMFlag::Error status = JVMFlag::SUCCESS;
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
status = range->check_double(new_value, verbose); status = range.check_double(new_value, verbose);
} }
if (status == JVMFlag::SUCCESS) { if (status == JVMFlag::SUCCESS) {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find_if_needs_check(flag);
if (constraint != NULL) { if (constraint.exists()) {
status = constraint->apply_double(new_value, verbose); status = constraint.apply_double(new_value, verbose);
} }
} }
return status; return status;
@ -1269,6 +1223,33 @@ void JVMFlag::verify() {
#endif // PRODUCT #endif // PRODUCT
#ifdef ASSERT
void JVMFlag::assert_valid_flag_enum(int i) {
assert(0 <= i && i < NUM_JVMFlagsEnum, "must be");
}
void JVMFlag::check_all_flag_declarations() {
for (JVMFlag* current = &flagTable[0]; current->_name != NULL; current++) {
int flags = static_cast<int>(current->_flags);
// Backwards compatibility. This will be relaxed/removed in JDK-7123237.
int mask = JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL;
if ((flags & mask) != 0) {
assert((flags & mask) == JVMFlag::KIND_DIAGNOSTIC ||
(flags & mask) == JVMFlag::KIND_MANAGEABLE ||
(flags & mask) == JVMFlag::KIND_EXPERIMENTAL,
"%s can be declared with at most one of "
"DIAGNOSTIC, MANAGEABLE or EXPERIMENTAL", current->_name);
assert((flags & KIND_NOT_PRODUCT) == 0 &&
(flags & KIND_DEVELOP) == 0,
"%s has an optional DIAGNOSTIC, MANAGEABLE or EXPERIMENTAL "
"attribute; it must be declared as a product flag", current->_name);
}
}
}
#endif // ASSERT
void JVMFlag::printFlags(outputStream* out, bool withComments, bool printRanges, bool skipDefaults) { void JVMFlag::printFlags(outputStream* out, bool withComments, bool printRanges, bool skipDefaults) {
// Print the flags sorted by name // Print the flags sorted by name
// Note: This method may be called before the thread structure is in place // Note: This method may be called before the thread structure is in place

83
src/hotspot/share/runtime/flags/jvmFlag.hpp
View file

@ -34,7 +34,7 @@ class outputStream;
typedef const char* (*RangeStrFunc)(void); typedef const char* (*RangeStrFunc)(void);
struct JVMFlag { struct JVMFlag {
enum Flags { enum Flags : int {
// latest value origin // latest value origin
DEFAULT = 0, DEFAULT = 0,
COMMAND_LINE = 1, COMMAND_LINE = 1,
@ -58,12 +58,11 @@ struct JVMFlag {
KIND_NOT_PRODUCT = 1 << 8, KIND_NOT_PRODUCT = 1 << 8,
KIND_DEVELOP = 1 << 9, KIND_DEVELOP = 1 << 9,
KIND_PLATFORM_DEPENDENT = 1 << 10, KIND_PLATFORM_DEPENDENT = 1 << 10,
KIND_READ_WRITE = 1 << 11, KIND_C1 = 1 << 11,
KIND_C1 = 1 << 12, KIND_C2 = 1 << 12,
KIND_C2 = 1 << 13, KIND_ARCH = 1 << 13,
KIND_ARCH = 1 << 14, KIND_LP64_PRODUCT = 1 << 14,
KIND_LP64_PRODUCT = 1 << 15, KIND_JVMCI = 1 << 15,
KIND_JVMCI = 1 << 16,
// set this bit if the flag was set on the command line // set this bit if the flag was set on the command line
ORIG_COMMAND_LINE = 1 << 17, ORIG_COMMAND_LINE = 1 << 17,
@ -109,9 +108,8 @@ struct JVMFlag {
const char* _type; const char* _type;
const char* _name; const char* _name;
void* _addr; void* _addr;
NOT_PRODUCT(const char* _doc;)
Flags _flags; Flags _flags;
size_t _name_len; NOT_PRODUCT(const char* _doc;)
// points to all Flags static array // points to all Flags static array
static JVMFlag* flags; static JVMFlag* flags;
@ -123,13 +121,21 @@ private:
static JVMFlag* find_flag(const char* name, size_t length, bool allow_locked, bool return_flag); static JVMFlag* find_flag(const char* name, size_t length, bool allow_locked, bool return_flag);
public: public:
constexpr JVMFlag() : _type(), _name(), _addr(), _flags() NOT_PRODUCT(COMMA _doc()) {}
constexpr JVMFlag(int flag_enum, const char* type, const char* name,
void* addr, int flags, int extra_flags, const char* doc);
constexpr JVMFlag(int flag_enum, const char* type, const char* name,
void* addr, int flags, const char* doc);
static JVMFlag* find_flag(const char* name) { static JVMFlag* find_flag(const char* name) {
return find_flag(name, strlen(name), false, false); return find_flag(name, strlen(name), false, false);
} }
static const JVMFlag* find_declared_flag(const char* name, size_t length) { static JVMFlag* find_declared_flag(const char* name, size_t length) {
return find_flag(name, length, true, true); return find_flag(name, length, true, true);
} }
static const JVMFlag* find_declared_flag(const char* name) { static JVMFlag* find_declared_flag(const char* name) {
return find_declared_flag(name, strlen(name)); return find_declared_flag(name, strlen(name));
} }
@ -143,52 +149,64 @@ public:
static const char* get_size_t_default_range_str(); static const char* get_size_t_default_range_str();
static const char* get_double_default_range_str(); static const char* get_double_default_range_str();
static void assert_valid_flag_enum(int i) NOT_DEBUG_RETURN;
static void check_all_flag_declarations() NOT_DEBUG_RETURN;
inline int flag_enum() const {
int i = this - JVMFlag::flags;
assert_valid_flag_enum(i);
return i;
}
static JVMFlag* flag_from_enum(int flag_enum) {
assert_valid_flag_enum(flag_enum);
return &JVMFlag::flags[flag_enum];
}
bool is_bool() const; bool is_bool() const;
bool get_bool() const { return *((bool*) _addr); } bool get_bool() const { return *((bool*) _addr); }
void set_bool(bool value) { *((bool*) _addr) = value; } void set_bool(bool value) const { *((bool*) _addr) = value; }
bool is_int() const; bool is_int() const;
int get_int() const { return *((int*) _addr); } int get_int() const { return *((int*) _addr); }
void set_int(int value) { *((int*) _addr) = value; } void set_int(int value) const { *((int*) _addr) = value; }
bool is_uint() const; bool is_uint() const;
uint get_uint() const { return *((uint*) _addr); } uint get_uint() const { return *((uint*) _addr); }
void set_uint(uint value) { *((uint*) _addr) = value; } void set_uint(uint value) const { *((uint*) _addr) = value; }
bool is_intx() const; bool is_intx() const;
intx get_intx() const { return *((intx*) _addr); } intx get_intx() const { return *((intx*) _addr); }
void set_intx(intx value) { *((intx*) _addr) = value; } void set_intx(intx value) const { *((intx*) _addr) = value; }
bool is_uintx() const; bool is_uintx() const;
uintx get_uintx() const { return *((uintx*) _addr); } uintx get_uintx() const { return *((uintx*) _addr); }
void set_uintx(uintx value) { *((uintx*) _addr) = value; } void set_uintx(uintx value) const { *((uintx*) _addr) = value; }
bool is_uint64_t() const; bool is_uint64_t() const;
uint64_t get_uint64_t() const { return *((uint64_t*) _addr); } uint64_t get_uint64_t() const { return *((uint64_t*) _addr); }
void set_uint64_t(uint64_t value) { *((uint64_t*) _addr) = value; } void set_uint64_t(uint64_t value) const { *((uint64_t*) _addr) = value; }
bool is_size_t() const; bool is_size_t() const;
size_t get_size_t() const { return *((size_t*) _addr); } size_t get_size_t() const { return *((size_t*) _addr); }
void set_size_t(size_t value) { *((size_t*) _addr) = value; } void set_size_t(size_t value) const { *((size_t*) _addr) = value; }
bool is_double() const; bool is_double() const;
double get_double() const { return *((double*) _addr); } double get_double() const { return *((double*) _addr); }
void set_double(double value) { *((double*) _addr) = value; } void set_double(double value) const { *((double*) _addr) = value; }
bool is_ccstr() const; bool is_ccstr() const;
bool ccstr_accumulates() const; bool ccstr_accumulates() const;
ccstr get_ccstr() const { return *((ccstr*) _addr); } ccstr get_ccstr() const { return *((ccstr*) _addr); }
void set_ccstr(ccstr value) { *((ccstr*) _addr) = value; } void set_ccstr(ccstr value) const { *((ccstr*) _addr) = value; }
Flags get_origin(); Flags get_origin() const;
void set_origin(Flags origin); void set_origin(Flags origin);
size_t get_name_length(); bool is_default() const;
bool is_ergonomic() const;
bool is_default(); bool is_jimage_resource() const;
bool is_ergonomic(); bool is_command_line() const;
bool is_jimage_resource();
bool is_command_line();
void set_command_line(); void set_command_line();
bool is_product() const; bool is_product() const;
@ -197,7 +215,6 @@ public:
bool is_experimental() const; bool is_experimental() const;
bool is_notproduct() const; bool is_notproduct() const;
bool is_develop() const; bool is_develop() const;
bool is_read_write() const;
bool is_constant_in_binary() const; bool is_constant_in_binary() const;
@ -214,10 +231,10 @@ public:
JVMFlag::MsgType get_locked_message_ext(char*, int) const; JVMFlag::MsgType get_locked_message_ext(char*, int) const;
// printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
void print_on(outputStream* st, bool withComments = false, bool printRanges = false); void print_on(outputStream* st, bool withComments = false, bool printRanges = false) const;
void print_kind(outputStream* st, unsigned int width); void print_kind(outputStream* st, unsigned int width) const;
void print_origin(outputStream* st, unsigned int width); void print_origin(outputStream* st, unsigned int width) const;
void print_as_flag(outputStream* st); void print_as_flag(outputStream* st) const;
static const char* flag_error_str(JVMFlag::Error error); static const char* flag_error_str(JVMFlag::Error error);
@ -260,4 +277,6 @@ public:
static void verify() PRODUCT_RETURN; static void verify() PRODUCT_RETURN;
}; };
#define DECLARE_CONSTRAINT(type, func) JVMFlag::Error func(type value, bool verbose);
#endif // SHARE_RUNTIME_FLAGS_JVMFLAG_HPP #endif // SHARE_RUNTIME_FLAGS_JVMFLAG_HPP

149
src/hotspot/share/runtime/flags/jvmFlagConstraintList.cpp
View file

@ -172,125 +172,43 @@ public:
} }
}; };
// No constraint emitting #define DEFINE_CONSTRAINT_APPLY(T) \
void emit_constraint_no(...) { /* NOP */ } JVMFlag::Error JVMFlagConstraintChecker::apply_ ## T(T value, bool verbose) const { \
assert(exists(), "must be"); \
// No constraint emitting if function argument is NOT provided JVMFlagConstraint_ ## T constraint(_flag, \
void emit_constraint_bool(const JVMFlag* /*flag*/) { /* NOP */ } (JVMFlagConstraintFunc_ ## T)_limit->constraint_func(), \
void emit_constraint_ccstr(const JVMFlag* /*flag*/) { /* NOP */ } (JVMFlagConstraint::ConstraintType)_limit->phase()); \
void emit_constraint_ccstrlist(const JVMFlag* /*flag*/) { /* NOP */ } return constraint.apply_ ## T(value, verbose); \
void emit_constraint_int(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_intx(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_uint(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_uintx(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_uint64_t(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_size_t(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_constraint_double(const JVMFlag* /*flag*/) { /* NOP */ }
// JVMFlagConstraint emitting code functions if function argument is provided
void emit_constraint_bool(const JVMFlag* flag, JVMFlagConstraintFunc_bool func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_bool(flag, func, type));
}
void emit_constraint_int(const JVMFlag* flag, JVMFlagConstraintFunc_int func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_int(flag, func, type));
}
void emit_constraint_intx(const JVMFlag* flag, JVMFlagConstraintFunc_intx func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_intx(flag, func, type));
}
void emit_constraint_uint(const JVMFlag* flag, JVMFlagConstraintFunc_uint func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_uint(flag, func, type));
}
void emit_constraint_uintx(const JVMFlag* flag, JVMFlagConstraintFunc_uintx func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_uintx(flag, func, type));
}
void emit_constraint_uint64_t(const JVMFlag* flag, JVMFlagConstraintFunc_uint64_t func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_uint64_t(flag, func, type));
}
void emit_constraint_size_t(const JVMFlag* flag, JVMFlagConstraintFunc_size_t func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_size_t(flag, func, type));
}
void emit_constraint_double(const JVMFlag* flag, JVMFlagConstraintFunc_double func, JVMFlagConstraint::ConstraintType type) {
JVMFlagConstraintList::add(new JVMFlagConstraint_double(flag, func, type));
} }
// Generate code to call emit_constraint_xxx function ALL_CONSTRAINT_TYPES(DEFINE_CONSTRAINT_APPLY)
#define EMIT_CONSTRAINT_START (void)(0
#define EMIT_CONSTRAINT(type, name) ); emit_constraint_##type(JVMFlagEx::flag_from_enum(FLAG_MEMBER_ENUM(name))
#define EMIT_CONSTRAINT_NO ); emit_constraint_no(0 JVMFlag::Error JVMFlagConstraintChecker::apply(bool verbose) const {
#define EMIT_CONSTRAINT_PRODUCT_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) #define APPLY_CONSTRAINT(T) \
#define EMIT_CONSTRAINT_DIAGNOSTIC_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) if (_flag->is_ ## T()) { \
#define EMIT_CONSTRAINT_EXPERIMENTAL_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) JVMFlagConstraint_ ## T constraint(_flag, \
#define EMIT_CONSTRAINT_MANAGEABLE_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) (JVMFlagConstraintFunc_ ## T)_limit->constraint_func(), \
#define EMIT_CONSTRAINT_PRODUCT_RW_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) (JVMFlagConstraint::ConstraintType)_limit->phase()); \
#define EMIT_CONSTRAINT_PD_PRODUCT_FLAG(type, name, doc) EMIT_CONSTRAINT(type, name) return constraint.apply(verbose); \
#define EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG(type, name, doc) EMIT_CONSTRAINT(type, name) }
#ifndef PRODUCT
#define EMIT_CONSTRAINT_DEVELOPER_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) ALL_CONSTRAINT_TYPES(APPLY_CONSTRAINT);
#define EMIT_CONSTRAINT_PD_DEVELOPER_FLAG(type, name, doc) EMIT_CONSTRAINT(type, name)
#define EMIT_CONSTRAINT_NOTPRODUCT_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name) ShouldNotReachHere();
#else return JVMFlag::INVALID_FLAG;
#define EMIT_CONSTRAINT_DEVELOPER_FLAG(type, name, value, doc) EMIT_CONSTRAINT_NO }
#define EMIT_CONSTRAINT_PD_DEVELOPER_FLAG(type, name, doc) EMIT_CONSTRAINT_NO
#define EMIT_CONSTRAINT_NOTPRODUCT_FLAG(type, name, value, doc) EMIT_CONSTRAINT_NO
#endif
#ifdef _LP64
#define EMIT_CONSTRAINT_LP64_PRODUCT_FLAG(type, name, value, doc) EMIT_CONSTRAINT(type, name)
#else
#define EMIT_CONSTRAINT_LP64_PRODUCT_FLAG(type, name, value, doc) EMIT_CONSTRAINT_NO
#endif
#define EMIT_CONSTRAINT_END );
// Generate func argument to pass into emit_constraint_xxx functions
#define EMIT_CONSTRAINT_CHECK(func, type) , func, JVMFlagConstraint::type
// the "name" argument must be a string literal
#define INITIAL_CONSTRAINTS_SIZE 72
GrowableArray<JVMFlagConstraint*>* JVMFlagConstraintList::_constraints = NULL;
JVMFlagConstraint::ConstraintType JVMFlagConstraintList::_validating_type = JVMFlagConstraint::AtParse; JVMFlagConstraint::ConstraintType JVMFlagConstraintList::_validating_type = JVMFlagConstraint::AtParse;
// Check the ranges of all flags that have them or print them out and exit if requested
void JVMFlagConstraintList::init(void) {
_constraints = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<JVMFlagConstraint*>(INITIAL_CONSTRAINTS_SIZE, mtArguments);
EMIT_CONSTRAINT_START
ALL_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
EMIT_CONSTRAINT_PRODUCT_FLAG,
EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
EMIT_CONSTRAINT_MANAGEABLE_FLAG,
EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
EMIT_CONSTRAINT_LP64_PRODUCT_FLAG,
IGNORE_RANGE,
EMIT_CONSTRAINT_CHECK)
EMIT_CONSTRAINT_END
}
JVMFlagConstraint* JVMFlagConstraintList::find(const JVMFlag* flag) {
JVMFlagConstraint* found = NULL;
for (int i=0; i<length(); i++) {
JVMFlagConstraint* constraint = at(i);
if (constraint->flag() == flag) {
found = constraint;
break;
}
}
return found;
}
// Find constraints and return only if found constraint's type is equal or lower than current validating type. // Find constraints and return only if found constraint's type is equal or lower than current validating type.
JVMFlagConstraint* JVMFlagConstraintList::find_if_needs_check(const JVMFlag* flag) { JVMFlagConstraintChecker JVMFlagConstraintList::find_if_needs_check(const JVMFlag* flag) {
JVMFlagConstraint* found = NULL; JVMFlagConstraintChecker constraint = JVMFlagConstraintList::find(flag);
JVMFlagConstraint* constraint = find(flag); if (constraint.exists() && (constraint.type() <= _validating_type)) {
if (constraint != NULL && (constraint->type() <= _validating_type)) { return constraint;
found = constraint;
} }
return found; return JVMFlagConstraintChecker(flag, NULL);
} }
// Check constraints for specific constraint type. // Check constraints for specific constraint type.
@ -299,10 +217,11 @@ bool JVMFlagConstraintList::check_constraints(JVMFlagConstraint::ConstraintType
_validating_type = type; _validating_type = type;
bool status = true; bool status = true;
for (int i=0; i<length(); i++) { for (int i = 0; i < NUM_JVMFlagsEnum; i++) {
JVMFlagConstraint* constraint = at(i); JVMFlagConstraintChecker constraint(&JVMFlag::flags[i], JVMFlagLimit::get_constraint_at(i));
if (type != constraint->type()) continue; if (!constraint.exists()) continue;
if (constraint->apply(true) != JVMFlag::SUCCESS) status = false; if (type != constraint.type()) continue;
if (constraint.apply(true) != JVMFlag::SUCCESS) status = false;
} }
return status; return status;
} }

26
src/hotspot/share/runtime/flags/jvmFlagConstraintList.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -26,7 +26,7 @@
#define SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTLIST_HPP #define SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTLIST_HPP
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "utilities/growableArray.hpp" #include "runtime/flags/jvmFlagLimit.hpp"
/* /*
* Here we have a mechanism for extracting constraints (as custom functions) for flags, * Here we have a mechanism for extracting constraints (as custom functions) for flags,
@ -83,18 +83,28 @@ public:
virtual JVMFlag::Error apply_double(double value, bool verbose = true) { ShouldNotReachHere(); return JVMFlag::ERR_OTHER; }; virtual JVMFlag::Error apply_double(double value, bool verbose = true) { ShouldNotReachHere(); return JVMFlag::ERR_OTHER; };
}; };
class JVMFlagConstraintChecker {
const JVMFlag* _flag;
const JVMFlagLimit* _limit;
public:
JVMFlagConstraintChecker(const JVMFlag* flag, const JVMFlagLimit* limit) : _flag(flag), _limit(limit) {}
bool exists() const { return _limit != NULL; }
JVMFlag::Error apply(bool verbose = true) const;
JVMFlagConstraint::ConstraintType type() const { return (JVMFlagConstraint::ConstraintType)_limit->phase(); }
#define DECLARE_CONSTRAINT_APPLY(T) JVMFlag::Error apply_ ## T(T new_value, bool verbose = true) const;
ALL_CONSTRAINT_TYPES(DECLARE_CONSTRAINT_APPLY)
};
class JVMFlagConstraintList : public AllStatic { class JVMFlagConstraintList : public AllStatic {
private: private:
static GrowableArray<JVMFlagConstraint*>* _constraints;
// Latest constraint validation type. // Latest constraint validation type.
static JVMFlagConstraint::ConstraintType _validating_type; static JVMFlagConstraint::ConstraintType _validating_type;
public: public:
static void init(); static void init();
static int length() { return (_constraints != NULL) ? _constraints->length() : 0; } static JVMFlagConstraintChecker find(const JVMFlag* flag) { return JVMFlagConstraintChecker(flag, JVMFlagLimit::get_constraint(flag)); }
static JVMFlagConstraint* at(int i) { return (_constraints != NULL) ? _constraints->at(i) : NULL; } static JVMFlagConstraintChecker find_if_needs_check(const JVMFlag* flag);
static JVMFlagConstraint* find(const JVMFlag* flag);
static JVMFlagConstraint* find_if_needs_check(const JVMFlag* flag);
static void add(JVMFlagConstraint* constraint) { _constraints->append(constraint); }
// True if 'AfterErgo' or later constraint functions are validated. // True if 'AfterErgo' or later constraint functions are validated.
static bool validated_after_ergo() { return _validating_type >= JVMFlagConstraint::AfterErgo; }; static bool validated_after_ergo() { return _validating_type >= JVMFlagConstraint::AfterErgo; };
static bool check_constraints(JVMFlagConstraint::ConstraintType type); static bool check_constraints(JVMFlagConstraint::ConstraintType type);

65
src/hotspot/share/runtime/flags/jvmFlagConstraintsCompiler.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -26,6 +26,7 @@
#define SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSCOMPILER_HPP #define SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSCOMPILER_HPP
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "utilities/macros.hpp"
/* /*
* Here we have compiler arguments constraints functions, which are called automatically * Here we have compiler arguments constraints functions, which are called automatically
@ -33,46 +34,28 @@
* an appropriate error value. * an appropriate error value.
*/ */
JVMFlag::Error AliasLevelConstraintFunc(intx value, bool verbose); #define COMPILER_CONSTRAINTS(f) \
f(intx, AliasLevelConstraintFunc) \
f(intx, CICompilerCountConstraintFunc) \
f(intx, AllocatePrefetchDistanceConstraintFunc) \
f(intx, AllocatePrefetchInstrConstraintFunc) \
f(intx, AllocatePrefetchStepSizeConstraintFunc) \
f(intx, CompileThresholdConstraintFunc) \
f(intx, OnStackReplacePercentageConstraintFunc) \
f(uintx, CodeCacheSegmentSizeConstraintFunc) \
f(intx, CodeEntryAlignmentConstraintFunc) \
f(intx, OptoLoopAlignmentConstraintFunc) \
f(uintx, ArraycopyDstPrefetchDistanceConstraintFunc) \
f(uintx, ArraycopySrcPrefetchDistanceConstraintFunc) \
f(uintx, TypeProfileLevelConstraintFunc) \
f(intx, InitArrayShortSizeConstraintFunc) \
f(int , RTMTotalCountIncrRateConstraintFunc) \
COMPILER2_PRESENT( \
f(intx, InteriorEntryAlignmentConstraintFunc) \
f(intx, NodeLimitFudgeFactorConstraintFunc) \
f(uintx, LoopStripMiningIterConstraintFunc) \
)
JVMFlag::Error CICompilerCountConstraintFunc(intx value, bool verbose); COMPILER_CONSTRAINTS(DECLARE_CONSTRAINT)
JVMFlag::Error AllocatePrefetchDistanceConstraintFunc(intx value, bool verbose);
JVMFlag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose);
JVMFlag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose);
JVMFlag::Error CompileThresholdConstraintFunc(intx value, bool verbose);
JVMFlag::Error OnStackReplacePercentageConstraintFunc(intx value, bool verbose);
JVMFlag::Error CodeCacheSegmentSizeConstraintFunc(uintx value, bool verbose);
JVMFlag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose);
JVMFlag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose);
JVMFlag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose);
JVMFlag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose);
JVMFlag::Error ArraycopySrcPrefetchDistanceConstraintFunc(uintx value, bool verbose);
JVMFlag::Error TypeProfileLevelConstraintFunc(uintx value, bool verbose);
JVMFlag::Error InitArrayShortSizeConstraintFunc(intx value, bool verbose);
#ifdef COMPILER2
JVMFlag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose);
JVMFlag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose);
#endif
JVMFlag::Error RTMTotalCountIncrRateConstraintFunc(int value, bool verbose);
#ifdef COMPILER2
JVMFlag::Error LoopStripMiningIterConstraintFunc(uintx value, bool verbose);
#endif
#endif // SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSCOMPILER_HPP #endif // SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSCOMPILER_HPP

32
src/hotspot/share/runtime/flags/jvmFlagConstraintsRuntime.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -25,6 +25,7 @@
#include "precompiled.hpp" #include "precompiled.hpp"
#include "runtime/arguments.hpp" #include "runtime/arguments.hpp"
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagLimit.hpp"
#include "runtime/flags/jvmFlagConstraintsRuntime.hpp" #include "runtime/flags/jvmFlagConstraintsRuntime.hpp"
#include "runtime/globals.hpp" #include "runtime/globals.hpp"
#include "runtime/safepointMechanism.hpp" #include "runtime/safepointMechanism.hpp"
@ -131,3 +132,32 @@ JVMFlag::Error PerfDataSamplingIntervalFunc(intx value, bool verbose) {
return JVMFlag::SUCCESS; return JVMFlag::SUCCESS;
} }
} }
JVMFlag::Error VMPageSizeConstraintFunc(uintx value, bool verbose) {
uintx min = (uintx)os::vm_page_size();
if (value < min) {
JVMFlag::printError(verbose,
"%s %s=" UINTX_FORMAT " is outside the allowed range [ " UINTX_FORMAT
" ... " UINTX_FORMAT " ]\n",
JVMFlagLimit::last_checked_flag()->_type,
JVMFlagLimit::last_checked_flag()->_name,
value, min, max_uintx);
return JVMFlag::VIOLATES_CONSTRAINT;
}
return JVMFlag::SUCCESS;
}
JVMFlag::Error NUMAInterleaveGranularityConstraintFunc(size_t value, bool verbose) {
size_t min = os::vm_allocation_granularity();
size_t max = NOT_LP64(2*G) LP64_ONLY(8192*G);
if (value < min || value > max) {
JVMFlag::printError(verbose,
"size_t NUMAInterleaveGranularity=" UINTX_FORMAT " is outside the allowed range [ " UINTX_FORMAT
" ... " UINTX_FORMAT " ]\n", value, min, max);
return JVMFlag::VIOLATES_CONSTRAINT;
}
return JVMFlag::SUCCESS;
}

22
src/hotspot/share/runtime/flags/jvmFlagConstraintsRuntime.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -33,15 +33,17 @@
* an appropriate error value. * an appropriate error value.
*/ */
JVMFlag::Error ObjectAlignmentInBytesConstraintFunc(intx value, bool verbose); #define RUNTIME_CONSTRAINTS(f) \
f(intx, ObjectAlignmentInBytesConstraintFunc) \
f(intx, ContendedPaddingWidthConstraintFunc) \
f(intx, BiasedLockingBulkRebiasThresholdFunc) \
f(intx, BiasedLockingStartupDelayFunc) \
f(intx, BiasedLockingBulkRevokeThresholdFunc) \
f(intx, BiasedLockingDecayTimeFunc) \
f(intx, PerfDataSamplingIntervalFunc) \
f(uintx, VMPageSizeConstraintFunc) \
f(size_t, NUMAInterleaveGranularityConstraintFunc)
JVMFlag::Error ContendedPaddingWidthConstraintFunc(intx value, bool verbose); RUNTIME_CONSTRAINTS(DECLARE_CONSTRAINT)
JVMFlag::Error BiasedLockingBulkRebiasThresholdFunc(intx value, bool verbose);
JVMFlag::Error BiasedLockingStartupDelayFunc(intx value, bool verbose);
JVMFlag::Error BiasedLockingBulkRevokeThresholdFunc(intx value, bool verbose);
JVMFlag::Error BiasedLockingDecayTimeFunc(intx value, bool verbose);
JVMFlag::Error PerfDataSamplingIntervalFunc(intx value, bool verbose);
#endif // SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSRUNTIME_HPP #endif // SHARE_RUNTIME_FLAGS_JVMFLAGCONSTRAINTSRUNTIME_HPP

150
src/hotspot/share/runtime/flags/jvmFlagLimit.cpp Normal file
View file

@ -0,0 +1,150 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#include "memory/allocation.inline.hpp"
#include "gc/shared/jvmFlagConstraintsGC.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagLimit.hpp"
#include "runtime/flags/jvmFlagConstraintList.hpp"
#include "runtime/flags/jvmFlagConstraintsCompiler.hpp"
#include "runtime/flags/jvmFlagConstraintsRuntime.hpp"
#include "runtime/flags/jvmFlagRangeList.hpp"
#include "runtime/globals_extension.hpp"
#include "gc/shared/referenceProcessor.hpp"
#include "oops/markWord.hpp"
#include "runtime/task.hpp"
//----------------------------------------------------------------------
// Build flagLimitTable[]
#define CONSTRAINT_ENUM(func) constraint_enum_ ## func
#define CONSTRAINT_ENUM_(type, func) CONSTRAINT_ENUM(func),
#define CONSTRAINT_FUNC(type, func) (void*)&func,
enum JVMFlagConstraintsEnum : int {
ALL_CONSTRAINTS(CONSTRAINT_ENUM_)
NUM_JVMFlagConstraintsEnum
};
static void* const flagConstraintTable[NUM_JVMFlagConstraintsEnum] = {
ALL_CONSTRAINTS(CONSTRAINT_FUNC)
};
void* JVMFlagLimit::constraint_func() const {
int i = _constraint_func;
assert(0 <= i && i < NUM_JVMFlagConstraintsEnum, "sanity");
return flagConstraintTable[i];
}
struct DummyLimit {
char dummy;
constexpr DummyLimit(...) : dummy() {}
};
template <typename T>
class LimitGetter {
public:
// These functions return NULL for develop flags in a PRODUCT build
static constexpr const JVMFlagLimit* no_limit(...) {
return NULL;
}
// This is for flags that have neither range no constraint. We don't need the JVMFlagLimit struct.
static constexpr const JVMFlagLimit* get_limit(const JVMTypedFlagLimit<T>* p, int dummy) {
return NULL;
}
static constexpr const JVMFlagLimit* get_limit(const JVMTypedFlagLimit<T>* p, int dummy, T min, T max) {
return p;
}
static constexpr const JVMFlagLimit* get_limit(const JVMTypedFlagLimit<T>* p, int dummy, ConstraintMarker dummy2, short func, int phase) {
return p;
}
static constexpr const JVMFlagLimit* get_limit(const JVMTypedFlagLimit<T>* p, int dummy, T min, T max, ConstraintMarker dummy2, short func, int phase) {
return p;
}
static constexpr const JVMFlagLimit* get_limit(const JVMTypedFlagLimit<T>* p, int dummy, ConstraintMarker dummy2, short func, int phase, T min, T max) {
return p;
}
};
// macro body starts here -------------------+
// |
// v
#define FLAG_LIMIT_DEFINE( type, name, ...) ); constexpr JVMTypedFlagLimit<type> limit_##name(0
#define FLAG_LIMIT_DEFINE_DUMMY(type, name, ...) ); constexpr DummyLimit nolimit_##name(0
#define FLAG_LIMIT_PTR( type, name, ...) ), LimitGetter<type>::get_limit(&limit_##name, 0
#define FLAG_LIMIT_PTR_NONE( type, name, ...) ), LimitGetter<type>::no_limit(0
#define APPLY_FLAG_RANGE(...) , __VA_ARGS__
#define APPLY_FLAG_CONSTRAINT(func, phase) , next_two_args_are_constraint, (short)CONSTRAINT_ENUM(func), int(JVMFlagConstraint::phase)
constexpr JVMTypedFlagLimit<int> limit_dummy
(
#ifdef PRODUCT
ALL_FLAGS(FLAG_LIMIT_DEFINE_DUMMY,
FLAG_LIMIT_DEFINE_DUMMY,
FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE_DUMMY,
APPLY_FLAG_RANGE,
APPLY_FLAG_CONSTRAINT)
#else
ALL_FLAGS(FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE,
FLAG_LIMIT_DEFINE,
APPLY_FLAG_RANGE,
APPLY_FLAG_CONSTRAINT)
#endif
);
static constexpr const JVMFlagLimit* const flagLimitTable[1 + NUM_JVMFlagsEnum] = {
// Because FLAG_LIMIT_PTR must start with an "),", we have to place a dummy element here.
LimitGetter<int>::get_limit(NULL, 0
#ifdef PRODUCT
ALL_FLAGS(FLAG_LIMIT_PTR_NONE,
FLAG_LIMIT_PTR_NONE,
FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR_NONE,
APPLY_FLAG_RANGE,
APPLY_FLAG_CONSTRAINT)
#else
ALL_FLAGS(FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR,
FLAG_LIMIT_PTR,
APPLY_FLAG_RANGE,
APPLY_FLAG_CONSTRAINT)
#endif
)
};
int JVMFlagLimit::_last_checked = -1;
const JVMFlagLimit* const* JVMFlagLimit::flagLimits = &flagLimitTable[1]; // excludes dummy

155
src/hotspot/share/runtime/flags/jvmFlagLimit.hpp Normal file
View file

@ -0,0 +1,155 @@
/*
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP
#define SHARE_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP
#include "runtime/flags/jvmFlag.hpp"
#define ALL_LIMIT_TYPES(f) \
f(int) \
f(intx) \
f(uint) \
f(uintx) \
f(uint64_t) \
f(size_t) \
f(double)
#define ALL_RANGE_TYPES(f) ALL_LIMIT_TYPES(f)
#define ALL_CONSTRAINT_TYPES(f) ALL_LIMIT_TYPES(f) f(bool)
template <typename T> class JVMTypedFlagLimit;
// A JVMFlagLimit is created for each JVMFlag that has a range() and/or constraint() in its declaration in
// the globals_xxx.hpp file.
//
// To query the range information of a JVMFlag:
// JVMFlagLimit::get_range(JVMFlag*)
// JVMFlagLimit::get_range_at(int flag_enum)
// If the given flag doesn't have a range, NULL is returned.
//
// To query the constraint information of a JVMFlag:
// JVMFlagLimit::get_constraint(JVMFlag*)
// JVMFlagLimit::get_constraint_at(int flag_enum)
// If the given flag doesn't have a constraint, NULL is returned.
class JVMFlagLimit {
short _constraint_func;
char _phase;
char _kind;
static const JVMFlagLimit* const* flagLimits;
static int _last_checked;
protected:
static constexpr int HAS_RANGE = 1;
static constexpr int HAS_CONSTRAINT = 2;
private:
static const JVMFlagLimit* get_kind_at(int flag_enum, int required_kind) {
const JVMFlagLimit* limit = at(flag_enum);
if (limit != NULL && (limit->_kind & required_kind) != 0) {
_last_checked = flag_enum;
return limit;
} else {
return NULL;
}
}
static const JVMFlagLimit* at(int flag_enum) {
JVMFlag::assert_valid_flag_enum(flag_enum);
return flagLimits[flag_enum];
}
public:
void* constraint_func() const;
char phase() const { return _phase; }
char kind() const { return _kind; }
constexpr JVMFlagLimit(short func, short phase, short kind) : _constraint_func(func), _phase(phase), _kind(kind) {}
static const JVMFlagLimit* get_range(const JVMFlag* flag) {
return get_range_at(flag->flag_enum());
}
static const JVMFlagLimit* get_range_at(int flag_enum) {
return get_kind_at(flag_enum, HAS_RANGE);
}
static const JVMFlagLimit* get_constraint(const JVMFlag* flag) {
return get_constraint_at(flag->flag_enum());
}
static const JVMFlagLimit* get_constraint_at(int flag_enum) {
return get_kind_at(flag_enum, HAS_CONSTRAINT);
}
static const JVMFlag* last_checked_flag() {
if (_last_checked >= 0) {
return JVMFlag::flag_from_enum(_last_checked);
} else {
return NULL;
}
}
#define AS_TYPED_LIMIT(type) inline JVMTypedFlagLimit<type>* as_ ## type() const { return (JVMTypedFlagLimit<type>*)this; }
ALL_RANGE_TYPES(AS_TYPED_LIMIT)
};
enum ConstraintMarker {
next_two_args_are_constraint,
};
template <typename T>
class JVMTypedFlagLimit : public JVMFlagLimit {
const T _min;
const T _max;
public:
// dummy - no range or constraint. This object will not be emitted into the .o file
// because we declare it as "const" but has no reference to it.
constexpr JVMTypedFlagLimit(int dummy) :
JVMFlagLimit(0, 0, 0), _min(0), _max(0) {}
// range only
constexpr JVMTypedFlagLimit(int dummy, T min, T max) :
JVMFlagLimit(0, 0, HAS_RANGE), _min(min), _max(max) {}
// constraint only
constexpr JVMTypedFlagLimit(int dummy, ConstraintMarker dummy2, short func, int phase) :
JVMFlagLimit(func, phase, HAS_CONSTRAINT), _min(0), _max(0) {}
// range and constraint
constexpr JVMTypedFlagLimit(int dummy, T min, T max, ConstraintMarker dummy2, short func, int phase) :
JVMFlagLimit(func, phase, HAS_RANGE | HAS_CONSTRAINT), _min(min), _max(max) {}
// constraint and range
constexpr JVMTypedFlagLimit(int dummy, ConstraintMarker dummy2, short func, int phase, T min, T max) :
JVMFlagLimit(func, phase, HAS_RANGE | HAS_CONSTRAINT), _min(min), _max(max) {}
T min() const { return _min; }
T max() const { return _max; }
};
#endif // SHARE_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP

78
src/hotspot/share/runtime/flags/jvmFlagLookup.cpp Normal file
View file

@ -0,0 +1,78 @@
/*
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagLookup.hpp"
#include "utilities/defaultStream.hpp"
#define DO_FLAG(type, name,...) DO_HASH(FLAG_MEMBER_ENUM(name), XSTR(name))
#define DO_HASH(flag_enum, flag_name) { \
unsigned int hash = hash_code(flag_name); \
int bucket_index = (int)(hash % NUM_BUCKETS); \
_hashes[flag_enum] = (u2)(hash); \
_table[flag_enum] = _buckets[bucket_index]; \
_buckets[bucket_index] = (short)flag_enum; \
}
constexpr JVMFlagLookup::JVMFlagLookup() : _buckets(), _table(), _hashes() {
for (int i = 0; i < NUM_BUCKETS; i++) {
_buckets[i] = -1;
}
ALL_FLAGS(DO_FLAG,
DO_FLAG,
DO_FLAG,
DO_FLAG,
DO_FLAG,
IGNORE_RANGE,
IGNORE_CONSTRAINT)
}
constexpr JVMFlagLookup _flag_lookup_table;
JVMFlag* JVMFlagLookup::find_impl(const char* name, size_t length) const {
unsigned int hash = hash_code(name, length);
int bucket_index = (int)(hash % NUM_BUCKETS);
for (int flag_enum = _buckets[bucket_index]; flag_enum >= 0; ) {
if (_hashes[flag_enum] == (u2)hash) {
JVMFlag* flag = JVMFlag::flags + flag_enum;
if (strncmp(name, flag->_name, length) == 0) {
// We know flag->_name has at least <length> bytes.
// Make sure it has exactly <length> bytes
if (flag->_name[length] == 0) {
return flag;
}
}
}
flag_enum = (int)_table[flag_enum];
}
return NULL;
}
JVMFlag* JVMFlagLookup::find(const char* name, size_t length) {
return _flag_lookup_table.find_impl(name, length);
}

74
src/hotspot/share/runtime/flags/jvmFlagLookup.hpp Normal file
View file

@ -0,0 +1,74 @@
/*
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_RUNTIME_FLAGS_JVMFLAGLOOKUP_HPP
#define SHARE_RUNTIME_FLAGS_JVMFLAGLOOKUP_HPP
#include "runtime/globals_extension.hpp"
#include "runtime/flags/jvmFlag.hpp"
// This is a hashtable that maps from (const char*) to (JVMFlag*) to speed up
// the processing of JVM command-line arguments at runtime.
//
// With constexpr, this table is generated at C++ compile time so there's
// no set up cost at runtime.
class JVMFlagLookup {
static constexpr int NUM_BUCKETS = 277;
short _buckets[NUM_BUCKETS];
short _table[NUM_JVMFlagsEnum];
u2 _hashes[NUM_JVMFlagsEnum];
// Cannot use strlen() -- it's not constexpr.
static constexpr size_t string_len(const char* s) {
size_t len = 0;
while (*s != 0) {
len++;
s++;
}
return len;
}
// This is executed at build-time only, so it doesn't matter if we walk
// the string twice.
static constexpr unsigned int hash_code(const char* s) {
return hash_code(s, string_len(s));
}
static constexpr unsigned int hash_code(const char* s, size_t len) {
unsigned int h = 0;
while (len -- > 0) {
h = 31*h + (unsigned int) *s;
s++;
}
return h;
}
JVMFlag* find_impl(const char* flag_name, size_t length) const;
public:
constexpr JVMFlagLookup();
static JVMFlag* find(const char* flag_name, size_t length);
};
#endif // SHARE_RUNTIME_FLAGS_JVMFLAGLOOKUP_HPP

162
src/hotspot/share/runtime/flags/jvmFlagRangeList.cpp
View file

@ -31,6 +31,7 @@
#include "runtime/arguments.hpp" #include "runtime/arguments.hpp"
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagConstraintList.hpp" #include "runtime/flags/jvmFlagConstraintList.hpp"
#include "runtime/flags/jvmFlagConstraintsRuntime.hpp"
#include "runtime/flags/jvmFlagRangeList.hpp" #include "runtime/flags/jvmFlagRangeList.hpp"
#include "runtime/globals.hpp" #include "runtime/globals.hpp"
#include "runtime/globals_extension.hpp" #include "runtime/globals_extension.hpp"
@ -241,122 +242,69 @@ public:
} }
}; };
// No constraint emitting #define DEFINE_RANGE_CHECK(T) \
void emit_range_no(...) { /* NOP */ } JVMFlag::Error JVMFlagRangeChecker::check_ ## T(T value, bool verbose) const { \
assert(exists(), "must be"); \
// No constraint emitting if function argument is NOT provided JVMFlagRange_ ## T range(_flag, _limit->as_ ## T()->min(), _limit->as_ ## T()->max()); \
void emit_range_bool(const JVMFlag* /*flag*/) { /* NOP */ } return range.check_ ## T(value, verbose); \
void emit_range_ccstr(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_ccstrlist(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_int(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_intx(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_uint(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_uintx(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_uint64_t(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_size_t(const JVMFlag* /*flag*/) { /* NOP */ }
void emit_range_double(const JVMFlag* /*flag*/) { /* NOP */ }
// JVMFlagRange emitting code functions if range arguments are provided
void emit_range_int(const JVMFlag* flag, int min, int max) {
JVMFlagRangeList::add(new JVMFlagRange_int(flag, min, max));
}
void emit_range_intx(const JVMFlag* flag, intx min, intx max) {
JVMFlagRangeList::add(new JVMFlagRange_intx(flag, min, max));
}
void emit_range_uint(const JVMFlag* flag, uint min, uint max) {
JVMFlagRangeList::add(new JVMFlagRange_uint(flag, min, max));
}
void emit_range_uintx(const JVMFlag* flag, uintx min, uintx max) {
JVMFlagRangeList::add(new JVMFlagRange_uintx(flag, min, max));
}
void emit_range_uint64_t(const JVMFlag* flag, uint64_t min, uint64_t max) {
JVMFlagRangeList::add(new JVMFlagRange_uint64_t(flag, min, max));
}
void emit_range_size_t(const JVMFlag* flag, size_t min, size_t max) {
JVMFlagRangeList::add(new JVMFlagRange_size_t(flag, min, max));
}
void emit_range_double(const JVMFlag* flag, double min, double max) {
JVMFlagRangeList::add(new JVMFlagRange_double(flag, min, max));
} }
// Generate code to call emit_range_xxx function ALL_RANGE_TYPES(DEFINE_RANGE_CHECK)
#define EMIT_RANGE_START (void)(0
#define EMIT_RANGE(type, name) ); emit_range_##type(JVMFlagEx::flag_from_enum(FLAG_MEMBER_ENUM(name))
#define EMIT_RANGE_NO ); emit_range_no(0
#define EMIT_RANGE_PRODUCT_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_DIAGNOSTIC_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_EXPERIMENTAL_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_MANAGEABLE_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_PRODUCT_RW_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_PD_PRODUCT_FLAG(type, name, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_PD_DIAGNOSTIC_FLAG(type, name, doc) EMIT_RANGE(type, name)
#ifndef PRODUCT
#define EMIT_RANGE_DEVELOPER_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_PD_DEVELOPER_FLAG(type, name, doc) EMIT_RANGE(type, name)
#define EMIT_RANGE_NOTPRODUCT_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#else
#define EMIT_RANGE_DEVELOPER_FLAG(type, name, value, doc) EMIT_RANGE_NO
#define EMIT_RANGE_PD_DEVELOPER_FLAG(type, name, doc) EMIT_RANGE_NO
#define EMIT_RANGE_NOTPRODUCT_FLAG(type, name, value, doc) EMIT_RANGE_NO
#endif
#ifdef _LP64
#define EMIT_RANGE_LP64_PRODUCT_FLAG(type, name, value, doc) EMIT_RANGE(type, name)
#else
#define EMIT_RANGE_LP64_PRODUCT_FLAG(type, name, value, doc) EMIT_RANGE_NO
#endif
#define EMIT_RANGE_END );
// Generate func argument to pass into emit_range_xxx functions
#define EMIT_RANGE_CHECK(a, b) , a, b
#define INITIAL_RANGES_SIZE 379 JVMFlag::Error JVMFlagRangeChecker::check(bool verbose) const {
GrowableArray<JVMFlagRange*>* JVMFlagRangeList::_ranges = NULL; #define CHECK_RANGE(T) \
if (_flag->is_ ## T()) { \
// Check the ranges of all flags that have them JVMFlagRange_ ## T range(_flag, _limit->as_ ## T()->min(), _limit->as_ ## T()->max()); \
void JVMFlagRangeList::init(void) { return range.check(verbose); \
_ranges = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<JVMFlagRange*>(INITIAL_RANGES_SIZE, mtArguments);
EMIT_RANGE_START
ALL_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
EMIT_RANGE_PD_DEVELOPER_FLAG,
EMIT_RANGE_PRODUCT_FLAG,
EMIT_RANGE_PD_PRODUCT_FLAG,
EMIT_RANGE_DIAGNOSTIC_FLAG,
EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
EMIT_RANGE_EXPERIMENTAL_FLAG,
EMIT_RANGE_NOTPRODUCT_FLAG,
EMIT_RANGE_MANAGEABLE_FLAG,
EMIT_RANGE_PRODUCT_RW_FLAG,
EMIT_RANGE_LP64_PRODUCT_FLAG,
EMIT_RANGE_CHECK,
IGNORE_CONSTRAINT)
EMIT_RANGE_END
}
JVMFlagRange* JVMFlagRangeList::find(const JVMFlag* flag) {
JVMFlagRange* found = NULL;
for (int i=0; i<length(); i++) {
JVMFlagRange* range = at(i);
if (range->flag() == flag) {
found = range;
break;
} }
ALL_RANGE_TYPES(CHECK_RANGE);
ShouldNotReachHere();
return JVMFlag::INVALID_FLAG;
}
void JVMFlagRangeChecker::print(outputStream* out) const {
#define PRINT_RANGE(T) \
if (_flag->is_ ## T()) { \
JVMFlagRange_ ## T range(_flag, _limit->as_ ## T()->min(), _limit->as_ ## T()->max()); \
range.print(out); \
return; \
} }
return found;
ALL_RANGE_TYPES(PRINT_RANGE);
ShouldNotReachHere();
} }
void JVMFlagRangeList::print(outputStream* st, const JVMFlag* flag, RangeStrFunc default_range_str_func) { void JVMFlagRangeList::print(outputStream* st, const JVMFlag* flag, RangeStrFunc default_range_str_func) {
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
range->print(st); range.print(st);
} else {
const JVMFlagLimit* limit = JVMFlagLimit::get_constraint(flag);
if (limit != NULL) {
void* func = limit->constraint_func();
// Two special cases where the lower limit of the range is defined by an os:: function call
// and cannot be initialized at compile time with constexpr.
if (func == (void*)VMPageSizeConstraintFunc) {
uintx min = (uintx)os::vm_page_size();
uintx max = max_uintx;
JVMFlagRange_uintx tmp(flag, min, max);
tmp.print(st);
} else if (func == (void*)NUMAInterleaveGranularityConstraintFunc) {
size_t min = os::vm_allocation_granularity();
size_t max = NOT_LP64(2*G) LP64_ONLY(8192*G);
JVMFlagRange_size_t tmp(flag, min, max);
tmp.print(st);
} else { } else {
JVMFlagConstraint* constraint = JVMFlagConstraintList::find(flag);
if (constraint != NULL) {
assert(default_range_str_func!=NULL, "default_range_str_func must be provided"); assert(default_range_str_func!=NULL, "default_range_str_func must be provided");
st->print("%s", default_range_str_func()); st->print("%s", default_range_str_func());
}
} else { } else {
st->print("[ ... ]"); st->print("[ ... ]");
} }
@ -365,9 +313,9 @@ void JVMFlagRangeList::print(outputStream* st, const JVMFlag* flag, RangeStrFunc
bool JVMFlagRangeList::check_ranges() { bool JVMFlagRangeList::check_ranges() {
bool status = true; bool status = true;
for (int i=0; i<length(); i++) { for (int i = 0; i < NUM_JVMFlagsEnum; i++) {
JVMFlagRange* range = at(i); JVMFlagRangeChecker range(&JVMFlag::flags[i], JVMFlagLimit::get_range_at(i));
if (range->check(true) != JVMFlag::SUCCESS) status = false; if (range.exists() && range.check(true) != JVMFlag::SUCCESS) status = false;
} }
return status; return status;
} }

27
src/hotspot/share/runtime/flags/jvmFlagRangeList.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -26,7 +26,7 @@
#define SHARE_RUNTIME_FLAGS_JVMFLAGRANGELIST_HPP #define SHARE_RUNTIME_FLAGS_JVMFLAGRANGELIST_HPP
#include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlag.hpp"
#include "utilities/growableArray.hpp" #include "runtime/flags/jvmFlagLimit.hpp"
/* /*
* Here we have a mechanism for extracting ranges specified in flag macro tables. * Here we have a mechanism for extracting ranges specified in flag macro tables.
@ -58,14 +58,23 @@ public:
virtual void print(outputStream* st) { ; } virtual void print(outputStream* st) { ; }
}; };
class JVMFlagRangeList : public AllStatic { class JVMFlagRangeChecker {
static GrowableArray<JVMFlagRange*>* _ranges; const JVMFlag* _flag;
const JVMFlagLimit* _limit;
public: public:
static void init(); JVMFlagRangeChecker(const JVMFlag* flag, const JVMFlagLimit* limit) : _flag(flag), _limit(limit) {}
static int length() { return (_ranges != NULL) ? _ranges->length() : 0; } bool exists() const { return _limit != NULL; }
static JVMFlagRange* at(int i) { return (_ranges != NULL) ? _ranges->at(i) : NULL; } JVMFlag::Error check(bool verbose = true) const;
static JVMFlagRange* find(const JVMFlag* flag); void print(outputStream* st) const;
static void add(JVMFlagRange* range) { _ranges->append(range); }
#define DECLARE_RANGE_CHECK(T) JVMFlag::Error check_ ## T(T new_value, bool verbose = true) const;
ALL_RANGE_TYPES(DECLARE_RANGE_CHECK)
};
class JVMFlagRangeList : public AllStatic {
public:
static JVMFlagRangeChecker find(const JVMFlag* flag) { return JVMFlagRangeChecker(flag, JVMFlagLimit::get_range(flag)); }
static void print(outputStream* st, const JVMFlag* flag, RangeStrFunc default_range_str_func); static void print(outputStream* st, const JVMFlag* flag, RangeStrFunc default_range_str_func);
// Check the final values of all flags for ranges. // Check the final values of all flags for ranges.
static bool check_ranges(); static bool check_ranges();

45
src/hotspot/share/runtime/globals.cpp
View file

@ -40,39 +40,22 @@
#include "utilities/stringUtils.hpp" #include "utilities/stringUtils.hpp"
// Implementation macros // Implementation macros
#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value; #define MATERIALIZE_PRODUCT_FLAG(type, name, value, ...) type name = value;
#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name; #define MATERIALIZE_PD_PRODUCT_FLAG(type, name, ...) type name = pd_##name;
#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_PD_DIAGNOSTIC_FLAG(type, name, doc) type name = pd_##name;
#define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value;
#ifdef PRODUCT #ifdef PRODUCT
#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, ...)
#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, ...)
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, ...)
#else #else
#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value; #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, ...) type name = value;
#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name; #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, ...) type name = pd_##name;
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value; #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, ...) type name = value;
#endif // PRODUCT #endif // PRODUCT
#ifdef _LP64
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value;
#else
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */
#endif // _LP64
ALL_FLAGS(MATERIALIZE_DEVELOPER_FLAG,
ALL_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \ MATERIALIZE_PD_DEVELOPER_FLAG,
MATERIALIZE_PD_DEVELOPER_FLAG, \ MATERIALIZE_PRODUCT_FLAG,
MATERIALIZE_PRODUCT_FLAG, \ MATERIALIZE_PD_PRODUCT_FLAG,
MATERIALIZE_PD_PRODUCT_FLAG, \ MATERIALIZE_NOTPRODUCT_FLAG,
MATERIALIZE_DIAGNOSTIC_FLAG, \ IGNORE_RANGE,
MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
MATERIALIZE_EXPERIMENTAL_FLAG, \
MATERIALIZE_NOTPRODUCT_FLAG, \
MATERIALIZE_MANAGEABLE_FLAG, \
MATERIALIZE_PRODUCT_RW_FLAG, \
MATERIALIZE_LP64_PRODUCT_FLAG, \
IGNORE_RANGE, \
IGNORE_CONSTRAINT) IGNORE_CONSTRAINT)

446
src/hotspot/share/runtime/globals.hpp
View file

File diff suppressed because it is too large Load diff

54
src/hotspot/share/runtime/globals_extension.hpp
View file

@ -34,34 +34,18 @@
#define FLAG_MEMBER_ENUM(name) Flag_##name##_enum #define FLAG_MEMBER_ENUM(name) Flag_##name##_enum
#define FLAG_MEMBER_ENUM_(name) FLAG_MEMBER_ENUM(name), #define FLAG_MEMBER_ENUM_(name) FLAG_MEMBER_ENUM(name),
#define FLAG_MEMBER_ENUM_PRODUCT(type, name, value, doc) FLAG_MEMBER_ENUM_(name) #define FLAG_MEMBER_ENUM_PRODUCT(type, name, value, ...) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_PD_PRODUCT(type, name, doc) FLAG_MEMBER_ENUM_(name) #define FLAG_MEMBER_ENUM_PD_PRODUCT(type, name, ...) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_DIAGNOSTIC(type, name, value, doc) FLAG_MEMBER_ENUM_(name) #define FLAG_MEMBER_ENUM_DEVELOP(type, name, value, ...) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_PD_DIAGNOSTIC(type, name, doc) FLAG_MEMBER_ENUM_(name) #define FLAG_MEMBER_ENUM_PD_DEVELOP(type, name, ...) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_EXPERIMENTAL(type, name, value, doc) FLAG_MEMBER_ENUM_(name) #define FLAG_MEMBER_ENUM_NOTPRODUCT(type, name, value, ...) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_MANAGEABLE(type, name, value, doc) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_PRODUCT_RW(type, name, value, doc) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_DEVELOP(type, name, value, doc) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_PD_DEVELOP(type, name, doc) FLAG_MEMBER_ENUM_(name)
#define FLAG_MEMBER_ENUM_NOTPRODUCT(type, name, value, doc) FLAG_MEMBER_ENUM_(name)
#ifdef _LP64
#define FLAG_MEMBER_ENUM_LP64_PRODUCT(type, name, value, doc) FLAG_MEMBER_ENUM_(name)
#else
#define FLAG_MEMBER_ENUM_LP64_PRODUCT(type, name, value, doc) /* flag is constant */
#endif // _LP64
typedef enum { typedef enum : int {
ALL_FLAGS(FLAG_MEMBER_ENUM_DEVELOP, ALL_FLAGS(FLAG_MEMBER_ENUM_DEVELOP,
FLAG_MEMBER_ENUM_PD_DEVELOP, FLAG_MEMBER_ENUM_PD_DEVELOP,
FLAG_MEMBER_ENUM_PRODUCT, FLAG_MEMBER_ENUM_PRODUCT,
FLAG_MEMBER_ENUM_PD_PRODUCT, FLAG_MEMBER_ENUM_PD_PRODUCT,
FLAG_MEMBER_ENUM_DIAGNOSTIC,
FLAG_MEMBER_ENUM_PD_DIAGNOSTIC,
FLAG_MEMBER_ENUM_EXPERIMENTAL,
FLAG_MEMBER_ENUM_NOTPRODUCT, FLAG_MEMBER_ENUM_NOTPRODUCT,
FLAG_MEMBER_ENUM_MANAGEABLE,
FLAG_MEMBER_ENUM_PRODUCT_RW,
FLAG_MEMBER_ENUM_LP64_PRODUCT,
IGNORE_RANGE, IGNORE_RANGE,
IGNORE_CONSTRAINT) IGNORE_CONSTRAINT)
NUM_JVMFlagsEnum NUM_JVMFlagsEnum
@ -100,33 +84,17 @@ class JVMFlagEx : JVMFlag {
#define FLAG_MEMBER_SET(name) Flag_##name##_set #define FLAG_MEMBER_SET(name) Flag_##name##_set
#define FLAG_MEMBER_SET_(type, name) inline JVMFlag::Error FLAG_MEMBER_SET(name)(type value, JVMFlag::Flags origin) { return JVMFlagEx::type##AtPut(FLAG_MEMBER_ENUM(name), value, origin); } #define FLAG_MEMBER_SET_(type, name) inline JVMFlag::Error FLAG_MEMBER_SET(name)(type value, JVMFlag::Flags origin) { return JVMFlagEx::type##AtPut(FLAG_MEMBER_ENUM(name), value, origin); }
#define FLAG_MEMBER_SET_PRODUCT(type, name, value, doc) FLAG_MEMBER_SET_(type, name) #define FLAG_MEMBER_SET_PRODUCT(type, name, value, ...) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_PD_PRODUCT(type, name, doc) FLAG_MEMBER_SET_(type, name) #define FLAG_MEMBER_SET_PD_PRODUCT(type, name, ...) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_DIAGNOSTIC(type, name, value, doc) FLAG_MEMBER_SET_(type, name) #define FLAG_MEMBER_SET_DEVELOP(type, name, value, ...) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_PD_DIAGNOSTIC(type, name, doc) FLAG_MEMBER_SET_(type, name) #define FLAG_MEMBER_SET_PD_DEVELOP(type, name, ...) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_EXPERIMENTAL(type, name, value, doc) FLAG_MEMBER_SET_(type, name) #define FLAG_MEMBER_SET_NOTPRODUCT(type, name, value, ...) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_MANAGEABLE(type, name, value, doc) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_PRODUCT_RW(type, name, value, doc) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_DEVELOP(type, name, value, doc) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_PD_DEVELOP(type, name, doc) FLAG_MEMBER_SET_(type, name)
#define FLAG_MEMBER_SET_NOTPRODUCT(type, name, value, doc) FLAG_MEMBER_SET_(type, name)
#ifdef _LP64
#define FLAG_MEMBER_SET_LP64_PRODUCT(type, name, value, doc) FLAG_MEMBER_SET_(type, name)
#else
#define FLAG_MEMBER_SET_LP64_PRODUCT(type, name, value, doc) /* flag is constant */
#endif // _LP64
ALL_FLAGS(FLAG_MEMBER_SET_DEVELOP, ALL_FLAGS(FLAG_MEMBER_SET_DEVELOP,
FLAG_MEMBER_SET_PD_DEVELOP, FLAG_MEMBER_SET_PD_DEVELOP,
FLAG_MEMBER_SET_PRODUCT, FLAG_MEMBER_SET_PRODUCT,
FLAG_MEMBER_SET_PD_PRODUCT, FLAG_MEMBER_SET_PD_PRODUCT,
FLAG_MEMBER_SET_DIAGNOSTIC,
FLAG_MEMBER_SET_PD_DIAGNOSTIC,
FLAG_MEMBER_SET_EXPERIMENTAL,
FLAG_MEMBER_SET_NOTPRODUCT, FLAG_MEMBER_SET_NOTPRODUCT,
FLAG_MEMBER_SET_MANAGEABLE,
FLAG_MEMBER_SET_PRODUCT_RW,
FLAG_MEMBER_SET_LP64_PRODUCT,
IGNORE_RANGE, IGNORE_RANGE,
IGNORE_CONSTRAINT) IGNORE_CONSTRAINT)

81
src/hotspot/share/runtime/globals_shared.hpp
View file

@ -77,18 +77,14 @@
// Only materialize src code for contraint checking when required, ignore otherwise // Only materialize src code for contraint checking when required, ignore otherwise
#define IGNORE_CONSTRAINT(func,type) #define IGNORE_CONSTRAINT(func,type)
#define IGNORE_FLAG(...)
#define VM_FLAGS( \ #define VM_FLAGS( \
develop, \ develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
@ -97,13 +93,7 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
@ -112,54 +102,28 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
// Put the LP64/JVMCI/COMPILER1/COMPILER1/ARCH at
// the top, as they are processed by jvmFlags.cpp in that
// order.
#define ALL_FLAGS( \ #define ALL_FLAGS( \
develop, \ develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \ range, \
constraint) \ constraint) \
\ \
VM_FLAGS( \ LP64_RUNTIME_FLAGS( \
develop, \ develop, \
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \
manageable, \
product_rw, \
lp64_product, \
range, \
constraint) \
\
RUNTIME_OS_FLAGS( \
develop, \
develop_pd, \
product, \
product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) \ constraint) \
@ -169,9 +133,6 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint)) \ constraint)) \
@ -181,8 +142,6 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint)) \ constraint)) \
@ -192,9 +151,6 @@
develop_pd, \ develop_pd, \
product, \ product, \
product_pd, \ product_pd, \
diagnostic, \
diagnostic_pd, \
experimental, \
notproduct, \ notproduct, \
range, \ range, \
constraint)) \ constraint)) \
@ -202,10 +158,31 @@
ARCH_FLAGS( \ ARCH_FLAGS( \
develop, \ develop, \
product, \ product, \
diagnostic, \ notproduct, \
experimental, \ range, \
constraint) \
\
VM_FLAGS( \
develop, \
develop_pd, \
product, \
product_pd, \
notproduct, \
range, \
constraint) \
\
RUNTIME_OS_FLAGS( \
develop, \
develop_pd, \
product, \
product_pd, \
notproduct, \ notproduct, \
range, \ range, \
constraint) constraint)
#define ALL_CONSTRAINTS(f) \
COMPILER_CONSTRAINTS(f) \
RUNTIME_CONSTRAINTS(f) \
GC_CONSTRAINTS(f)
#endif // SHARE_RUNTIME_GLOBALS_SHARED_HPP #endif // SHARE_RUNTIME_GLOBALS_SHARED_HPP

8
src/hotspot/share/services/writeableFlags.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -39,12 +39,12 @@ static void buffer_concat(char* buffer, const char* src) {
} }
static void print_flag_error_message_bounds(const JVMFlag* flag, char* buffer) { static void print_flag_error_message_bounds(const JVMFlag* flag, char* buffer) {
JVMFlagRange* range = JVMFlagRangeList::find(flag); JVMFlagRangeChecker range = JVMFlagRangeList::find(flag);
if (range != NULL) { if (range.exists()) {
buffer_concat(buffer, "must have value in range "); buffer_concat(buffer, "must have value in range ");
stringStream stream; stringStream stream;
range->print(&stream); range.print(&stream);
const char* range_string = stream.as_string(); const char* range_string = stream.as_string();
size_t j = strlen(buffer); size_t j = strlen(buffer);
for (size_t i=0; j<TEMP_BUF_SIZE-1; i++) { for (size_t i=0; j<TEMP_BUF_SIZE-1; i++) {

12
src/hotspot/share/utilities/globalDefinitions.hpp
View file

@ -972,12 +972,12 @@ inline intptr_t bitfield(intptr_t x, int start_bit_no, int field_length) {
// and 64-bit overloaded functions, which does not work, and having // and 64-bit overloaded functions, which does not work, and having
// explicitly-typed versions of these routines (i.e., MAX2I, MAX2L) // explicitly-typed versions of these routines (i.e., MAX2I, MAX2L)
// will be even more error-prone than macros. // will be even more error-prone than macros.
template<class T> inline T MAX2(T a, T b) { return (a > b) ? a : b; } template<class T> constexpr T MAX2(T a, T b) { return (a > b) ? a : b; }
template<class T> inline T MIN2(T a, T b) { return (a < b) ? a : b; } template<class T> constexpr T MIN2(T a, T b) { return (a < b) ? a : b; }
template<class T> inline T MAX3(T a, T b, T c) { return MAX2(MAX2(a, b), c); } template<class T> constexpr T MAX3(T a, T b, T c) { return MAX2(MAX2(a, b), c); }
template<class T> inline T MIN3(T a, T b, T c) { return MIN2(MIN2(a, b), c); } template<class T> constexpr T MIN3(T a, T b, T c) { return MIN2(MIN2(a, b), c); }
template<class T> inline T MAX4(T a, T b, T c, T d) { return MAX2(MAX3(a, b, c), d); } template<class T> constexpr T MAX4(T a, T b, T c, T d) { return MAX2(MAX3(a, b, c), d); }
template<class T> inline T MIN4(T a, T b, T c, T d) { return MIN2(MIN3(a, b, c), d); } template<class T> constexpr T MIN4(T a, T b, T c, T d) { return MIN2(MIN3(a, b, c), d); }
template<class T> inline T ABS(T x) { return (x > 0) ? x : -x; } template<class T> inline T ABS(T x) { return (x > 0) ? x : -x; }