| UseProfilingInformation | Boolean | true |
AlwaysInlineVTableStubs = false [Boolean]
ArrayRegionEqualsConstantLimit = 4096 [Integer]
Array region equality checks will be evaluated at compile time if the
receiver is a constant and its length is smaller than this value.
BaseTargetSpending = 120 [Integer]
The base target spending used to estimate the inlining threshold; the
higher, the likelier it is to inline.
BlindConstants = false [Boolean]
Blind constants in code with a random key.
CMoveALot = false [Boolean]
Perform CMove transformation on every IfNode possible.
CallGraphCompilerNodeLimit = 35000 [Integer]
Controls the maximum number of compiler nodes that can appear in the
call graph
CallGraphSizeLimit = 1200 [Integer]
Controls the maximum size of the call graph before ceasing inlining.
CallGraphSizePenaltyCoefficient = 0.01 [Double]
Reduces the likelihood of exploring call graph subtrees that are large.
CompilationBailoutAsFailure = false [Boolean]
Treat compilation bailouts like compilation failures.
CompilationFailureAction = Silent [String]
Specifies the action to take when compilation fails.
The accepted values are:
Silent - Print nothing to the console.
Print - Print a stack trace to the console.
Diagnose* - Retry the compilation with extra diagnostics.
ExitVM - Same as Diagnose except that the VM process exits after retrying.
* If "Diagnose" is set compilation will be retried with extra diagnostics enabled including dumping (see file:doc-files/DumpHelp.txt).
In such a scenario DiagnoseDumpLevel can be used to specify the dump level (DebugContext dump levels) accordingly.
CompileGraalWithC1Only = true [Boolean]
In tiered mode compile Graal and JVMCI using optimized first tier code.
CompilerConfiguration = null [String]
Names the compiler configuration to use. If omitted, the compiler
configuration with the highest auto-selection priority is used. To see
the set of available configurations, supply the value 'help' to this
option.
CompilerNodePenaltyCoefficient = 0.006 [Double]
Controls the likelihood of exploring subtrees that already have a lot
of code during inlining.
ConsiderVectorizableLoops = true [Boolean]
Consider the vectorizability of loop during the duplication of a merge
inside a loop.There are rare cases where duplication can destroy
vectorization.
CountedStripMiningBudget = 0.1 [Double]
Code size budget of the strip mining transformation in terms of
NodeCostSize.
CountedStripMiningBudgetHotCode = 2.5 [Double]
See CountedStripMiningBudget.
CountedStripMiningInnerLoopTrips = 4096 [Integer]
The max number of iterations the counted inner loop takes.
CountedStripMiningMinFrequency = 4 [Integer]
Minimal frequency to consider a loop for strip mining.
CountedStripMiningNodeSizeSmallGraphs = 2000 [Integer]
Code size in NodeSize defining when code size heuristics starts capping
strip mining.
CutoffCodeSizePenaltyCoefficient = 1.0E-5 [Double]
Controls the likelihood of further exploring subtrees with a lot of
code during inlining.
DefaultLoopFrequency = 100.0 [Double]
Default frequency for loops with unknown local frequency.
DefaultUnswitchFactor = 0.7 [Double]
Default unswitching factor for control split node with unkown profile
data.
DeoptsToDisableOptimisticOptimization = 40 [Integer]
DetectInvertedLoopsAsCounted = true [Boolean]
DumpAfterEveryLowering = false [Boolean]
Dump lowering after every node to igv.
DuplicationBudgetFactor = 0.25 [Double]
Percentage in node cost graph size for the duplication budget. Computed
relative to the methods code size.
DuplicationBudgetFactorHotCode = 2.5 [Double]
See DuplicationBudgetFactor.
DuplicationCostReductionFactor = 64 [Integer]
Cost/Benefit heuristic for EE simulation-based code duplication: reduce
cost by a constant factor when comparing with relative benefit.
DuplicationCostReductionFactorHotCode = 256 [Integer]
See DuplicationCostReductionFactor
DuplicationMinBranchFrequency = 0.66 [Double]
Ignore low frequency branches during duplication.
EEPeelAlot = false [Boolean]
EnterpriseRangeCheckElimination = true [Boolean]
Perform range check elimination for java long type range checks.
ExactFullUnrollMaxNodes = 800 [Integer]
ExactPartialUnrollMaxNodes = 200 [Integer]
ExpandAllProximityBonus = 6.0 [Double]
The decrease in call graph expansion pressure when there are few call
nodes left to explore.
ExpandAllProximityBonusInertia = 2.0 [Double]
The inertia at which the expand-all proximity bonus decreases with the
number of yet unexpanded nodes.
ExpansionInertiaBaseValue = 550 [Integer]
The slowness at which the expansion pressure grows with code size; the
higher it is, the slower the pressure growth.
ExpansionInertiaInvokeBonus = 14 [Integer]
The extra slowness at which the expansion pressure grows with the code
size, for each extra invoke node.
ExpansionInertiaMax = 2000 [Integer]
The max slowness at which the expansion pressure grows with the code
size.
ForceExplicitReachabilityFence = false [Boolean]
Force an explicit compiler node for Reference.reachabilityFence,
instead of relying on FrameState liveness
FullUnrollCodeSizeBudgetFactorForLargeGraphs = 2.0 [Double]
Maximum factor by which full unrolling can increase code size for large
graphs. The FullUnrollSmallGraphThreshold option determines which
graphs are small
FullUnrollCodeSizeBudgetFactorForSmallGraphs = 10.0 [Double]
Maximum factor by which full unrolling can increase code size for small
graphs. The FullUnrollSmallGraphThreshold option determines which
graphs are small
FullUnrollConstantCompareBoost = 15 [Integer]
FullUnrollMaxApplication = 60 [Integer]
FullUnrollMaxIterations = 600 [Integer]
FullUnrollMaxNodes = 700 [Integer]
FullUnrollSmallGraphThreshold = 1000 [Integer]
The threshold in terms of NodeSize for a graph to be considered small
for the purpose of full unrolling. Applied in conjunction with the
FullUnrollCodeSizeBudgetFactorForSmallGraphs and
FullUnrollCodeSizeBudgetFactorForLargeGraphs options.
GraalCompileOnly = null [String]
A filter applied to a method the VM has selected for compilation by
Graal. A method not matching the filter is redirected to a lower tier
compiler. The filter format is the same as for the MethodFilter option.
HotSpotDeoptExplicitExceptions = false [Boolean]
Testing only option that forces deopts for exception throws
HotSpotPostOnExceptions = false [Boolean]
Testing only option that forces deopts for exception throws
IgnoreBadDuplications = true [Boolean]
Ignore duplications with a bad benefit cost relation.
InfeasiblePathCorrelationWindowSize = 10 [Integer]
Limit of the number of dominating if nodes to consider in infeasible
path correlation to avoid compile time explosion.
Inline = true [Boolean]
Enable inlining
InlineAllBonus = 1.0 [Double]
The bonus applied to call nodes that can be fully inlined.
InlineDuringParsing = true [Boolean]
Inlines trivial methods during bytecode parsing.
InlineEverything = false [Boolean]
InlineGraalStubs = false [Boolean]
Embed all the emitted code for Graal-generated stubs.
InlineMegamorphicCalls = true [Boolean]
Inline calls with megamorphic type profile (i.e., not all types could
be recorded).
InlineMonomorphicCalls = true [Boolean]
Inline calls with monomorphic type profile.
InlinePartialIntrinsicExitDuringParsing = true [Boolean]
Inlines partial intrinsic exits during bytecode parsing when possible.
A partial intrinsic exit is a call within an intrinsic to the method
being intrinsified and denotes semantics of the original method that
the intrinsic does not support.
InlinePolymorphicCalls = true [Boolean]
Inline calls with polymorphic type profile.
InlineVTableStubs = true [Boolean]
InlinedCompilerNodeLimit = 20000 [Integer]
Controls the maximum number of compiler nodes that can be inlined into
the compiled method.
InversionMinLocalFrequency = 2.0 [Double]
Minimal loop frequency for a loop to be considered for inversion.
InversionMinRelativeFrequency = 1.0 [Double]
Minimal relative frequency for a loop to be considered for inversion.
IsolatedLoopHeaderAlignment = 32 [Integer]
Alignment in bytes for loop header blocks that have no fall through
paths.
IterativePeelingOuterFrequencyBonusThreshold = 4.0 [Double]
Allow iterative peeling of loops with an outer frequency bonus above
this value.
LargeChildrenCountPenaltyCoefficient = 0.005 [Double]
Reduces the likelihood of exploring call graphs that have a lot of
children below the root.
LimitInlinedInvokes = 5.0 [Double]
LoadProfiles = null [String]
Load per compilation profile information.
LogFile = null [String]
File to which logging is sent. A %p in the name will be replaced with a
string identifying the process, usually the process id and %t will be
replaced by System.currentTimeMillis(). If the current runtime is in an
isolate, then %i will be replaced by '' otherwise %i is
removed. An %I is the same as %i except that the replacement is
'@'. Using %o as filename sends logging to
System.out whereas %e sends logging to System.err.
LoopHeaderAlignment = 16 [Integer]
Alignment in bytes for loop header blocks.
LoopMaxUnswitch = 3 [Integer]
LoopRotation = true [Boolean]
Enable Loop Rotation to let the compiler detect more loops as counted.
LoopRotationToxicNodeSetMaxNodecost = 512 [Integer]
Maximum size in NodeSize of the code to be duplicated during rotation.
LoopUnswitchFrequencyBoost = 20.0 [Double]
Number of nodes allowed for a loop unswitching per loop frequency. The
number of nodes allowed for the unswitching is proportional to the
relative frequency of the loop by this constant.
LoopUnswitchFrequencyMaxFactor = 0.95 [Double]
Maximun value for the frequency factor of an invariant.
LoopUnswitchFrequencyMinFactor = 0.05 [Double]
Minimum value for the frequency factor of an invariant.
LoopUnswitchMaxIncrease = 2000 [Integer]
Maximum loop unswitching code size increase in nodes.
LoopUnswitchMinSplitFrequency = 1.0 [Double]
Lower bound for the minimun frequency of an invariant condition to be
unswitched.
LoopUnswitchTrivial = 20 [Integer]
Number of nodes allowed for a loop unswitching regardless of the loop
frequency.
MaxCompilationProblemsPerAction = 2 [Integer]
The maximum number of compilation failures to handle with the action
specified by CompilationFailureAction before changing to a less verbose
action. This does not apply to the ExitVM action.
MaxDuplicationFactor = 2.0 [Double]
Max amount of extra effort to expend handling irreducible loops. A
value <= 1 disables support for irreducible loops.
MaxMispredictionCostIncreaseFactor = 2.0 [Double]
Abstract measure of the cost of branch misprediction. Higher values
make generation of conditional moves more likely.
MaxSimulationIterations = 2 [Integer]
Maximum simulation-duplication iterations of the duplication
optimization per invocation.
MaxSimulationIterationsHotCode = 4 [Integer]
See MaxSimulationIterations.
MaxUnswitchSuccessors = 64 [Integer]
Maximum number of split successors before aborting unswitching.
MaximumDesiredSize = 20000 [Integer]
Maximum desired size of the compiler graph in nodes.
MaximumEscapeAnalysisArrayLength = 128 [Integer]
The maximum length of an array that will be escape analyzed.
MaximumInliningSize = 300 [Integer]
Inlining is explored up to this number of nodes in the graph for each
call site.
MaximumRecursiveInlining = 5 [Integer]
Maximum level of recursive inlining.
MegamorphicInliningMinMethodProbability = 0.33 [Double]
Minimum probability for methods to be inlined for megamorphic type
profiles.
MinimalBulkZeroingSize = 2048 [Integer]
If applicable, use bulk zeroing instructions when the zeroing size in
bytes exceeds this threshold.
MinimalRegions = true [Boolean]
Try to reduce duplication code size to the minimal amount of code.
MinimumBlindedConstantSize = 4 [Integer]
Minimum size (in bytes) of constants to blind.
MinimumPeelFrequency = 0.35 [Float]
MoveGuardsUpwards = true [Boolean]
Move guard nodes to earlier places in the dominator tree if all
successors of basic block share a common guard condition.
NonCountedStripMinedBenefitBoost = 64 [Integer]
Benefit boost for strip mined non counted loops.
NonCountedStripMiningBudget = 0.1 [Double]
Code size budget of the non-counted strip mining transformation in
terms of NodeCostSize.
NonCountedStripMiningBudgetHotCode = 2.5 [Double]
See NonCountedStripMiningBudget.
NonCountedStripMiningForceStripAll = false [Boolean]
Force non-counted strip mining for all loops (also counted ones), test
flag only.
NonCountedStripMiningIgnoreSmallLoops = true [Boolean]
Ignore small loops from strip mining, the iv overhead can cause
slowdowns.
NonCountedStripMiningInnerLoopTrips = -1 [Integer]
The max number of iterations the counted inner loop takes. If -1, the
frequency of the loop will be used to derive an inner frequency.
NonCountedStripMiningMaximumInnerLoopTrips = 8192 [Integer]
If NonCountedStripMiningInnerLoopTrips == -1: Maximum loop trips for
strip mined non-counted loops.
NonCountedStripMiningMinFrequency = 16.0 [Double]
Minimal loop frequency to consider a non-counted loop for strip mining.
NonCountedStripMiningMinimumInnerLoopTrips = 512 [Integer]
If NonCountedStripMiningInnerLoopTrips == -1: Minimum loop trips for
strip mined non-counted loops.
NonCountedStripMiningReuseIVs = true [Boolean]
Try to reuse pre-existing induction variables inside non-counted loops
for the strip-mined loop's exit check.
OptAssumptions = true [Boolean]
OptMethodDuplication = false [Boolean]
Duplicate methods to form hot part and cold part areas.
OverrideProfiles = false [Boolean]
Allow multiple compilations of the same method by overriding existing
profiles.
PartialUnrollCostReductionFactorHighTier = 2 [Integer]
Cost/Benefit heuristic for EE unrolling in high tier: reduce cost by a
constant factor when comparing with relative benefit.
PartialUnrollCostReductionFactorHotCodeMidTier = 32 [Integer]
See PartialUnrollCostReductionFactorMidTier
PartialUnrollCostReductionFactorMidTier = 8 [Integer]
Cost/Benefit heuristic for EE unrolling in mid tier: reduce cost by a
constant factor when comparing with relative benefit.
PartialUnrollMaxIterationsHighTier = 4 [Integer]
Maximum number of iterations to unroll for a high tier main loop.
PartialUnrollMaxIterationsMidTier = 16 [Integer]
Maximum number of iterations to unroll for a mid tier main loop.
PartialUnrollMaxSizeHighTier = 256 [Integer]
Maximum node cost size of a loop to be considered for high tier
unrolling.
PartialUnrollMaxSizeHotCodeMidTier = 1024 [Integer]
See PartialUnrollMaxSizeMidTier
PartialUnrollMaxSizeMidTier = 256 [Integer]
Maximum node cost size of a loop to be considered for mid tier tier
unrolling.
PartialUnrollMinFrequency = 4 [Integer]
Minimal loop frequency to consider a loop for partial unrolling
PeelingConsideredMinLoopIterations = 1.5 [Double]
Minimal loop body iterations necessary to consider peeling.
PeelingConsideredMinRelativeFrequency = 4.0 [Double]
Minimal relative frequency of loop begin necessary to consider peeling.
PeelingHighTierCostReductionFactor = 64.0 [Double]
Cost/Benefit heuristic for EE simulation-based loop peeling in high
tier: reduce cost by a constant factor when comparing with relative
benefit.
PeelingMidTierCostReductionFactor = 8.0 [Double]
Cost/Benefit heuristic for EE simulation-based loop peeling in mid
tier: reduce cost by a constant factor when comparing with relative
benefit.
PenalizeComplexLoopControlFlow = true [Boolean]
Increase the cost of duplicating control flow splits inside loops if
they are not foldable.The generally tend to complicate control flow and
generate worse code in the backend.
PrintLoweringScheduleToTTY = false [Boolean]
Print schedule result pre lowering to TTY.
PrintProfileLoading = false [Boolean]
Print to stdout when a profile is loaded.
ProfileMethodFilter = null [String]
Restrict saving or loading of profiles based on this filter. See the
MethodFilter option for the pattern syntax.
RelativeBenefitInliningCoefficient = 0.001 [Double]
The coefficient used to compute the inlining threshold; the higher, the
hard to inline.
RemoveLoopSafepoints = true [Boolean]
Remove safepoints on counted loop ends.
RewriteStripMinedCounterTo32Bit = true [Boolean]
Rewrite the counter of a strip mined loop to have a 32bit type.
RootSizePenaltyCoefficient = 0.1 [Double]
Reduces likelihood of spending a lot of time inlining when the IR is
already large.
RootSizePenaltyTypicalGraphSize = 3250 [Integer]
At what size of the root IR graph do we start to consider applying a
exploration penalty.
RotateNonLeafLoops = false [Boolean]
RotationMinLocalFrequency = 2.0 [Double]
Minimal loop frequency for a loop to be considered for rotation.
RotationMinRelativeFrequency = 1.0 [Double]
Minimal relative frequency for a loop to be considered for rotation.
SIMDArithmeticReduceMinLength = 16 [Integer]
Minimum vector length for matching SIMD arithmetic reduce patterns.
SaveProfiles = false [Boolean]
Save per compilation profile information.
SaveProfilesPath = null [String]
Path for saving compilation profiles. If the value is omitted the debug
dump path will be used.
ShowConfiguration = none [String]
Writes to the VM log information about the compiler configuration
selected.
SimulationBasedLoopPeeling = true [Boolean]
Use DBDS algorithm to simulate the impact of peeling on a loop.
SimulationPruneUnlikelyBranches = true [Boolean]
Ignore low frequency branches during simulation.
SmallCompiledLowLevelGraphSize = 330 [Integer]
If the previous low-level graph size of the method exceeds the
threshold, it is not inlined.
SmallGraphDuplicationBudgetFactor = 1.0 [Double]
See 'DuplicationBudgetFactor': for small graphs.
SmallGraphSize = 2000 [Integer]
Node cost graph size for a graph to be considered 'small'.
SmallRootIrPenaltyCoefficient = 0.02 [Double]
Reduces the likelihood of exploring call graphs with IR size much
larger than the root.
SpectrePHTIndexMasking = false [Boolean]
Mask indices to scope access to allocation size after bounds check.
StrictProfiles = true [Boolean]
Throw an error if an attempt is made to overwrite/update a profile
loaded from disk.
StringIndexOfConstantLimit = 4096 [Integer]
String.indexOf invocations will be evaluated at compile time if the
receiver is a constant and its length is smaller than this value.
StripMineALot = false [Boolean]
Force strip mining of all loops that can be strip mined.
StripMineInvertedLoops = true [Boolean]
Strip mine inverted loops.
SupportJsrBytecodes = true [Boolean]
SystemicCompilationFailureRate = 1 [Integer]
Compilation failure rate indicating a systemic compilation problem that
will issue a warning. The value is made absolute and clamped to produce
P, a value between 0 and 100. Systemic failure is detected if the
percent of failing compilations in a sliding time window >= P. A
negative value will cause the VM to exit after issuing the warning. Set
to 0 to disable systemic compilation problem detection.
TrivialInliningSize = 10 [Integer]
Graphs with less than this number of nodes are trivial and therefore
always inlined.
TuneInlinerExploration = 0.0 [Double]
Increases or decreases the time spent exploring inlining opportunities
under the assumption that more time results in better peak performance
and less time reduces time to reach (a lower) peak performance. The
value of the option is clamped between -1 and 1 inclusive. Anything
below 0, reduces the exploration time and anything above 0 increases
exploration time. Note that this option is only a heuristic and should
be tuned for any specific application.
TypeCheckMaxHints = 2 [Integer]
The maximum number of profiled types that will be used when compiling a
profiled type check. Note that TypeCheckMinProfileHitProbability also
influences whether profiling info is used in compiled type checks.
TypeCheckMinProfileHitProbability = 0.5 [Double]
If the probability that a type check will hit one the profiled types
(up to TypeCheckMaxHints) is below this value, the type check will be
compiled without profiling info
TypicalCallGraphSize = 100 [Integer]
Denotes the call graph size that is considered medium size.
TypicalGraphSize = 3250 [Integer]
The typical graph size at which inlining pressure must start growing.
TypicalGraphSizeInvokeBonus = 70 [Integer]
The increase in estimated typical graph size after inlining, per each
extra invoke.
TypicalGraphSizeMax = 15000 [Integer]
The maximum in estimated inlined typical graph size.
UnrollMaxIterations = 16 [Integer]
UseBranchesWithin32ByteBoundary = false [Boolean]
Force branch instructions to align with 32-bytes boundary, to mitigate
the jcc erratum. See
https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf
for more details. If not set explicitly, the default value will be
determined according to the CPU model.
UseTrappingNullChecks = true [Boolean]
Use traps for null checks instead of explicit null-checks
VerifyDuplicationOperations = false [Boolean]
WarnAboutCodeSignatureMismatch = true [Boolean]
Print to stdout when a compilation performed with different profiles
generates different backend code.
WarnAboutGraphSignatureMismatch = true [Boolean]
Print to stdout when a compilation performed with different profiles
generates different frontend IR.
WarnAboutNotCachedLoadedAccess = true [Boolean]
Print to stdout when requesting profiling info not present in a loaded
profile.
|
