Last active
March 21, 2019 22:35
-
-
Save retronym/81dca7f53757bca8d41d91b22a2bf003 to your computer and use it in GitHub Desktop.
Graal CE vs EE config options
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| --- graal-ce-config.txt 2018-05-23 13:52:18.000000000 +1000 | |
| +++ graal-ee-config.txt 2018-05-23 13:52:34.000000000 +1000 | |
| @@ -1,11 +1,11 @@ | |
| -scala@scalabench:/usr/lib/jvm$ /usr/lib/jvm/graalvm-ce-1.0.0-rc1/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+JVMCIPrintProperties -version | |
| +scala@scalabench:/usr/lib/jvm$ /usr/lib/jvm/graalvm-1.0.0-rc1/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+JVMCIPrintProperties -version | |
| [JVMCI properties] | |
| jvmci.Compiler := "graal" [String] | |
| Selects the system compiler. This must match the getCompilerName() value returned by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. An empty string or the value "null" selects a compiler that will raise an exception upon receiving a compilation request. This property can also be defined by the contents of <java.home>/lib/jvmci/compiler-name. | |
| jvmci.InitTimer = false [Boolean] | |
| Specifies if initialization timing is enabled. | |
| jvmci.PrintConfig = false [Boolean] | |
| Prints VM configuration available via JVMCI. | |
| jvmci.TraceMethodDataFilter = null [String] | |
| Enables tracing of profiling info when read by JVMCI. | |
| Empty value: trace all methods | |
| @@ -18,20 +18,25 @@ | |
| Enables instruction profiling on assembler level. Valid values are a | |
| comma separated list of supported instructions. Compare with subclasses | |
| of Assembler.InstructionCounter. | |
| graal.AggregatedMetricsFile = null [String] | |
| File to which aggregated metrics are dumped at shutdown. A CSV format | |
| is used if the file ends with .csv otherwise a more human readable | |
| format is used. If not specified, metrics are dumped to the console. | |
| graal.AlwaysInlineIntrinsics = false [Boolean] | |
| Unconditionally inline intrinsics | |
| graal.AlwaysInlineVTableStubs = false [Boolean] | |
| +graal.BaseCodeSizeCostCoefficient = 1.0E-4 [Double] | |
| + The base coefficient used to compute code size cost. | |
| +graal.BaseTargetSpending = 120 [Integer] | |
| + The base target spending used to estimate the inlining threshold; the | |
| + higher, the likelier it is to inline. | |
| graal.BenchmarkCountersDumpDynamic = true [Boolean] | |
| Dump dynamic counters | |
| graal.BenchmarkCountersDumpStatic = false [Boolean] | |
| Dump static counters | |
| graal.BenchmarkCountersFile = null [String] | |
| File to which benchmark counters are dumped. A CSV format is used if | |
| the file ends with .csv otherwise a more human readable format is used. | |
| The fields in the CSV format are: category, group, name, value | |
| graal.BenchmarkDynamicCounters = null [String] | |
| Turn on the benchmark counters, and listen for specific patterns on | |
| @@ -52,29 +57,36 @@ | |
| about allocations within the DaCapo pmd benchmark: | |
| -XX:JVMCICounterSize=<value> -XX:-JVMCICountersExcludeCompiler \ | |
| -Dgraal.BenchmarkDynamicCounters="err, starting ====, PASSED in " \ | |
| -Dgraal.ProfileAllocations=true | |
| The JVMCICounterSize value depends on the granularity of the profiling - | |
| 10000 should be sufficient. Omit JVMCICountersExcludeCompiler to exclude | |
| counting allocations on the compiler threads. | |
| The counters can be further configured by the ProfileAllocationsContext option. | |
| +graal.BlockZeroingLowLimit = 512 [Integer] | |
| + Minimum amount of bytes when block zeroing used. (SPARC only) | |
| graal.BootstrapInitializeOnly = false [Boolean] | |
| Do not compile anything on bootstrap but just initialize the compiler. | |
| graal.BootstrapTimeout = 15.0 [Double] | |
| Maximum time in minutes to spend bootstrapping (0 to disable this | |
| limit). | |
| graal.BootstrapWatchDogCriticalRateRatio = 0.25 [Double] | |
| Ratio of the maximum compilation rate below which the bootstrap | |
| compilation rate must not fall (0 or less disables monitoring). | |
| graal.CallArrayCopy = true [Boolean] | |
| +graal.CallGraphCompilerNodeLimit = 100000 [Integer] | |
| + Controls the maximum number of compiler nodes that can appear in the | |
| + call graph | |
| +graal.CallGraphSizeLimit = 1200 [Integer] | |
| + Controls the maximum size of the call graph before ceasing inlining. | |
| graal.CanOmitFrame = true [Boolean] | |
| graal.CanonicalGraphStringsCheckConstants = false [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsExcludeVirtuals = true [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsRemoveIdentities = true [Boolean] | |
| Attempts to remove object identity hashes when dumping canonical text | |
| for graphs. | |
| graal.ClearMetricsAfterBootstrap = false [Boolean] | |
| Clear the debug metrics after bootstrap. | |
| @@ -103,45 +115,54 @@ | |
| graal.CompilationWatchDogStartDelay = 0.0 [Double] | |
| Delay in seconds before watch dog monitoring a compilation (0 disables | |
| monitoring). | |
| graal.CompileGraalWithC1Only = true [Boolean] | |
| In tiered mode compile Graal and JVMCI using optimized first tier code. | |
| graal.CompilerConfiguration = null [String] | |
| Names the Graal compiler configuration to use. If ommitted, 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. | |
| +graal.CompilerNodePenaltyCoefficient = 0.01 [Double] | |
| + Controls the likelihood of exploring subtrees that already have a lot | |
| + of code during inlining. | |
| graal.ConditionalElimination = true [Boolean] | |
| graal.Count = null [String] | |
| Pattern for specifying scopes in which counters are enabled. See the | |
| Dump option for the pattern syntax. An empty value enables all counters | |
| unconditionally. | |
| graal.Counters = null [String] | |
| Comma separated names of counters that are enabled irrespective of the | |
| value for Count option. An empty value enables all counters | |
| unconditionally. | |
| graal.CrashAt = null [String] | |
| Pattern for method(s) that will trigger an exception when compiled. | |
| This option exists to test handling compilation crashes gracefully. See | |
| the MethodFilter option for the pattern syntax. A ':Bailout' suffix | |
| will raise a bailout exception and a ':PermanentBailout' suffix will | |
| raise a permanent bailout exception. | |
| +graal.CutoffCodeSizePenaltyCoefficient = 1.0E-5 [Double] | |
| + Controls the likelihood of further exploring subtrees with a lot of | |
| + code during inlining. | |
| +graal.DebugLoopInversion = false [Boolean] | |
| + Debug the loop inversion transformation. | |
| graal.DebugStubsAndSnippets = false [Boolean] | |
| Enable debug output for stub code generation and snippet preparation. | |
| graal.DeoptALot = false [Boolean] | |
| graal.DeoptAfterOSR = true [Boolean] | |
| Deoptimize OSR compiled code when the OSR entry loop is finished if | |
| there is no mature profile available for the rest of the method. | |
| graal.DeoptsToDisableOptimisticOptimization = 40 [Integer] | |
| graal.DetailedAsserts = false [Boolean] | |
| Enable expensive assertions if normal assertions (i.e. -ea or -esa) are | |
| enabled. | |
| +graal.DominatorUsageTreeMaxDepth = 16 [Integer] | |
| graal.Dump = null [String] | |
| Filter pattern for specifying scopes in which dumping is enabled. | |
| A filter is a list of comma-separated terms of the form: | |
| <pattern>[:<level>] | |
| If <pattern> contains a "*" or "?" character, it is interpreted as a glob pattern. | |
| Otherwise, it is interpreted as a substring. If <pattern> is empty, it | |
| matches every scope. If :<level> is omitted, it defaults to 1. The term | |
| @@ -200,36 +221,64 @@ | |
| graal.DumpOnError = false [Boolean] | |
| Send Graal compiler IR to dump handlers on error. | |
| graal.DumpOnPhaseChange = null [String] | |
| Dump a before and after graph if the named phase changes the | |
| graph.%nThe argument is substring matched against the simple name of | |
| the phase class | |
| graal.DumpPath = "dumps" [String] | |
| The directory where various Graal dump files are written. | |
| graal.DumpingErrorsAreFatal = false [Boolean] | |
| Treat any exceptions during dumping as fatal. | |
| +graal.DuplicateALot = false [Boolean] | |
| + Perform Duplications as long as there is any sane improvement. | |
| +graal.DuplicationBudgetFactor = 0.25 [Double] | |
| + Percentage in node cost graph size for the duplication budget. Computed | |
| + relative to the methods code size. | |
| +graal.DuplicationBudgetFactorLate = 0.5 [Double] | |
| + Percentage in node cost graph size for the late duplication budget. | |
| + Computed relative to the methods code size. | |
| graal.DynamicCountersPrintGroupSeparator = true [Boolean] | |
| Use grouping separators for number printing | |
| graal.EagerSnippets = false [Boolean] | |
| Eagerly construct extra snippet info. | |
| graal.EscapeAnalysisIterations = 2 [Integer] | |
| graal.EscapeAnalysisLoopCutoff = 20 [Integer] | |
| graal.EscapeAnalyzeOnly = null [String] | |
| graal.ExactFullUnrollMaxNodes = 1200 [Integer] | |
| graal.ExactPartialUnrollMaxNodes = 200 [Integer] | |
| +graal.ExcludeFunctionFromDuplication = null [String] | |
| + Exclude compilations that MethodFilter.match this string from the | |
| + duplication optimization. | |
| graal.ExitVMOnException = false [Boolean] | |
| Alias for CompilationFailureAction=ExitVM. | |
| +graal.ExpandAllProximityBonus = 6.0 [Double] | |
| + The decrease in call graph expansion pressure when there are few call | |
| + nodes left to explore. | |
| +graal.ExpandAllProximityBonusInertia = 2.0 [Double] | |
| + The inertia at which the expand-all proximity bonus decreases with the | |
| + number of yet unexpanded nodes. | |
| +graal.ExpansionInertiaBaseValue = 550 [Integer] | |
| + The slowness at which the expansion pressure grows with code size; the | |
| + higher it is, the slower the pressure growth. | |
| +graal.ExpansionInertiaInvokeBonus = 14 [Integer] | |
| + The extra slowness at which the expansion pressure grows with the code | |
| + size, for each extra invoke node. | |
| +graal.ExpansionInertiaMax = 2000 [Integer] | |
| + The max slowness at which the expansion pressure grows with the code | |
| + size. | |
| graal.FailedLoopExplosionIsFatal = false [Boolean] | |
| Do not bail out but throw an exception on failed loop explosion. | |
| graal.ForceUseOfNewInstanceStub = false [Boolean] | |
| Force non-array object allocation to always use the slow path. | |
| graal.FullUnroll = true [Boolean] | |
| +graal.FullUnrollAsPEACleanup = true [Boolean] | |
| + Perform full unrolling as a Partial Escape Analysis Cleanup | |
| graal.FullUnrollMaxIterations = 600 [Integer] | |
| graal.FullUnrollMaxNodes = 300 [Integer] | |
| graal.GCDebugStartCycle = -1 [Integer] | |
| graal.GenLoopSafepoints = true [Boolean] | |
| graal.GenSafepoints = true [Boolean] | |
| graal.GeneratePIC = false [Boolean] | |
| Generate position independent code | |
| graal.GenericDynamicCounters = false [Boolean] | |
| Turn on the benchmark counters, and displays the results on VM shutdown | |
| graal.GraalArithmeticStubs = false [Boolean] | |
| @@ -239,44 +288,53 @@ | |
| 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. | |
| graal.GraphCompressionThreshold = 70 [Integer] | |
| Graal graph compression is performed when percent of live nodes falls | |
| below this value | |
| graal.GuardPriorities = true [Boolean] | |
| graal.HideSubstitutionStates = false [Boolean] | |
| When creating info points hide the methods of the substitutions. | |
| graal.HotSpotPrintInlining = false [Boolean] | |
| Print inlining optimizations | |
| +graal.IgnoreBadDuplications = true [Boolean] | |
| + Ignore duplications with a bad benefit cost relation. | |
| +graal.IgnoreDeoptSinkBranches = true [Boolean] | |
| + Ignore paths that sink in a deopt during duplication. | |
| graal.ImmutableCode = false [Boolean] | |
| Try to avoid emitting code where patching is required | |
| graal.Inline = true [Boolean] | |
| Enable inlining | |
| +graal.InlineAllBonus = 1.0 [Double] | |
| + The bonus applied to call nodes that can be fully inlined. | |
| graal.InlineDuringParsing = true [Boolean] | |
| Inlines trivial methods during bytecode parsing. | |
| graal.InlineDuringParsingMaxDepth = 10 [Integer] | |
| Maximum depth when inlining during bytecode parsing. | |
| graal.InlineEverything = false [Boolean] | |
| graal.InlineIntrinsicsDuringParsing = true [Boolean] | |
| Inlines intrinsic methods during bytecode parsing. | |
| graal.InlineMegamorphicCalls = true [Boolean] | |
| Inline calls with megamorphic type profile (i.e., not all types could | |
| be recorded). | |
| graal.InlineMonomorphicCalls = true [Boolean] | |
| Inline calls with monomorphic type profile. | |
| graal.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. | |
| graal.InlinePolymorphicCalls = true [Boolean] | |
| Inline calls with polymorphic type profile. | |
| graal.InlineVTableStubs = true [Boolean] | |
| +graal.InlinedCompilerNodeLimit = 50000 [Integer] | |
| + Controls the maximum number of compiler nodes that can be inlined into | |
| + the compiled method. | |
| graal.InliningDepthError = 1000 [Integer] | |
| Maximum inlining depth during partial evaluation before reporting an | |
| infinite recursion | |
| graal.InterceptBailout = false [Boolean] | |
| Intercept also bailout exceptions | |
| graal.Intrinsify = true [Boolean] | |
| Use compiler intrinsifications. | |
| graal.LIRDynMoveProfileMethod = false [Boolean] | |
| Enable dynamic move profiling per method. | |
| graal.LIROptConstantLoadOptimization = true [Boolean] | |
| @@ -319,50 +377,69 @@ | |
| thread at the start of a compiled exception handler. | |
| graal.Log = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.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(). | |
| graal.LogVerbose = false [Boolean] | |
| Enable more verbose log output when available | |
| +graal.LoopInversion = false [Boolean] | |
| + Convert loops into their zero trip form. | |
| graal.LoopMaxUnswitch = 3 [Integer] | |
| graal.LoopPeeling = true [Boolean] | |
| graal.LoopUnswitch = true [Boolean] | |
| graal.LoopUnswitchFrequencyBoost = 10.0 [Double] | |
| graal.LoopUnswitchMaxIncrease = 500 [Integer] | |
| graal.LoopUnswitchTrivial = 10 [Integer] | |
| graal.MatchExpressions = true [Boolean] | |
| Allow backend to match complex expressions. | |
| +graal.MaxCFGRecomputations = 12 [Integer] | |
| graal.MaxCompilationProblemsPerAction = 2 [Integer] | |
| The maximum number of compilation failures or bailouts to handle with | |
| the action specified by CompilationFailureAction or | |
| CompilationBailoutAction before changing to a less verbose action. | |
| +graal.MaxGraphSizeNodeCost = 100000 [Integer] | |
| + Maximum node cost graph size for duplication. If a graph is bigger | |
| + duplication will stop. | |
| +graal.MaxPriorityInliningPeelingIterations = 10 [Integer] | |
| + Max number of precise inlining peeling iterations. | |
| +graal.MaxSimulationIterations = 2 [Integer] | |
| + Maximum simulation-duplication iterations of the duplication | |
| + optimization per invocation. | |
| +graal.MaxSplitsPerNode = 32 [Integer] | |
| graal.MaxTemplatesPerSnippet = 50 [Integer] | |
| +graal.MaxVectorAlignmentUnroll = 4 [Integer] | |
| + Maximum number of unrolled alignment instructions | |
| +graal.MaxVectorUnroll = 16 [Integer] | |
| + Maximum length of linear-code vector operations | |
| graal.MaximumDesiredSize = 20000 [Integer] | |
| Maximum desired size of the compiler graph in nodes. | |
| graal.MaximumEscapeAnalysisArrayLength = 32 [Integer] | |
| graal.MaximumInliningSize = 300 [Integer] | |
| Inlining is explored up to this number of nodes in the graph for each | |
| call site. | |
| graal.MaximumLoopExplosionCount = 10000 [Integer] | |
| Max number of loop explosions per method. | |
| graal.MaximumRecursiveInlining = 5 [Integer] | |
| Maximum level of recursive inlining. | |
| graal.MegamorphicInliningMinMethodProbability = 0.33 [Double] | |
| Minimum probability for methods to be inlined for megamorphic type | |
| profiles. | |
| graal.MemUseTrackers = null [String] | |
| Comma separated names of memory usage trackers that are enabled | |
| irrespective of the value for TrackMemUse option. An empty value | |
| enables all memory usage trackers unconditionally. | |
| +graal.MethodDupCounters = false [Boolean] | |
| +graal.MethodDupOnly = "" [String] | |
| +graal.MethodDupPropagateAnchors = false [Boolean] | |
| graal.MethodFilter = null [String] | |
| Pattern for filtering debug scope output based on method context. | |
| The syntax for a pattern is: | |
| SourcePatterns = SourcePattern ["," SourcePatterns] . | |
| SourcePattern = [ Class "." ] method [ "(" [ Parameter { ";" Parameter } ] ")" ] . | |
| Parameter = Class | "int" | "long" | "float" | "double" | "short" | "char" | "boolean" . | |
| Class = { package "." } class . | |
| Glob pattern matching (*, ?) is allowed in all parts of the source pattern. | |
| @@ -411,49 +488,80 @@ | |
| compilable_identity - identity hash code of compilable | |
| compilation_nr - where this compilation lies in the ordered | |
| sequence of all compilations identified by | |
| compilable_identity | |
| compilation_id - runtime issued identifier for the compilation | |
| metric_name - name of metric | |
| metric_value - value of metric | |
| graal.MetricsThreadFilter = null [String] | |
| Only report metrics for threads whose name matches the regular | |
| expression. | |
| +graal.MinimalRegions = true [Boolean] | |
| + Try to reduce duplication code size to the minimal amount of code. | |
| graal.MinimumPeelProbability = 0.35 [Float] | |
| graal.MitigateSpeculativeExecutionAttacks = false [Boolean] | |
| AMD64: Emit lfence instructions at the beginning of basic blocks | |
| graal.NDCV = 0 [Integer] | |
| Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, | |
| 3 = fatal) | |
| graal.NodeCounters = false [Boolean] | |
| Counts the number of instances of each node class. | |
| graal.NonFatalIdenticalCompilationSnapshots = 20 [Integer] | |
| Number of contiguous identical compiler thread stack traces allowed | |
| before the VM exits on the basis of a stuck compilation. | |
| graal.OmitHotExceptionStacktrace = false [Boolean] | |
| graal.OptAssumptions = true [Boolean] | |
| +graal.OptBulkAllocation = true [Boolean] | |
| graal.OptClearNonLiveLocals = true [Boolean] | |
| +graal.OptCompressedFrameStateValues = true [Boolean] | |
| +graal.OptConditionalMoves = true [Boolean] | |
| + Optimize simple if branches with conditional moves | |
| graal.OptConvertDeoptsToGuards = true [Boolean] | |
| +graal.OptDeDuplication = true [Boolean] | |
| graal.OptDeoptimizationGrouping = true [Boolean] | |
| graal.OptDevirtualizeInvokesOptimistically = true [Boolean] | |
| +graal.OptDuplication = true [Boolean] | |
| graal.OptEarlyReadElimination = true [Boolean] | |
| graal.OptEliminateGuards = true [Boolean] | |
| graal.OptEliminatePartiallyRedundantGuards = true [Boolean] | |
| +graal.OptExactArithmetic = true [Boolean] | |
| graal.OptFilterProfiledTypes = true [Boolean] | |
| graal.OptFloatingReads = true [Boolean] | |
| +graal.OptGuardRangeGrouping = true [Boolean] | |
| graal.OptImplicitNullChecks = true [Boolean] | |
| +graal.OptLateDuplication = false [Boolean] | |
| +graal.OptLockElimination = true [Boolean] | |
| graal.OptLoopTransform = true [Boolean] | |
| +graal.OptMethodDuplication = false [Boolean] | |
| +graal.OptPullThroughPhi = true [Boolean] | |
| graal.OptReadElimination = true [Boolean] | |
| graal.OptScheduleOutOfLoops = true [Boolean] | |
| +graal.OptSpeculativeGuardMovement = true [Boolean] | |
| +graal.OptStringConcat = true [Boolean] | |
| + Optimize StringBuilder construction | |
| +graal.OptStringConcatDump = false [Boolean] | |
| + Dump graphs to help debug operation | |
| +graal.OptWriteBarrierElimination = true [Boolean] | |
| +graal.OptimisticAliasingAnalysis = true [Boolean] | |
| +graal.OptimizeDiv = true [Boolean] | |
| +graal.OptimizeLoopAccesses = true [Boolean] | |
| + Enable access node optimizations for loops | |
| graal.PEAInliningHints = false [Boolean] | |
| graal.PartialEscapeAnalysis = true [Boolean] | |
| +graal.PartialRedundancyElimination = true [Boolean] | |
| + Enable partial redundancy elimination | |
| graal.PartialUnroll = true [Boolean] | |
| +graal.PathDuplicationPhiCutoff = 20 [Integer] | |
| +graal.PeelALot = false [Boolean] | |
| +graal.PeelBackFoldFactor = 100 [Integer] | |
| +graal.PeelForwardFoldFactor = 20 [Integer] | |
| +graal.PeelPotentialFoldFactor = 60 [Integer] | |
| graal.PrintBackendCFG = true [Boolean] | |
| Enable dumping LIR, register allocation and code generation info to the | |
| C1Visualizer. | |
| graal.PrintBinaryGraphPort = 4445 [Integer] | |
| Port part of the address to which graphs are dumped in binary format | |
| (ignored if PrintBinaryGraphs=false). | |
| graal.PrintCFG = false [Boolean] | |
| Enable dumping to the C1Visualizer. Enabling this option implies | |
| PrintBackendCFG. | |
| graal.PrintCanonicalGraphStringFlavor = 0 [Integer] | |
| @@ -492,84 +600,105 @@ | |
| Include the LIR as comments with the final assembly. | |
| graal.PrintProfilingInformation = false [Boolean] | |
| Print profiling information when parsing a method's bytecode | |
| graal.PrintTruffleExpansionHistogram = false [Boolean] | |
| Prints a histogram of all expanded Java methods. | |
| graal.PrintTruffleTrees = true [Boolean] | |
| Enable dumping Truffle ASTs to the IdealGraphVisualizer. | |
| graal.PrintXmlGraphPort = 4444 [Integer] | |
| Port part of the address to which graphs are dumped in XML format | |
| (ignored if PrintBinaryGraphs=true). | |
| +graal.PriorityInliningPolicy = "" [String] | |
| + The policy to use, must be empty for automatic resolution. | |
| graal.ProbabilisticProfiling = true [Boolean] | |
| Control probabilistic profiling on AMD64 | |
| graal.ProfileAllocations = false [Boolean] | |
| Enable profiling of allocation sites. | |
| graal.ProfileAllocationsContext = AllocatingMethod [String] | |
| Control the naming and granularity of the counters when using | |
| ProfileAllocations. | |
| The accepted values are: | |
| AllocatingMethod - a counter per method | |
| InstanceOrArray - one counter for all instance allocations and | |
| one counter for all array allocations | |
| AllocatedType - one counter per allocated type | |
| AllocatedTypesInMethod - one counter per allocated type, per method | |
| graal.ProfileBackedges = true [Boolean] | |
| Emit profiling of backedges | |
| graal.ProfileCompiledMethods = false [Boolean] | |
| graal.ProfileInvokes = true [Boolean] | |
| Emit profiling of invokes | |
| +graal.ProfileLockElimination = false [Boolean] | |
| graal.ProfileMonitors = false [Boolean] | |
| Enable profiling of monitor operations. | |
| graal.ProfileSimpleMethods = true [Boolean] | |
| Profile simple methods | |
| +graal.ProfileTypeSwitches = false [Boolean] | |
| + Turn on typeswitch profiling. This tracks the stability of typeswitches | |
| + after compilation. | |
| +graal.PruneLargeDominatorUsageTrees = true [Boolean] | |
| +graal.PullThroughPhiBudget = 4096.0 [Double] | |
| graal.RawConditionalElimination = true [Boolean] | |
| graal.ReadEliminationMaxLoopVisits = 5 [Integer] | |
| graal.ReassociateInvariants = true [Boolean] | |
| graal.ReduceDCE = true [Boolean] | |
| Disable optional dead code eliminations | |
| graal.RegisterPressure = null [String] | |
| Comma separated list of registers that register allocation is limited | |
| to. | |
| +graal.RelativeBenefitInliningCoefficient = 0.005 [Double] | |
| + The coefficient used to compute the inlining threshold; the higher, the | |
| + hard to inline. | |
| graal.RemoveNeverExecutedCode = true [Boolean] | |
| graal.ReplaceInputsWithConstantsBasedOnStamps = true [Boolean] | |
| graal.ResolveClassBeforeStaticInvoke = false [Boolean] | |
| +graal.ScheduledDuplicationSimulation = false [Boolean] | |
| + Simulation can either only process fixed nodes or schedule the graph | |
| + and also process floating nodes. | |
| graal.ShowConfiguration = none [String] | |
| Writes to the VM log information about the Graal compiler configuration | |
| selected. | |
| graal.ShowDumpFiles = false [Boolean] | |
| Print the name of each dump file path as it's created. | |
| graal.SimpleFastInflatedLocking = true [Boolean] | |
| Handle simple cases for inflated monitors in the fast-path. | |
| graal.SimpleMethodCalls = 1 [Integer] | |
| Maximum number of calls in a simple method | |
| graal.SimpleMethodGraphSize = 256 [Integer] | |
| Maximum number of nodes in a graph for a simple method | |
| graal.SimpleMethodIndirectCalls = 0 [Integer] | |
| Maximum number of indirect calls in a simple moethod | |
| +graal.SimulationStopAtControlFlow = true [Boolean] | |
| + Determines if simulation traversal should stop at control flow | |
| + boundaries that cannot be duplicated. | |
| graal.SmallCompiledLowLevelGraphSize = 300 [Integer] | |
| If the previous low-level graph size of the method exceeds the | |
| threshold, it is not inlined. | |
| graal.SnippetCounters = false [Boolean] | |
| Enable counters for various paths in snippets. | |
| +graal.SpeculativeRewriteCompare = true [Boolean] | |
| +graal.SpeculativeStoreCheck = true [Boolean] | |
| + Speculates that arrays have exact type to optimize store checks | |
| graal.StressExplicitExceptionCode = false [Boolean] | |
| Stress the code emitting explicit exception throwing code. | |
| graal.StressInvokeWithExceptionNode = false [Boolean] | |
| Stress the code emitting invokes with explicit exception edges. | |
| graal.StressTestEarlyReads = false [Boolean] | |
| Stress the code by emitting reads at earliest instead of latest point. | |
| graal.SupportJsrBytecodes = true [Boolean] | |
| graal.SupportOSRWithLocks = true [Boolean] | |
| Support OSR compilations with locks. If DeoptAfterOSR is true we can | |
| per definition not have unbalaced enter/extis mappings. If | |
| DeoptAfterOSR is false insert artificial monitor enters after the | |
| OSRStart to have balanced enter/exits in the graph. | |
| +graal.TailDupOnly = "" [String] | |
| graal.TailDuplicationProbability = 0.5 [Double] | |
| graal.TailDuplicationTrivialSize = 1 [Integer] | |
| graal.TierABackedgeNotifyFreqLog = 16 [Integer] | |
| Backedge notification frequency | |
| graal.TierABackedgeProfileProbabilityLog = 12 [Integer] | |
| Backedge profile probability | |
| graal.TierAInvokeInlineeNotifyFreqLog = -1 [Integer] | |
| Inlinee invocation notification frequency (-1 means count, but do not | |
| notify) | |
| graal.TierAInvokeNotifyFreqLog = 13 [Integer] | |
| @@ -665,32 +794,37 @@ | |
| graal.TraceTruffleCompilationCallTree = false [Boolean] | |
| Print the inlined call tree for each compiled method | |
| graal.TraceTruffleCompilationDetails = false [Boolean] | |
| Print information for compilation queuing | |
| graal.TraceTruffleCompilationPolymorphism = false [Boolean] | |
| Print all polymorphic and generic nodes after each compilation | |
| graal.TraceTruffleExpansionSource = false [Boolean] | |
| Print source secions for printed expansion trees | |
| graal.TraceTruffleInlining = false [Boolean] | |
| Print information for inlining for each compilation. | |
| +graal.TraceTruffleLoopPeeling = false [Boolean] | |
| + Traces loop peeling decisions. | |
| graal.TraceTrufflePerformanceWarnings = false [Boolean] | |
| Print potential performance problems | |
| graal.TraceTruffleSplitting = false [Boolean] | |
| Print information for each splitted call site. | |
| graal.TraceTruffleStackTraceLimit = 20 [Integer] | |
| Number of stack trace elements printed by | |
| TraceTruffleTransferToInterpreter and TraceTruffleAssumptions | |
| graal.TraceTruffleTransferToInterpreter = false [Boolean] | |
| Print stack trace on transfer to interpreter | |
| graal.TraceUnwindStub = false [Boolean] | |
| Trace execution of the stub that routes an exception to a handler in | |
| the calling frame. | |
| +graal.TrackGraphSizesInDuplication = false [Boolean] | |
| + Enable (if Count is enabled) graph size tracking during every | |
| + duplication iteration. | |
| graal.TrackMemUse = null [String] | |
| Pattern for specifying scopes in which memory use tracking is enabled. | |
| See the Dump option for the pattern syntax. An empty value enables all | |
| memory use trackers unconditionally. | |
| graal.TrackNodeInsertion = false [Boolean] | |
| Track source stack trace where a node was inserted into the graph. | |
| graal.TrackNodeSourcePosition = false [Boolean] | |
| Track the NodeSourcePosition. | |
| graal.TrivialInliningSize = 10 [Integer] | |
| Graphs with less than this number of nodes are trivial and therefore | |
| @@ -764,20 +898,27 @@ | |
| Method filter for host methods in which to add instrumentation. | |
| graal.TruffleInstrumentationTableSize = 10000 [Integer] | |
| Maximum number of instrumentation counters available. | |
| graal.TruffleIntrinsifyFrameAccess = true [Boolean] | |
| Intrinsify get/set/is methods of FrameWithoutBoxing to improve Truffle | |
| compilation time | |
| graal.TruffleInvalidationReprofileCount = 3 [Integer] | |
| Delay compilation after an invalidation to allow for reprofiling | |
| graal.TruffleIterativePartialEscape = false [Boolean] | |
| Run the partial escape analysis iteratively in Truffle compilation. | |
| +graal.TruffleLoopPeeling = true [Boolean] | |
| + Enables loop peeling. | |
| +graal.TruffleLoopPeelingMaximumSize = 250 [Integer] | |
| + Maximum loop body node count for loop peeling or a value <= 0 for no | |
| + limit. | |
| +graal.TruffleLoopPeelingProfiling = 2 [Integer] | |
| + Number of loop invocations until loop peeling is decided. | |
| graal.TruffleMaximumRecursiveInlining = 4 [Integer] | |
| Maximum level of recursive inlining | |
| graal.TruffleMinInvokeThreshold = 3 [Integer] | |
| Minimum number of calls before a call target is compiled | |
| graal.TruffleOSR = true [Boolean] | |
| Enable on stack replacement for Truffle loops. | |
| graal.TruffleOSRCompilationThreshold = 100000 [Integer] | |
| Number of loop iterations until on-stack-replacement compilation is | |
| triggered. | |
| graal.TrufflePerformanceWarningsAreFatal = false [Boolean] | |
| @@ -801,52 +942,95 @@ | |
| graal.TruffleTimeThreshold = 50000 [Integer] | |
| Defines the maximum timespan in milliseconds that is required for a | |
| call target to be queued for compilation. | |
| graal.TruffleTraceSplittingSummary = false [Boolean] | |
| Used for debugging the splitting implementation. Prints splitting | |
| summary directly to stdout on shutdown | |
| graal.TruffleUseFrameWithoutBoxing = true [Boolean] | |
| graal.TrustFinalDefaultFields = true [Boolean] | |
| Determines whether to treat final fields with default values as | |
| constant. | |
| +graal.TryExplodeOverPhis = true [Boolean] | |
| +graal.TryPhiPhiPulls = true [Boolean] | |
| graal.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. | |
| graal.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 | |
| +graal.TypicalGraphSize = 3250 [Integer] | |
| + The typical graph size at which inlining pressure must start growing. | |
| +graal.TypicalGraphSizeInvokeBonus = 70 [Integer] | |
| + The increase in estimated typical graph size after inlining, per each | |
| + extra invoke. | |
| +graal.TypicalGraphSizeMax = 10000 [Integer] | |
| + The maximum in estimated inlined typical graph size. | |
| graal.UnrollMaxIterations = 16 [Integer] | |
| graal.UseCompilationStatistics = false [Boolean] | |
| Enables CompilationStatistics. | |
| graal.UseExceptionProbability = true [Boolean] | |
| +graal.UseGraphCache = true [Boolean] | |
| + Turn on graph caching. | |
| graal.UseGuardedIntrinsics = true [Boolean] | |
| Use intrinsics guarded by a virtual dispatch test at indirect call | |
| sites. | |
| graal.UseLoopLimitChecks = true [Boolean] | |
| +graal.UsePolymorphicInlining = true [Boolean] | |
| + Inline polymorphic calls based on callsite receiver profiles. | |
| +graal.UsePriorityInlining = true [Boolean] | |
| + Use priority-based inlining. | |
| graal.UseSnippetGraphCache = true [Boolean] | |
| Use a cache for snippet graphs. | |
| graal.UseSnippetTemplateCache = true [Boolean] | |
| Use a LRU cache for snippet templates. | |
| graal.UseTrappingNullChecks = true [Boolean] | |
| Use traps for null checks instead of explicit null-checks | |
| graal.UseTypeCheckHints = true [Boolean] | |
| +graal.VectorIntrinsics = true [Boolean] | |
| + Enable vectorized array copy intrinsics | |
| +graal.VectorUnroll = 1 [Integer] | |
| + Unroll vectorized loops | |
| +graal.Vectorization = true [Boolean] | |
| + Enable vectorization | |
| +graal.VectorizeAllocation = true [Boolean] | |
| + Enable vectorized array initialization | |
| +graal.VectorizeConditional = false [Boolean] | |
| + Enable vectorization of conditional code. | |
| +graal.VectorizeFoldShaped = true [Boolean] | |
| + Enable vectorization of loops implementing a higher-order 'fold' | |
| + function. | |
| +graal.VectorizeLoops = true [Boolean] | |
| + Enable vectorization of loops | |
| +graal.VectorizeMapShaped = true [Boolean] | |
| + Enable vectorization of loops implementing a higher-order 'map' | |
| + function. | |
| +graal.VectorizeNegativeStride = true [Boolean] | |
| + Enable vectorization of loops with negative strides. | |
| +graal.VectorizeSIMD = false [Boolean] | |
| + Enable detection of SIMD patterns | |
| +graal.VectorizeSequence = true [Boolean] | |
| + Enable vectorization of sequence values. | |
| graal.Verify = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.VerifyBalancedMonitors = false [Boolean] | |
| Emit extra code to dynamically check monitor operations are balanced. | |
| +graal.VerifyDuplicationOperations = false [Boolean] | |
| graal.VerifyGraalGraphEdges = false [Boolean] | |
| Perform expensive verification of graph inputs, usages, successors and | |
| predecessors | |
| graal.VerifyGraalGraphs = true [Boolean] | |
| Verify graphs often during compilation when assertions are turned on | |
| graal.VerifyGraalPhasesSize = false [Boolean] | |
| Verify before - after relation of the relative, computed, code size of | |
| a graph | |
| graal.VerifyHeapAtReturn = false [Boolean] | |
| Perform platform dependent validation of the Java heap at returns | |
| graal.VerifyKillCFGUnusedNodes = false [Boolean] | |
| Verify that there are no new unused nodes when performing killCFG | |
| graal.VerifyPhases = false [Boolean] | |
| +graal.VerifyWriteBarrierElimination = false [Boolean] | |
| + Add code to verify that eliminated barriers weren't needed. Not | |
| + implemented for G1. | |
| graal.ZapStackOnMethodEntry = false [Boolean] |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| scala@scalabench:/usr/lib/jvm$ /usr/lib/jvm/graalvm-ce-1.0.0-rc1/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+JVMCIPrintProperties -version | |
| [JVMCI properties] | |
| jvmci.Compiler := "graal" [String] | |
| Selects the system compiler. This must match the getCompilerName() value returned by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. An empty string or the value "null" selects a compiler that will raise an exception upon receiving a compilation request. This property can also be defined by the contents of <java.home>/lib/jvmci/compiler-name. | |
| jvmci.InitTimer = false [Boolean] | |
| Specifies if initialization timing is enabled. | |
| jvmci.PrintConfig = false [Boolean] | |
| Prints VM configuration available via JVMCI. | |
| jvmci.TraceMethodDataFilter = null [String] | |
| Enables tracing of profiling info when read by JVMCI. | |
| Empty value: trace all methods | |
| Non-empty value: trace methods whose fully qualified name contains the value. | |
| [Graal properties] | |
| graal.AOTInliningDepthToSizeRate = 2.5 [Double] | |
| graal.AOTInliningSizeMaximum = 300 [Integer] | |
| graal.AOTInliningSizeMinimum = 50 [Integer] | |
| graal.ASMInstructionProfiling = null [String] | |
| Enables instruction profiling on assembler level. Valid values are a | |
| comma separated list of supported instructions. Compare with subclasses | |
| of Assembler.InstructionCounter. | |
| graal.AggregatedMetricsFile = null [String] | |
| File to which aggregated metrics are dumped at shutdown. A CSV format | |
| is used if the file ends with .csv otherwise a more human readable | |
| format is used. If not specified, metrics are dumped to the console. | |
| graal.AlwaysInlineIntrinsics = false [Boolean] | |
| Unconditionally inline intrinsics | |
| graal.AlwaysInlineVTableStubs = false [Boolean] | |
| graal.BenchmarkCountersDumpDynamic = true [Boolean] | |
| Dump dynamic counters | |
| graal.BenchmarkCountersDumpStatic = false [Boolean] | |
| Dump static counters | |
| graal.BenchmarkCountersFile = null [String] | |
| File to which benchmark counters are dumped. A CSV format is used if | |
| the file ends with .csv otherwise a more human readable format is used. | |
| The fields in the CSV format are: category, group, name, value | |
| graal.BenchmarkDynamicCounters = null [String] | |
| Turn on the benchmark counters, and listen for specific patterns on | |
| System.out/System.err. | |
| The format of this option is: | |
| (err|out),start pattern,end pattern | |
| You can use "~" to match 1 or more digits. | |
| Examples: | |
| err, starting =====, PASSED in | |
| out,Iteration ~ (~s) begins:,Iteration ~ (~s) ends: | |
| The first pattern matches DaCapo output and the second matches SPECjvm2008 output. | |
| As a more detailed example, here are the options to use for getting statistics | |
| about allocations within the DaCapo pmd benchmark: | |
| -XX:JVMCICounterSize=<value> -XX:-JVMCICountersExcludeCompiler \ | |
| -Dgraal.BenchmarkDynamicCounters="err, starting ====, PASSED in " \ | |
| -Dgraal.ProfileAllocations=true | |
| The JVMCICounterSize value depends on the granularity of the profiling - | |
| 10000 should be sufficient. Omit JVMCICountersExcludeCompiler to exclude | |
| counting allocations on the compiler threads. | |
| The counters can be further configured by the ProfileAllocationsContext option. | |
| graal.BootstrapInitializeOnly = false [Boolean] | |
| Do not compile anything on bootstrap but just initialize the compiler. | |
| graal.BootstrapTimeout = 15.0 [Double] | |
| Maximum time in minutes to spend bootstrapping (0 to disable this | |
| limit). | |
| graal.BootstrapWatchDogCriticalRateRatio = 0.25 [Double] | |
| Ratio of the maximum compilation rate below which the bootstrap | |
| compilation rate must not fall (0 or less disables monitoring). | |
| graal.CallArrayCopy = true [Boolean] | |
| graal.CanOmitFrame = true [Boolean] | |
| graal.CanonicalGraphStringsCheckConstants = false [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsExcludeVirtuals = true [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsRemoveIdentities = true [Boolean] | |
| Attempts to remove object identity hashes when dumping canonical text | |
| for graphs. | |
| graal.ClearMetricsAfterBootstrap = false [Boolean] | |
| Clear the debug metrics after bootstrap. | |
| graal.CompilationBailoutAction = Silent [String] | |
| Specifies the action to take when compilation fails with a bailout | |
| exception. | |
| 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. | |
| graal.CompilationCountLimit = 0 [Integer] | |
| The number of compilations allowed for any method before the VM exits | |
| (a value of 0 means there is no limit). | |
| graal.CompilationExpirationPeriod = 300 [Integer] | |
| Time limit in seconds before a compilation expires (0 to disable the | |
| limit). The compilation alarm will be implicitly disabled if assertions | |
| are enabled. | |
| graal.CompilationFailureAction = Diagnose [String] | |
| Specifies the action to take when compilation fails with a bailout | |
| exception. The accepted values are the same as for | |
| CompilationBailoutAction. | |
| graal.CompilationWatchDogStackTraceInterval = 60.0 [Double] | |
| Interval in seconds between a watch dog reporting stack traces for long | |
| running compilations. | |
| graal.CompilationWatchDogStartDelay = 0.0 [Double] | |
| Delay in seconds before watch dog monitoring a compilation (0 disables | |
| monitoring). | |
| graal.CompileGraalWithC1Only = true [Boolean] | |
| In tiered mode compile Graal and JVMCI using optimized first tier code. | |
| graal.CompilerConfiguration = null [String] | |
| Names the Graal compiler configuration to use. If ommitted, 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. | |
| graal.ConditionalElimination = true [Boolean] | |
| graal.Count = null [String] | |
| Pattern for specifying scopes in which counters are enabled. See the | |
| Dump option for the pattern syntax. An empty value enables all counters | |
| unconditionally. | |
| graal.Counters = null [String] | |
| Comma separated names of counters that are enabled irrespective of the | |
| value for Count option. An empty value enables all counters | |
| unconditionally. | |
| graal.CrashAt = null [String] | |
| Pattern for method(s) that will trigger an exception when compiled. | |
| This option exists to test handling compilation crashes gracefully. See | |
| the MethodFilter option for the pattern syntax. A ':Bailout' suffix | |
| will raise a bailout exception and a ':PermanentBailout' suffix will | |
| raise a permanent bailout exception. | |
| graal.DebugStubsAndSnippets = false [Boolean] | |
| Enable debug output for stub code generation and snippet preparation. | |
| graal.DeoptALot = false [Boolean] | |
| graal.DeoptAfterOSR = true [Boolean] | |
| Deoptimize OSR compiled code when the OSR entry loop is finished if | |
| there is no mature profile available for the rest of the method. | |
| graal.DeoptsToDisableOptimisticOptimization = 40 [Integer] | |
| graal.DetailedAsserts = false [Boolean] | |
| Enable expensive assertions if normal assertions (i.e. -ea or -esa) are | |
| enabled. | |
| graal.Dump = null [String] | |
| Filter pattern for specifying scopes in which dumping is enabled. | |
| A filter is a list of comma-separated terms of the form: | |
| <pattern>[:<level>] | |
| If <pattern> contains a "*" or "?" character, it is interpreted as a glob pattern. | |
| Otherwise, it is interpreted as a substring. If <pattern> is empty, it | |
| matches every scope. If :<level> is omitted, it defaults to 1. The term | |
| ~<pattern> is a shorthand for <pattern>:0 to disable a debug facility for a pattern. | |
| The default log level is 0 (disabled). Terms with an empty pattern set | |
| the default log level to the specified value. The last | |
| matching term with a non-empty pattern selects the level specified. If | |
| no term matches, the log level is the default level. A filter with no | |
| terms matches every scope with a log level of 1. | |
| Examples of debug filters: | |
| --------- | |
| (empty string) | |
| Matches any scope with level 1. | |
| --------- | |
| :1 | |
| Matches any scope with level 1. | |
| --------- | |
| * | |
| Matches any scope with level 1. | |
| --------- | |
| CodeGen,CodeInstall | |
| Matches scopes containing "CodeGen" or "CodeInstall", both with level 1. | |
| --------- | |
| CodeGen:2,CodeInstall:1 | |
| Matches scopes containing "CodeGen" with level 2, or "CodeInstall" with level 1. | |
| --------- | |
| Outer:2,Inner:0} | |
| Matches scopes containing "Outer" with log level 2, or "Inner" with log level 0. If the scope | |
| name contains both patterns then the log level will be 0. This is useful for silencing subscopes. | |
| --------- | |
| :1,Dead:2 | |
| Matches scopes containing "Dead" with level 2, and all other scopes with level 1. | |
| --------- | |
| Dead:0,:1 | |
| Matches all scopes with level 1, except those containing "Dead". Note that the location of | |
| the :1 doesn't matter since it's specifying the default log level so it's the same as | |
| specifying :1,Dead:0. | |
| --------- | |
| Code* | |
| Matches scopes starting with "Code" with level 1. | |
| --------- | |
| Code,~Dead | |
| Matches scopes containing "Code" but not "Dead", with level 1. | |
| graal.DumpOnError = false [Boolean] | |
| Send Graal compiler IR to dump handlers on error. | |
| graal.DumpOnPhaseChange = null [String] | |
| Dump a before and after graph if the named phase changes the | |
| graph.%nThe argument is substring matched against the simple name of | |
| the phase class | |
| graal.DumpPath = "dumps" [String] | |
| The directory where various Graal dump files are written. | |
| graal.DumpingErrorsAreFatal = false [Boolean] | |
| Treat any exceptions during dumping as fatal. | |
| graal.DynamicCountersPrintGroupSeparator = true [Boolean] | |
| Use grouping separators for number printing | |
| graal.EagerSnippets = false [Boolean] | |
| Eagerly construct extra snippet info. | |
| graal.EscapeAnalysisIterations = 2 [Integer] | |
| graal.EscapeAnalysisLoopCutoff = 20 [Integer] | |
| graal.EscapeAnalyzeOnly = null [String] | |
| graal.ExactFullUnrollMaxNodes = 1200 [Integer] | |
| graal.ExactPartialUnrollMaxNodes = 200 [Integer] | |
| graal.ExitVMOnException = false [Boolean] | |
| Alias for CompilationFailureAction=ExitVM. | |
| graal.FailedLoopExplosionIsFatal = false [Boolean] | |
| Do not bail out but throw an exception on failed loop explosion. | |
| graal.ForceUseOfNewInstanceStub = false [Boolean] | |
| Force non-array object allocation to always use the slow path. | |
| graal.FullUnroll = true [Boolean] | |
| graal.FullUnrollMaxIterations = 600 [Integer] | |
| graal.FullUnrollMaxNodes = 300 [Integer] | |
| graal.GCDebugStartCycle = -1 [Integer] | |
| graal.GenLoopSafepoints = true [Boolean] | |
| graal.GenSafepoints = true [Boolean] | |
| graal.GeneratePIC = false [Boolean] | |
| Generate position independent code | |
| graal.GenericDynamicCounters = false [Boolean] | |
| Turn on the benchmark counters, and displays the results on VM shutdown | |
| graal.GraalArithmeticStubs = false [Boolean] | |
| Use Graal arithmetic stubs instead of HotSpot stubs where possible | |
| graal.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. | |
| graal.GraphCompressionThreshold = 70 [Integer] | |
| Graal graph compression is performed when percent of live nodes falls | |
| below this value | |
| graal.GuardPriorities = true [Boolean] | |
| graal.HideSubstitutionStates = false [Boolean] | |
| When creating info points hide the methods of the substitutions. | |
| graal.HotSpotPrintInlining = false [Boolean] | |
| Print inlining optimizations | |
| graal.ImmutableCode = false [Boolean] | |
| Try to avoid emitting code where patching is required | |
| graal.Inline = true [Boolean] | |
| Enable inlining | |
| graal.InlineDuringParsing = true [Boolean] | |
| Inlines trivial methods during bytecode parsing. | |
| graal.InlineDuringParsingMaxDepth = 10 [Integer] | |
| Maximum depth when inlining during bytecode parsing. | |
| graal.InlineEverything = false [Boolean] | |
| graal.InlineIntrinsicsDuringParsing = true [Boolean] | |
| Inlines intrinsic methods during bytecode parsing. | |
| graal.InlineMegamorphicCalls = true [Boolean] | |
| Inline calls with megamorphic type profile (i.e., not all types could | |
| be recorded). | |
| graal.InlineMonomorphicCalls = true [Boolean] | |
| Inline calls with monomorphic type profile. | |
| graal.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. | |
| graal.InlinePolymorphicCalls = true [Boolean] | |
| Inline calls with polymorphic type profile. | |
| graal.InlineVTableStubs = true [Boolean] | |
| graal.InliningDepthError = 1000 [Integer] | |
| Maximum inlining depth during partial evaluation before reporting an | |
| infinite recursion | |
| graal.InterceptBailout = false [Boolean] | |
| Intercept also bailout exceptions | |
| graal.Intrinsify = true [Boolean] | |
| Use compiler intrinsifications. | |
| graal.LIRDynMoveProfileMethod = false [Boolean] | |
| Enable dynamic move profiling per method. | |
| graal.LIROptConstantLoadOptimization = true [Boolean] | |
| Enable constant load optimization. | |
| graal.LIROptControlFlowOptimizer = true [Boolean] | |
| graal.LIROptEdgeMoveOptimizer = true [Boolean] | |
| graal.LIROptLSRAEliminateSpillMoves = true [Boolean] | |
| Enable spill move elimination. | |
| graal.LIROptLSRAOptimizeSpillPosition = true [Boolean] | |
| Enable spill position optimization | |
| graal.LIROptLSStackSlotAllocator = true [Boolean] | |
| Use linear scan stack slot allocation. | |
| graal.LIROptNullCheckOptimizer = true [Boolean] | |
| graal.LIROptRedundantMoveElimination = true [Boolean] | |
| graal.LIROptStackMoveOptimizer = true [Boolean] | |
| graal.LIROptTraceRAEliminateSpillMoves = true [Boolean] | |
| Enable spill position optimization | |
| graal.LIROptimization = true [Boolean] | |
| Enable LIR level optimiztations. | |
| graal.LIRProfileMethods = false [Boolean] | |
| Enables profiling of methods. | |
| graal.LIRProfileMoves = false [Boolean] | |
| Enables profiling of move types on LIR level. Move types are for | |
| example stores (register to stack), constant loads (constant to | |
| register) or copies (register to register). | |
| graal.LIRUnlockBackendRestart = false [Boolean] | |
| Unlock backend restart feature. | |
| graal.LSRAOptSplitOnly = false [Boolean] | |
| LSRA optimization: Only split but do not reassign | |
| graal.LSRAOptimization = false [Boolean] | |
| Enable LSRA optimization | |
| graal.LimitInlinedInvokes = 5.0 [Double] | |
| graal.ListMetrics = false [Boolean] | |
| Lists on the console at VM shutdown the metric names available to the | |
| Timers, Counters and MemUseTrackers options. Note that this only lists | |
| the metrics that were initialized during the VM execution and so will | |
| not include metrics for compiler code that is not executed. | |
| graal.LoadExceptionObjectInVM = false [Boolean] | |
| Use a VM runtime call to load and clear the exception object from the | |
| thread at the start of a compiled exception handler. | |
| graal.Log = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.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(). | |
| graal.LogVerbose = false [Boolean] | |
| Enable more verbose log output when available | |
| graal.LoopMaxUnswitch = 3 [Integer] | |
| graal.LoopPeeling = true [Boolean] | |
| graal.LoopUnswitch = true [Boolean] | |
| graal.LoopUnswitchFrequencyBoost = 10.0 [Double] | |
| graal.LoopUnswitchMaxIncrease = 500 [Integer] | |
| graal.LoopUnswitchTrivial = 10 [Integer] | |
| graal.MatchExpressions = true [Boolean] | |
| Allow backend to match complex expressions. | |
| graal.MaxCompilationProblemsPerAction = 2 [Integer] | |
| The maximum number of compilation failures or bailouts to handle with | |
| the action specified by CompilationFailureAction or | |
| CompilationBailoutAction before changing to a less verbose action. | |
| graal.MaxTemplatesPerSnippet = 50 [Integer] | |
| graal.MaximumDesiredSize = 20000 [Integer] | |
| Maximum desired size of the compiler graph in nodes. | |
| graal.MaximumEscapeAnalysisArrayLength = 32 [Integer] | |
| graal.MaximumInliningSize = 300 [Integer] | |
| Inlining is explored up to this number of nodes in the graph for each | |
| call site. | |
| graal.MaximumLoopExplosionCount = 10000 [Integer] | |
| Max number of loop explosions per method. | |
| graal.MaximumRecursiveInlining = 5 [Integer] | |
| Maximum level of recursive inlining. | |
| graal.MegamorphicInliningMinMethodProbability = 0.33 [Double] | |
| Minimum probability for methods to be inlined for megamorphic type | |
| profiles. | |
| graal.MemUseTrackers = null [String] | |
| Comma separated names of memory usage trackers that are enabled | |
| irrespective of the value for TrackMemUse option. An empty value | |
| enables all memory usage trackers unconditionally. | |
| graal.MethodFilter = null [String] | |
| Pattern for filtering debug scope output based on method context. | |
| The syntax for a pattern is: | |
| SourcePatterns = SourcePattern ["," SourcePatterns] . | |
| SourcePattern = [ Class "." ] method [ "(" [ Parameter { ";" Parameter } ] ")" ] . | |
| Parameter = Class | "int" | "long" | "float" | "double" | "short" | "char" | "boolean" . | |
| Class = { package "." } class . | |
| Glob pattern matching (*, ?) is allowed in all parts of the source pattern. | |
| Examples of method filters: | |
| --------- | |
| visit(Argument;BlockScope) | |
| Matches all methods named "visit", with the first parameter of | |
| type "Argument", and the second parameter of type "BlockScope". | |
| The packages of the parameter types are irrelevant. | |
| --------- | |
| arraycopy(Object;;;;) | |
| Matches all methods named "arraycopy", with the first parameter | |
| of type "Object", and four more parameters of any type. The | |
| packages of the parameter types are irrelevant. | |
| --------- | |
| org.graalvm.compiler.core.graph.PostOrderNodeIterator.* | |
| Matches all methods in the class "org.graalvm.compiler.core.graph.PostOrderNodeIterator". | |
| --------- | |
| * | |
| Matches all methods in all classes | |
| --------- | |
| org.graalvm.compiler.core.graph.*.visit | |
| Matches all methods named "visit" in classes in the package | |
| "org.graalvm.compiler.core.graph". | |
| --------- | |
| arraycopy,toString | |
| Matches all methods named "arraycopy" or "toString", meaning that ',' acts as an or operator. | |
| graal.MethodFilterRootOnly = false [Boolean] | |
| Only check MethodFilter against the root method in the context if true, | |
| otherwise check all methods | |
| graal.MethodInlineBailoutLimit = 5000 [Integer] | |
| Per-compilation method inlining exploration limit before giving up (use | |
| 0 to disable) | |
| graal.MetricsFile = null [String] | |
| File to which metrics are dumped per compilation. | |
| A CSV format is used if the file ends with .csv otherwise a more | |
| human readable format is used. The fields in the CSV format are: | |
| compilable - method being compiled | |
| compilable_identity - identity hash code of compilable | |
| compilation_nr - where this compilation lies in the ordered | |
| sequence of all compilations identified by | |
| compilable_identity | |
| compilation_id - runtime issued identifier for the compilation | |
| metric_name - name of metric | |
| metric_value - value of metric | |
| graal.MetricsThreadFilter = null [String] | |
| Only report metrics for threads whose name matches the regular | |
| expression. | |
| graal.MinimumPeelProbability = 0.35 [Float] | |
| graal.MitigateSpeculativeExecutionAttacks = false [Boolean] | |
| AMD64: Emit lfence instructions at the beginning of basic blocks | |
| graal.NDCV = 0 [Integer] | |
| Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, | |
| 3 = fatal) | |
| graal.NodeCounters = false [Boolean] | |
| Counts the number of instances of each node class. | |
| graal.NonFatalIdenticalCompilationSnapshots = 20 [Integer] | |
| Number of contiguous identical compiler thread stack traces allowed | |
| before the VM exits on the basis of a stuck compilation. | |
| graal.OmitHotExceptionStacktrace = false [Boolean] | |
| graal.OptAssumptions = true [Boolean] | |
| graal.OptClearNonLiveLocals = true [Boolean] | |
| graal.OptConvertDeoptsToGuards = true [Boolean] | |
| graal.OptDeoptimizationGrouping = true [Boolean] | |
| graal.OptDevirtualizeInvokesOptimistically = true [Boolean] | |
| graal.OptEarlyReadElimination = true [Boolean] | |
| graal.OptEliminateGuards = true [Boolean] | |
| graal.OptEliminatePartiallyRedundantGuards = true [Boolean] | |
| graal.OptFilterProfiledTypes = true [Boolean] | |
| graal.OptFloatingReads = true [Boolean] | |
| graal.OptImplicitNullChecks = true [Boolean] | |
| graal.OptLoopTransform = true [Boolean] | |
| graal.OptReadElimination = true [Boolean] | |
| graal.OptScheduleOutOfLoops = true [Boolean] | |
| graal.PEAInliningHints = false [Boolean] | |
| graal.PartialEscapeAnalysis = true [Boolean] | |
| graal.PartialUnroll = true [Boolean] | |
| graal.PrintBackendCFG = true [Boolean] | |
| Enable dumping LIR, register allocation and code generation info to the | |
| C1Visualizer. | |
| graal.PrintBinaryGraphPort = 4445 [Integer] | |
| Port part of the address to which graphs are dumped in binary format | |
| (ignored if PrintBinaryGraphs=false). | |
| graal.PrintCFG = false [Boolean] | |
| Enable dumping to the C1Visualizer. Enabling this option implies | |
| PrintBackendCFG. | |
| graal.PrintCanonicalGraphStringFlavor = 0 [Integer] | |
| Choose format used when dumping canonical text for graphs: 0 gives a | |
| scheduled graph (better for spotting changes involving the schedule) | |
| while 1 gives a CFG containing expressions rooted at fixed nodes | |
| (better for spotting small structure differences) | |
| graal.PrintCanonicalGraphStrings = false [Boolean] | |
| Enable dumping canonical text from for graphs. | |
| graal.PrintCompilation = false [Boolean] | |
| Print an informational line to the console for each completed | |
| compilation. | |
| graal.PrintGraph = true [Boolean] | |
| Enable dumping to the IdealGraphVisualizer. | |
| graal.PrintGraphFile = false [Boolean] | |
| Print graphs to files instead of sending them over the network. | |
| graal.PrintGraphHost = "127.0.0.1" [String] | |
| Host part of the address to which graphs are dumped. | |
| graal.PrintGraphProbabilities = false [Boolean] | |
| Output probabilities for fixed nodes during binary graph dumping. | |
| graal.PrintGraphWithSchedule = false [Boolean] | |
| Schedule graphs as they are dumped. | |
| graal.PrintIRWithLIR = false [Boolean] | |
| Print HIR along side LIR as the latter is generated | |
| graal.PrintIdealGraph = true [Boolean] | |
| Deprecated - use PrintGraph instead. | |
| graal.PrintIdealGraphAddress = "127.0.0.1" [String] | |
| Deprecated - use PrintGraphHost instead. | |
| graal.PrintIdealGraphFile = false [Boolean] | |
| Deprecated - use PrintGraphFile instead. | |
| graal.PrintIdealGraphPort = 4444 [Integer] | |
| Deprecated - use PrintXmlGraphPort instead. | |
| graal.PrintIdealGraphSchedule = false [Boolean] | |
| Deprecated - use PrintGraphWithSchedule instead. | |
| graal.PrintLIRWithAssembly = false [Boolean] | |
| Include the LIR as comments with the final assembly. | |
| graal.PrintProfilingInformation = false [Boolean] | |
| Print profiling information when parsing a method's bytecode | |
| graal.PrintTruffleExpansionHistogram = false [Boolean] | |
| Prints a histogram of all expanded Java methods. | |
| graal.PrintTruffleTrees = true [Boolean] | |
| Enable dumping Truffle ASTs to the IdealGraphVisualizer. | |
| graal.PrintXmlGraphPort = 4444 [Integer] | |
| Port part of the address to which graphs are dumped in XML format | |
| (ignored if PrintBinaryGraphs=true). | |
| graal.ProbabilisticProfiling = true [Boolean] | |
| Control probabilistic profiling on AMD64 | |
| graal.ProfileAllocations = false [Boolean] | |
| Enable profiling of allocation sites. | |
| graal.ProfileAllocationsContext = AllocatingMethod [String] | |
| Control the naming and granularity of the counters when using | |
| ProfileAllocations. | |
| The accepted values are: | |
| AllocatingMethod - a counter per method | |
| InstanceOrArray - one counter for all instance allocations and | |
| one counter for all array allocations | |
| AllocatedType - one counter per allocated type | |
| AllocatedTypesInMethod - one counter per allocated type, per method | |
| graal.ProfileBackedges = true [Boolean] | |
| Emit profiling of backedges | |
| graal.ProfileCompiledMethods = false [Boolean] | |
| graal.ProfileInvokes = true [Boolean] | |
| Emit profiling of invokes | |
| graal.ProfileMonitors = false [Boolean] | |
| Enable profiling of monitor operations. | |
| graal.ProfileSimpleMethods = true [Boolean] | |
| Profile simple methods | |
| graal.RawConditionalElimination = true [Boolean] | |
| graal.ReadEliminationMaxLoopVisits = 5 [Integer] | |
| graal.ReassociateInvariants = true [Boolean] | |
| graal.ReduceDCE = true [Boolean] | |
| Disable optional dead code eliminations | |
| graal.RegisterPressure = null [String] | |
| Comma separated list of registers that register allocation is limited | |
| to. | |
| graal.RemoveNeverExecutedCode = true [Boolean] | |
| graal.ReplaceInputsWithConstantsBasedOnStamps = true [Boolean] | |
| graal.ResolveClassBeforeStaticInvoke = false [Boolean] | |
| graal.ShowConfiguration = none [String] | |
| Writes to the VM log information about the Graal compiler configuration | |
| selected. | |
| graal.ShowDumpFiles = false [Boolean] | |
| Print the name of each dump file path as it's created. | |
| graal.SimpleFastInflatedLocking = true [Boolean] | |
| Handle simple cases for inflated monitors in the fast-path. | |
| graal.SimpleMethodCalls = 1 [Integer] | |
| Maximum number of calls in a simple method | |
| graal.SimpleMethodGraphSize = 256 [Integer] | |
| Maximum number of nodes in a graph for a simple method | |
| graal.SimpleMethodIndirectCalls = 0 [Integer] | |
| Maximum number of indirect calls in a simple moethod | |
| graal.SmallCompiledLowLevelGraphSize = 300 [Integer] | |
| If the previous low-level graph size of the method exceeds the | |
| threshold, it is not inlined. | |
| graal.SnippetCounters = false [Boolean] | |
| Enable counters for various paths in snippets. | |
| graal.StressExplicitExceptionCode = false [Boolean] | |
| Stress the code emitting explicit exception throwing code. | |
| graal.StressInvokeWithExceptionNode = false [Boolean] | |
| Stress the code emitting invokes with explicit exception edges. | |
| graal.StressTestEarlyReads = false [Boolean] | |
| Stress the code by emitting reads at earliest instead of latest point. | |
| graal.SupportJsrBytecodes = true [Boolean] | |
| graal.SupportOSRWithLocks = true [Boolean] | |
| Support OSR compilations with locks. If DeoptAfterOSR is true we can | |
| per definition not have unbalaced enter/extis mappings. If | |
| DeoptAfterOSR is false insert artificial monitor enters after the | |
| OSRStart to have balanced enter/exits in the graph. | |
| graal.TailDuplicationProbability = 0.5 [Double] | |
| graal.TailDuplicationTrivialSize = 1 [Integer] | |
| graal.TierABackedgeNotifyFreqLog = 16 [Integer] | |
| Backedge notification frequency | |
| graal.TierABackedgeProfileProbabilityLog = 12 [Integer] | |
| Backedge profile probability | |
| graal.TierAInvokeInlineeNotifyFreqLog = -1 [Integer] | |
| Inlinee invocation notification frequency (-1 means count, but do not | |
| notify) | |
| graal.TierAInvokeNotifyFreqLog = 13 [Integer] | |
| Invocation notification frequency | |
| graal.TierAInvokeProfileProbabilityLog = 8 [Integer] | |
| Invocation profile probability | |
| graal.TieredAOT = false [Boolean] | |
| Do profiling and callbacks to tiered runtime | |
| graal.Time = null [String] | |
| Pattern for specifying scopes in which timing is enabled. See the Dump | |
| option for the pattern syntax. An empty value enables all timers | |
| unconditionally. | |
| graal.TimedDynamicCounters = -1 [Integer] | |
| Turn on the benchmark counters, and displays the results every n | |
| milliseconds | |
| graal.Timers = null [String] | |
| Comma separated names of timers that are enabled irrespective of the | |
| value for Time option. An empty value enables all timers | |
| unconditionally. | |
| graal.TraceBuilding = UniDirectional [String] | |
| Trace building algorithm. | |
| graal.TraceBytecodeParserLevel = 0 [Integer] | |
| The trace level for the bytecode parser. A value of 1 enables | |
| instruction tracing and any greater value emits a frame state trace | |
| just prior to each instruction trace.Instruction tracing output from | |
| multiple compiler threads will be interleaved so use of this option | |
| make most sense for single threaded compilation.The MethodFilter option | |
| can be used to refine tracing to selected methods. | |
| graal.TraceEscapeAnalysis = false [Boolean] | |
| graal.TraceExceptionHandlerStub = false [Boolean] | |
| Trace execution of stub used to handle an exception thrown by a callee. | |
| graal.TraceInlineDuringParsing = false [Boolean] | |
| Traces inlining performed during bytecode parsing. | |
| graal.TraceInlining = false [Boolean] | |
| Enable tracing of inlining decisions. | |
| Output format: | |
| compilation of 'Signature of the compilation root method': | |
| at 'Signature of the root method' ['Bytecode index']: <'Phase'> 'Child method signature': 'Decision made about this callsite' | |
| at 'Signature of the child method' ['Bytecode index']: | |
| ├──<'Phase 1'> 'Grandchild method signature': 'First decision made about this callsite' | |
| └──<'Phase 2'> 'Grandchild method signature': 'Second decision made about this callsite' | |
| at 'Signature of the child method' ['Bytecode index']: <'Phase'> 'Another grandchild method signature': 'The only decision made about this callsite.' | |
| graal.TraceInliningForStubsAndSnippets = false [Boolean] | |
| Enable inlining decision tracing in stubs and snippets. | |
| graal.TraceLIRGeneratorLevel = 0 [Integer] | |
| The trace level for the LIR generator | |
| graal.TraceMonitorsMethodFilter = null [String] | |
| Trace monitor operations in methods whose fully qualified name contains | |
| this substring. | |
| graal.TraceMonitorsTypeFilter = null [String] | |
| Trace monitor operations on objects whose type contains this substring. | |
| graal.TraceNewArrayStub = false [Boolean] | |
| Trace execution of slow path stub for array allocation. | |
| graal.TraceNewInstanceStub = false [Boolean] | |
| Trace execution of slow path stub for non-array object allocation. | |
| graal.TraceParserPlugins = false [Boolean] | |
| Traces use of plugins during bytecode parsing. | |
| graal.TraceRA = false [Boolean] | |
| Enable experimental Trace Register Allocation. | |
| graal.TraceRACacheStackSlots = true [Boolean] | |
| Cache stack slots globally (i.e. a variable always gets the same slot | |
| in every trace). | |
| graal.TraceRAPolicy = Default [String] | |
| TraceRA allocation policy to use. | |
| graal.TraceRAScheduleTrivialTracesEarly = true [Boolean] | |
| Schedule trivial traces as early as possible. | |
| graal.TraceRAalmostTrivialSize = 2 [Integer] | |
| Use BottomUp if there is only one block with at most this number of | |
| instructions | |
| graal.TraceRAbottomUpRatio = 0.0 [Double] | |
| Use LSRA / BottomUp ratio | |
| graal.TraceRAnumVariables = null [Integer] | |
| Use BottomUp for traces with low number of variables at block | |
| boundaries | |
| graal.TraceRAprobalilityThreshold = 0.8 [Double] | |
| Probability Threshold | |
| graal.TraceRAreuseStackSlotsForMoveResolutionCycleBreaking = true [Boolean] | |
| Reuse spill slots for global move resolution cycle breaking. | |
| graal.TraceRAshareSpillInformation = true [Boolean] | |
| Share information about spilled values to other traces. | |
| graal.TraceRAsumBudget = 0.5 [Double] | |
| Sum Probability Budget Threshold | |
| graal.TraceRAtrivialBlockAllocator = true [Boolean] | |
| Use special allocator for trivial blocks. | |
| graal.TraceRAuseInterTraceHints = true [Boolean] | |
| Use inter-trace register hints. | |
| graal.TraceTruffleAssumptions = false [Boolean] | |
| Print stack trace on assumption invalidation | |
| graal.TraceTruffleCompilation = false [Boolean] | |
| Print information for compilation results | |
| graal.TraceTruffleCompilationAST = false [Boolean] | |
| Print all polymorphic and generic nodes after each compilation | |
| graal.TraceTruffleCompilationCallTree = false [Boolean] | |
| Print the inlined call tree for each compiled method | |
| graal.TraceTruffleCompilationDetails = false [Boolean] | |
| Print information for compilation queuing | |
| graal.TraceTruffleCompilationPolymorphism = false [Boolean] | |
| Print all polymorphic and generic nodes after each compilation | |
| graal.TraceTruffleExpansionSource = false [Boolean] | |
| Print source secions for printed expansion trees | |
| graal.TraceTruffleInlining = false [Boolean] | |
| Print information for inlining for each compilation. | |
| graal.TraceTrufflePerformanceWarnings = false [Boolean] | |
| Print potential performance problems | |
| graal.TraceTruffleSplitting = false [Boolean] | |
| Print information for each splitted call site. | |
| graal.TraceTruffleStackTraceLimit = 20 [Integer] | |
| Number of stack trace elements printed by | |
| TraceTruffleTransferToInterpreter and TraceTruffleAssumptions | |
| graal.TraceTruffleTransferToInterpreter = false [Boolean] | |
| Print stack trace on transfer to interpreter | |
| graal.TraceUnwindStub = false [Boolean] | |
| Trace execution of the stub that routes an exception to a handler in | |
| the calling frame. | |
| graal.TrackMemUse = null [String] | |
| Pattern for specifying scopes in which memory use tracking is enabled. | |
| See the Dump option for the pattern syntax. An empty value enables all | |
| memory use trackers unconditionally. | |
| graal.TrackNodeInsertion = false [Boolean] | |
| Track source stack trace where a node was inserted into the graph. | |
| graal.TrackNodeSourcePosition = false [Boolean] | |
| Track the NodeSourcePosition. | |
| graal.TrivialInliningSize = 10 [Integer] | |
| Graphs with less than this number of nodes are trivial and therefore | |
| always inlined. | |
| graal.TruffleArgumentTypeSpeculation = true [Boolean] | |
| graal.TruffleBackgroundCompilation = true [Boolean] | |
| Enable asynchronous truffle compilation in background thread | |
| graal.TruffleCompilationExceptionsAreFatal = false [Boolean] | |
| Treat compilation exceptions as fatal exceptions that will exit the | |
| application | |
| graal.TruffleCompilationExceptionsArePrinted = true [Boolean] | |
| Prints the exception stack trace for compilation exceptions | |
| graal.TruffleCompilationExceptionsAreThrown = false [Boolean] | |
| Treat compilation exceptions as thrown runtime exceptions | |
| graal.TruffleCompilationStatisticDetails = false [Boolean] | |
| Print additional more verbose Truffle compilation statistics at the end | |
| of a run. | |
| graal.TruffleCompilationStatistics = false [Boolean] | |
| Print Truffle compilation statistics at the end of a run. | |
| graal.TruffleCompilationThreshold = 1000 [Integer] | |
| Compile call target when call count exceeds this threshold | |
| graal.TruffleCompileImmediately = false [Boolean] | |
| Compile immediately to test truffle compiler | |
| graal.TruffleCompileOnly = null [String] | |
| Restrict compilation to comma-separated list of includes (or excludes | |
| prefixed with tilde) | |
| graal.TruffleCompilerConfiguration = null [String] | |
| Select a Graal compiler configuration for Truffle compilation (default: | |
| use Graal system compiler configuration). | |
| graal.TruffleCompilerThreads = 0 [Integer] | |
| Manually set the number of compiler threads | |
| graal.TruffleEnableInfopoints = false [Boolean] | |
| Enable support for simple infopoints in truffle partial evaluations. | |
| graal.TruffleExcludeAssertions = true [Boolean] | |
| Exclude assertion code from Truffle compilations | |
| graal.TruffleExperimentalSplitting = false [Boolean] | |
| Use the splitting strategy that relies on language implementations | |
| reporting polymorpic specializations. Disables forced splits. | |
| graal.TruffleExperimentalSplittingAllowForcedSplits = false [Boolean] | |
| Should forced splits be allowed (when using experimental splitting) | |
| graal.TruffleExperimentalSplittingDumpDecisions = false [Boolean] | |
| Dumps to IGV information on polymorphic events | |
| graal.TruffleExperimentalSplittingMaxPropagationDepth = 5 [Integer] | |
| Propagate info about a polymorphic specialize through maximum this many | |
| call targets | |
| graal.TruffleFunctionInlining = true [Boolean] | |
| Enable automatic inlining of call targets | |
| graal.TruffleInlineAcrossTruffleBoundary = false [Boolean] | |
| Enable inlining across Truffle boundary | |
| graal.TruffleInliningMaxCallerSize = 2250 [Integer] | |
| Stop inlining if caller's cumulative tree size would exceed this limit | |
| graal.TruffleInstrumentBoundaries = false [Boolean] | |
| Instrument Truffle boundaries and output profiling information to the | |
| standard output. | |
| graal.TruffleInstrumentBoundariesPerInlineSite = false [Boolean] | |
| Instrument Truffle boundaries by considering different inlining sites | |
| as different branches. | |
| graal.TruffleInstrumentBranches = false [Boolean] | |
| Instrument branches and output profiling information to the standard | |
| output. | |
| graal.TruffleInstrumentBranchesCount = 10000 [Integer] | |
| Maximum number of instrumentation counters available. | |
| graal.TruffleInstrumentBranchesFilter = null [String] | |
| Method filter for methods in which to add branch instrumentation. | |
| graal.TruffleInstrumentBranchesPerInlineSite = false [Boolean] | |
| Instrument branches by considering different inlining sites as | |
| different branches. | |
| graal.TruffleInstrumentBranchesPretty = true [Boolean] | |
| Prettify stack traces for branch-instrumented callsites. | |
| graal.TruffleInstrumentFilter = "*.*.*" [String] | |
| Method filter for host methods in which to add instrumentation. | |
| graal.TruffleInstrumentationTableSize = 10000 [Integer] | |
| Maximum number of instrumentation counters available. | |
| graal.TruffleIntrinsifyFrameAccess = true [Boolean] | |
| Intrinsify get/set/is methods of FrameWithoutBoxing to improve Truffle | |
| compilation time | |
| graal.TruffleInvalidationReprofileCount = 3 [Integer] | |
| Delay compilation after an invalidation to allow for reprofiling | |
| graal.TruffleIterativePartialEscape = false [Boolean] | |
| Run the partial escape analysis iteratively in Truffle compilation. | |
| graal.TruffleMaximumRecursiveInlining = 4 [Integer] | |
| Maximum level of recursive inlining | |
| graal.TruffleMinInvokeThreshold = 3 [Integer] | |
| Minimum number of calls before a call target is compiled | |
| graal.TruffleOSR = true [Boolean] | |
| Enable on stack replacement for Truffle loops. | |
| graal.TruffleOSRCompilationThreshold = 100000 [Integer] | |
| Number of loop iterations until on-stack-replacement compilation is | |
| triggered. | |
| graal.TrufflePerformanceWarningsAreFatal = false [Boolean] | |
| Treat performance warnings as fatal occurrences that will exit the | |
| applications | |
| graal.TruffleProfilingEnabled = true [Boolean] | |
| Enable/disable builtin profiles in com.oracle.truffle.api.profiles. | |
| graal.TruffleReplaceReprofileCount = 3 [Integer] | |
| Delay compilation after a node replacement | |
| graal.TruffleReturnTypeSpeculation = true [Boolean] | |
| graal.TruffleSplitting = true [Boolean] | |
| Enable call target splitting | |
| graal.TruffleSplittingGrowthLimit = 1.5 [Double] | |
| Disable call target splitting if the number of nodes created by | |
| splitting exceeds this factor times node count | |
| graal.TruffleSplittingMaxCalleeSize = 100 [Integer] | |
| Disable call target splitting if tree size exceeds this limit | |
| graal.TruffleSplittingMaxNumberOfSplitNodes = 500000 [Integer] | |
| Disable call target splitting if number of nodes created by splitting | |
| exceeds this limit | |
| graal.TruffleTimeThreshold = 50000 [Integer] | |
| Defines the maximum timespan in milliseconds that is required for a | |
| call target to be queued for compilation. | |
| graal.TruffleTraceSplittingSummary = false [Boolean] | |
| Used for debugging the splitting implementation. Prints splitting | |
| summary directly to stdout on shutdown | |
| graal.TruffleUseFrameWithoutBoxing = true [Boolean] | |
| graal.TrustFinalDefaultFields = true [Boolean] | |
| Determines whether to treat final fields with default values as | |
| constant. | |
| graal.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. | |
| graal.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 | |
| graal.UnrollMaxIterations = 16 [Integer] | |
| graal.UseCompilationStatistics = false [Boolean] | |
| Enables CompilationStatistics. | |
| graal.UseExceptionProbability = true [Boolean] | |
| graal.UseGuardedIntrinsics = true [Boolean] | |
| Use intrinsics guarded by a virtual dispatch test at indirect call | |
| sites. | |
| graal.UseLoopLimitChecks = true [Boolean] | |
| graal.UseSnippetGraphCache = true [Boolean] | |
| Use a cache for snippet graphs. | |
| graal.UseSnippetTemplateCache = true [Boolean] | |
| Use a LRU cache for snippet templates. | |
| graal.UseTrappingNullChecks = true [Boolean] | |
| Use traps for null checks instead of explicit null-checks | |
| graal.UseTypeCheckHints = true [Boolean] | |
| graal.Verify = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.VerifyBalancedMonitors = false [Boolean] | |
| Emit extra code to dynamically check monitor operations are balanced. | |
| graal.VerifyGraalGraphEdges = false [Boolean] | |
| Perform expensive verification of graph inputs, usages, successors and | |
| predecessors | |
| graal.VerifyGraalGraphs = true [Boolean] | |
| Verify graphs often during compilation when assertions are turned on | |
| graal.VerifyGraalPhasesSize = false [Boolean] | |
| Verify before - after relation of the relative, computed, code size of | |
| a graph | |
| graal.VerifyHeapAtReturn = false [Boolean] | |
| Perform platform dependent validation of the Java heap at returns | |
| graal.VerifyKillCFGUnusedNodes = false [Boolean] | |
| Verify that there are no new unused nodes when performing killCFG | |
| graal.VerifyPhases = false [Boolean] | |
| graal.ZapStackOnMethodEntry = false [Boolean] |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| scala@scalabench:/usr/lib/jvm$ /usr/lib/jvm/graalvm-1.0.0-rc1/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+JVMCIPrintProperties -version | |
| [JVMCI properties] | |
| jvmci.Compiler := "graal" [String] | |
| Selects the system compiler. This must match the getCompilerName() value returned by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. An empty string or the value "null" selects a compiler that will raise an exception upon receiving a compilation request. This property can also be defined by the contents of <java.home>/lib/jvmci/compiler-name. | |
| jvmci.InitTimer = false [Boolean] | |
| Specifies if initialization timing is enabled. | |
| jvmci.PrintConfig = false [Boolean] | |
| Prints VM configuration available via JVMCI. | |
| jvmci.TraceMethodDataFilter = null [String] | |
| Enables tracing of profiling info when read by JVMCI. | |
| Empty value: trace all methods | |
| Non-empty value: trace methods whose fully qualified name contains the value. | |
| [Graal properties] | |
| graal.AOTInliningDepthToSizeRate = 2.5 [Double] | |
| graal.AOTInliningSizeMaximum = 300 [Integer] | |
| graal.AOTInliningSizeMinimum = 50 [Integer] | |
| graal.ASMInstructionProfiling = null [String] | |
| Enables instruction profiling on assembler level. Valid values are a | |
| comma separated list of supported instructions. Compare with subclasses | |
| of Assembler.InstructionCounter. | |
| graal.AggregatedMetricsFile = null [String] | |
| File to which aggregated metrics are dumped at shutdown. A CSV format | |
| is used if the file ends with .csv otherwise a more human readable | |
| format is used. If not specified, metrics are dumped to the console. | |
| graal.AlwaysInlineIntrinsics = false [Boolean] | |
| Unconditionally inline intrinsics | |
| graal.AlwaysInlineVTableStubs = false [Boolean] | |
| graal.BaseCodeSizeCostCoefficient = 1.0E-4 [Double] | |
| The base coefficient used to compute code size cost. | |
| graal.BaseTargetSpending = 120 [Integer] | |
| The base target spending used to estimate the inlining threshold; the | |
| higher, the likelier it is to inline. | |
| graal.BenchmarkCountersDumpDynamic = true [Boolean] | |
| Dump dynamic counters | |
| graal.BenchmarkCountersDumpStatic = false [Boolean] | |
| Dump static counters | |
| graal.BenchmarkCountersFile = null [String] | |
| File to which benchmark counters are dumped. A CSV format is used if | |
| the file ends with .csv otherwise a more human readable format is used. | |
| The fields in the CSV format are: category, group, name, value | |
| graal.BenchmarkDynamicCounters = null [String] | |
| Turn on the benchmark counters, and listen for specific patterns on | |
| System.out/System.err. | |
| The format of this option is: | |
| (err|out),start pattern,end pattern | |
| You can use "~" to match 1 or more digits. | |
| Examples: | |
| err, starting =====, PASSED in | |
| out,Iteration ~ (~s) begins:,Iteration ~ (~s) ends: | |
| The first pattern matches DaCapo output and the second matches SPECjvm2008 output. | |
| As a more detailed example, here are the options to use for getting statistics | |
| about allocations within the DaCapo pmd benchmark: | |
| -XX:JVMCICounterSize=<value> -XX:-JVMCICountersExcludeCompiler \ | |
| -Dgraal.BenchmarkDynamicCounters="err, starting ====, PASSED in " \ | |
| -Dgraal.ProfileAllocations=true | |
| The JVMCICounterSize value depends on the granularity of the profiling - | |
| 10000 should be sufficient. Omit JVMCICountersExcludeCompiler to exclude | |
| counting allocations on the compiler threads. | |
| The counters can be further configured by the ProfileAllocationsContext option. | |
| graal.BlockZeroingLowLimit = 512 [Integer] | |
| Minimum amount of bytes when block zeroing used. (SPARC only) | |
| graal.BootstrapInitializeOnly = false [Boolean] | |
| Do not compile anything on bootstrap but just initialize the compiler. | |
| graal.BootstrapTimeout = 15.0 [Double] | |
| Maximum time in minutes to spend bootstrapping (0 to disable this | |
| limit). | |
| graal.BootstrapWatchDogCriticalRateRatio = 0.25 [Double] | |
| Ratio of the maximum compilation rate below which the bootstrap | |
| compilation rate must not fall (0 or less disables monitoring). | |
| graal.CallArrayCopy = true [Boolean] | |
| graal.CallGraphCompilerNodeLimit = 100000 [Integer] | |
| Controls the maximum number of compiler nodes that can appear in the | |
| call graph | |
| graal.CallGraphSizeLimit = 1200 [Integer] | |
| Controls the maximum size of the call graph before ceasing inlining. | |
| graal.CanOmitFrame = true [Boolean] | |
| graal.CanonicalGraphStringsCheckConstants = false [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsExcludeVirtuals = true [Boolean] | |
| Exclude virtual nodes when dumping canonical text for graphs. | |
| graal.CanonicalGraphStringsRemoveIdentities = true [Boolean] | |
| Attempts to remove object identity hashes when dumping canonical text | |
| for graphs. | |
| graal.ClearMetricsAfterBootstrap = false [Boolean] | |
| Clear the debug metrics after bootstrap. | |
| graal.CompilationBailoutAction = Silent [String] | |
| Specifies the action to take when compilation fails with a bailout | |
| exception. | |
| 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. | |
| graal.CompilationCountLimit = 0 [Integer] | |
| The number of compilations allowed for any method before the VM exits | |
| (a value of 0 means there is no limit). | |
| graal.CompilationExpirationPeriod = 300 [Integer] | |
| Time limit in seconds before a compilation expires (0 to disable the | |
| limit). The compilation alarm will be implicitly disabled if assertions | |
| are enabled. | |
| graal.CompilationFailureAction = Diagnose [String] | |
| Specifies the action to take when compilation fails with a bailout | |
| exception. The accepted values are the same as for | |
| CompilationBailoutAction. | |
| graal.CompilationWatchDogStackTraceInterval = 60.0 [Double] | |
| Interval in seconds between a watch dog reporting stack traces for long | |
| running compilations. | |
| graal.CompilationWatchDogStartDelay = 0.0 [Double] | |
| Delay in seconds before watch dog monitoring a compilation (0 disables | |
| monitoring). | |
| graal.CompileGraalWithC1Only = true [Boolean] | |
| In tiered mode compile Graal and JVMCI using optimized first tier code. | |
| graal.CompilerConfiguration = null [String] | |
| Names the Graal compiler configuration to use. If ommitted, 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. | |
| graal.CompilerNodePenaltyCoefficient = 0.01 [Double] | |
| Controls the likelihood of exploring subtrees that already have a lot | |
| of code during inlining. | |
| graal.ConditionalElimination = true [Boolean] | |
| graal.Count = null [String] | |
| Pattern for specifying scopes in which counters are enabled. See the | |
| Dump option for the pattern syntax. An empty value enables all counters | |
| unconditionally. | |
| graal.Counters = null [String] | |
| Comma separated names of counters that are enabled irrespective of the | |
| value for Count option. An empty value enables all counters | |
| unconditionally. | |
| graal.CrashAt = null [String] | |
| Pattern for method(s) that will trigger an exception when compiled. | |
| This option exists to test handling compilation crashes gracefully. See | |
| the MethodFilter option for the pattern syntax. A ':Bailout' suffix | |
| will raise a bailout exception and a ':PermanentBailout' suffix will | |
| raise a permanent bailout exception. | |
| graal.CutoffCodeSizePenaltyCoefficient = 1.0E-5 [Double] | |
| Controls the likelihood of further exploring subtrees with a lot of | |
| code during inlining. | |
| graal.DebugLoopInversion = false [Boolean] | |
| Debug the loop inversion transformation. | |
| graal.DebugStubsAndSnippets = false [Boolean] | |
| Enable debug output for stub code generation and snippet preparation. | |
| graal.DeoptALot = false [Boolean] | |
| graal.DeoptAfterOSR = true [Boolean] | |
| Deoptimize OSR compiled code when the OSR entry loop is finished if | |
| there is no mature profile available for the rest of the method. | |
| graal.DeoptsToDisableOptimisticOptimization = 40 [Integer] | |
| graal.DetailedAsserts = false [Boolean] | |
| Enable expensive assertions if normal assertions (i.e. -ea or -esa) are | |
| enabled. | |
| graal.DominatorUsageTreeMaxDepth = 16 [Integer] | |
| graal.Dump = null [String] | |
| Filter pattern for specifying scopes in which dumping is enabled. | |
| A filter is a list of comma-separated terms of the form: | |
| <pattern>[:<level>] | |
| If <pattern> contains a "*" or "?" character, it is interpreted as a glob pattern. | |
| Otherwise, it is interpreted as a substring. If <pattern> is empty, it | |
| matches every scope. If :<level> is omitted, it defaults to 1. The term | |
| ~<pattern> is a shorthand for <pattern>:0 to disable a debug facility for a pattern. | |
| The default log level is 0 (disabled). Terms with an empty pattern set | |
| the default log level to the specified value. The last | |
| matching term with a non-empty pattern selects the level specified. If | |
| no term matches, the log level is the default level. A filter with no | |
| terms matches every scope with a log level of 1. | |
| Examples of debug filters: | |
| --------- | |
| (empty string) | |
| Matches any scope with level 1. | |
| --------- | |
| :1 | |
| Matches any scope with level 1. | |
| --------- | |
| * | |
| Matches any scope with level 1. | |
| --------- | |
| CodeGen,CodeInstall | |
| Matches scopes containing "CodeGen" or "CodeInstall", both with level 1. | |
| --------- | |
| CodeGen:2,CodeInstall:1 | |
| Matches scopes containing "CodeGen" with level 2, or "CodeInstall" with level 1. | |
| --------- | |
| Outer:2,Inner:0} | |
| Matches scopes containing "Outer" with log level 2, or "Inner" with log level 0. If the scope | |
| name contains both patterns then the log level will be 0. This is useful for silencing subscopes. | |
| --------- | |
| :1,Dead:2 | |
| Matches scopes containing "Dead" with level 2, and all other scopes with level 1. | |
| --------- | |
| Dead:0,:1 | |
| Matches all scopes with level 1, except those containing "Dead". Note that the location of | |
| the :1 doesn't matter since it's specifying the default log level so it's the same as | |
| specifying :1,Dead:0. | |
| --------- | |
| Code* | |
| Matches scopes starting with "Code" with level 1. | |
| --------- | |
| Code,~Dead | |
| Matches scopes containing "Code" but not "Dead", with level 1. | |
| graal.DumpOnError = false [Boolean] | |
| Send Graal compiler IR to dump handlers on error. | |
| graal.DumpOnPhaseChange = null [String] | |
| Dump a before and after graph if the named phase changes the | |
| graph.%nThe argument is substring matched against the simple name of | |
| the phase class | |
| graal.DumpPath = "dumps" [String] | |
| The directory where various Graal dump files are written. | |
| graal.DumpingErrorsAreFatal = false [Boolean] | |
| Treat any exceptions during dumping as fatal. | |
| graal.DuplicateALot = false [Boolean] | |
| Perform Duplications as long as there is any sane improvement. | |
| graal.DuplicationBudgetFactor = 0.25 [Double] | |
| Percentage in node cost graph size for the duplication budget. Computed | |
| relative to the methods code size. | |
| graal.DuplicationBudgetFactorLate = 0.5 [Double] | |
| Percentage in node cost graph size for the late duplication budget. | |
| Computed relative to the methods code size. | |
| graal.DynamicCountersPrintGroupSeparator = true [Boolean] | |
| Use grouping separators for number printing | |
| graal.EagerSnippets = false [Boolean] | |
| Eagerly construct extra snippet info. | |
| graal.EscapeAnalysisIterations = 2 [Integer] | |
| graal.EscapeAnalysisLoopCutoff = 20 [Integer] | |
| graal.EscapeAnalyzeOnly = null [String] | |
| graal.ExactFullUnrollMaxNodes = 1200 [Integer] | |
| graal.ExactPartialUnrollMaxNodes = 200 [Integer] | |
| graal.ExcludeFunctionFromDuplication = null [String] | |
| Exclude compilations that MethodFilter.match this string from the | |
| duplication optimization. | |
| graal.ExitVMOnException = false [Boolean] | |
| Alias for CompilationFailureAction=ExitVM. | |
| graal.ExpandAllProximityBonus = 6.0 [Double] | |
| The decrease in call graph expansion pressure when there are few call | |
| nodes left to explore. | |
| graal.ExpandAllProximityBonusInertia = 2.0 [Double] | |
| The inertia at which the expand-all proximity bonus decreases with the | |
| number of yet unexpanded nodes. | |
| graal.ExpansionInertiaBaseValue = 550 [Integer] | |
| The slowness at which the expansion pressure grows with code size; the | |
| higher it is, the slower the pressure growth. | |
| graal.ExpansionInertiaInvokeBonus = 14 [Integer] | |
| The extra slowness at which the expansion pressure grows with the code | |
| size, for each extra invoke node. | |
| graal.ExpansionInertiaMax = 2000 [Integer] | |
| The max slowness at which the expansion pressure grows with the code | |
| size. | |
| graal.FailedLoopExplosionIsFatal = false [Boolean] | |
| Do not bail out but throw an exception on failed loop explosion. | |
| graal.ForceUseOfNewInstanceStub = false [Boolean] | |
| Force non-array object allocation to always use the slow path. | |
| graal.FullUnroll = true [Boolean] | |
| graal.FullUnrollAsPEACleanup = true [Boolean] | |
| Perform full unrolling as a Partial Escape Analysis Cleanup | |
| graal.FullUnrollMaxIterations = 600 [Integer] | |
| graal.FullUnrollMaxNodes = 300 [Integer] | |
| graal.GCDebugStartCycle = -1 [Integer] | |
| graal.GenLoopSafepoints = true [Boolean] | |
| graal.GenSafepoints = true [Boolean] | |
| graal.GeneratePIC = false [Boolean] | |
| Generate position independent code | |
| graal.GenericDynamicCounters = false [Boolean] | |
| Turn on the benchmark counters, and displays the results on VM shutdown | |
| graal.GraalArithmeticStubs = false [Boolean] | |
| Use Graal arithmetic stubs instead of HotSpot stubs where possible | |
| graal.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. | |
| graal.GraphCompressionThreshold = 70 [Integer] | |
| Graal graph compression is performed when percent of live nodes falls | |
| below this value | |
| graal.GuardPriorities = true [Boolean] | |
| graal.HideSubstitutionStates = false [Boolean] | |
| When creating info points hide the methods of the substitutions. | |
| graal.HotSpotPrintInlining = false [Boolean] | |
| Print inlining optimizations | |
| graal.IgnoreBadDuplications = true [Boolean] | |
| Ignore duplications with a bad benefit cost relation. | |
| graal.IgnoreDeoptSinkBranches = true [Boolean] | |
| Ignore paths that sink in a deopt during duplication. | |
| graal.ImmutableCode = false [Boolean] | |
| Try to avoid emitting code where patching is required | |
| graal.Inline = true [Boolean] | |
| Enable inlining | |
| graal.InlineAllBonus = 1.0 [Double] | |
| The bonus applied to call nodes that can be fully inlined. | |
| graal.InlineDuringParsing = true [Boolean] | |
| Inlines trivial methods during bytecode parsing. | |
| graal.InlineDuringParsingMaxDepth = 10 [Integer] | |
| Maximum depth when inlining during bytecode parsing. | |
| graal.InlineEverything = false [Boolean] | |
| graal.InlineIntrinsicsDuringParsing = true [Boolean] | |
| Inlines intrinsic methods during bytecode parsing. | |
| graal.InlineMegamorphicCalls = true [Boolean] | |
| Inline calls with megamorphic type profile (i.e., not all types could | |
| be recorded). | |
| graal.InlineMonomorphicCalls = true [Boolean] | |
| Inline calls with monomorphic type profile. | |
| graal.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. | |
| graal.InlinePolymorphicCalls = true [Boolean] | |
| Inline calls with polymorphic type profile. | |
| graal.InlineVTableStubs = true [Boolean] | |
| graal.InlinedCompilerNodeLimit = 50000 [Integer] | |
| Controls the maximum number of compiler nodes that can be inlined into | |
| the compiled method. | |
| graal.InliningDepthError = 1000 [Integer] | |
| Maximum inlining depth during partial evaluation before reporting an | |
| infinite recursion | |
| graal.InterceptBailout = false [Boolean] | |
| Intercept also bailout exceptions | |
| graal.Intrinsify = true [Boolean] | |
| Use compiler intrinsifications. | |
| graal.LIRDynMoveProfileMethod = false [Boolean] | |
| Enable dynamic move profiling per method. | |
| graal.LIROptConstantLoadOptimization = true [Boolean] | |
| Enable constant load optimization. | |
| graal.LIROptControlFlowOptimizer = true [Boolean] | |
| graal.LIROptEdgeMoveOptimizer = true [Boolean] | |
| graal.LIROptLSRAEliminateSpillMoves = true [Boolean] | |
| Enable spill move elimination. | |
| graal.LIROptLSRAOptimizeSpillPosition = true [Boolean] | |
| Enable spill position optimization | |
| graal.LIROptLSStackSlotAllocator = true [Boolean] | |
| Use linear scan stack slot allocation. | |
| graal.LIROptNullCheckOptimizer = true [Boolean] | |
| graal.LIROptRedundantMoveElimination = true [Boolean] | |
| graal.LIROptStackMoveOptimizer = true [Boolean] | |
| graal.LIROptTraceRAEliminateSpillMoves = true [Boolean] | |
| Enable spill position optimization | |
| graal.LIROptimization = true [Boolean] | |
| Enable LIR level optimiztations. | |
| graal.LIRProfileMethods = false [Boolean] | |
| Enables profiling of methods. | |
| graal.LIRProfileMoves = false [Boolean] | |
| Enables profiling of move types on LIR level. Move types are for | |
| example stores (register to stack), constant loads (constant to | |
| register) or copies (register to register). | |
| graal.LIRUnlockBackendRestart = false [Boolean] | |
| Unlock backend restart feature. | |
| graal.LSRAOptSplitOnly = false [Boolean] | |
| LSRA optimization: Only split but do not reassign | |
| graal.LSRAOptimization = false [Boolean] | |
| Enable LSRA optimization | |
| graal.LimitInlinedInvokes = 5.0 [Double] | |
| graal.ListMetrics = false [Boolean] | |
| Lists on the console at VM shutdown the metric names available to the | |
| Timers, Counters and MemUseTrackers options. Note that this only lists | |
| the metrics that were initialized during the VM execution and so will | |
| not include metrics for compiler code that is not executed. | |
| graal.LoadExceptionObjectInVM = false [Boolean] | |
| Use a VM runtime call to load and clear the exception object from the | |
| thread at the start of a compiled exception handler. | |
| graal.Log = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.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(). | |
| graal.LogVerbose = false [Boolean] | |
| Enable more verbose log output when available | |
| graal.LoopInversion = false [Boolean] | |
| Convert loops into their zero trip form. | |
| graal.LoopMaxUnswitch = 3 [Integer] | |
| graal.LoopPeeling = true [Boolean] | |
| graal.LoopUnswitch = true [Boolean] | |
| graal.LoopUnswitchFrequencyBoost = 10.0 [Double] | |
| graal.LoopUnswitchMaxIncrease = 500 [Integer] | |
| graal.LoopUnswitchTrivial = 10 [Integer] | |
| graal.MatchExpressions = true [Boolean] | |
| Allow backend to match complex expressions. | |
| graal.MaxCFGRecomputations = 12 [Integer] | |
| graal.MaxCompilationProblemsPerAction = 2 [Integer] | |
| The maximum number of compilation failures or bailouts to handle with | |
| the action specified by CompilationFailureAction or | |
| CompilationBailoutAction before changing to a less verbose action. | |
| graal.MaxGraphSizeNodeCost = 100000 [Integer] | |
| Maximum node cost graph size for duplication. If a graph is bigger | |
| duplication will stop. | |
| graal.MaxPriorityInliningPeelingIterations = 10 [Integer] | |
| Max number of precise inlining peeling iterations. | |
| graal.MaxSimulationIterations = 2 [Integer] | |
| Maximum simulation-duplication iterations of the duplication | |
| optimization per invocation. | |
| graal.MaxSplitsPerNode = 32 [Integer] | |
| graal.MaxTemplatesPerSnippet = 50 [Integer] | |
| graal.MaxVectorAlignmentUnroll = 4 [Integer] | |
| Maximum number of unrolled alignment instructions | |
| graal.MaxVectorUnroll = 16 [Integer] | |
| Maximum length of linear-code vector operations | |
| graal.MaximumDesiredSize = 20000 [Integer] | |
| Maximum desired size of the compiler graph in nodes. | |
| graal.MaximumEscapeAnalysisArrayLength = 32 [Integer] | |
| graal.MaximumInliningSize = 300 [Integer] | |
| Inlining is explored up to this number of nodes in the graph for each | |
| call site. | |
| graal.MaximumLoopExplosionCount = 10000 [Integer] | |
| Max number of loop explosions per method. | |
| graal.MaximumRecursiveInlining = 5 [Integer] | |
| Maximum level of recursive inlining. | |
| graal.MegamorphicInliningMinMethodProbability = 0.33 [Double] | |
| Minimum probability for methods to be inlined for megamorphic type | |
| profiles. | |
| graal.MemUseTrackers = null [String] | |
| Comma separated names of memory usage trackers that are enabled | |
| irrespective of the value for TrackMemUse option. An empty value | |
| enables all memory usage trackers unconditionally. | |
| graal.MethodDupCounters = false [Boolean] | |
| graal.MethodDupOnly = "" [String] | |
| graal.MethodDupPropagateAnchors = false [Boolean] | |
| graal.MethodFilter = null [String] | |
| Pattern for filtering debug scope output based on method context. | |
| The syntax for a pattern is: | |
| SourcePatterns = SourcePattern ["," SourcePatterns] . | |
| SourcePattern = [ Class "." ] method [ "(" [ Parameter { ";" Parameter } ] ")" ] . | |
| Parameter = Class | "int" | "long" | "float" | "double" | "short" | "char" | "boolean" . | |
| Class = { package "." } class . | |
| Glob pattern matching (*, ?) is allowed in all parts of the source pattern. | |
| Examples of method filters: | |
| --------- | |
| visit(Argument;BlockScope) | |
| Matches all methods named "visit", with the first parameter of | |
| type "Argument", and the second parameter of type "BlockScope". | |
| The packages of the parameter types are irrelevant. | |
| --------- | |
| arraycopy(Object;;;;) | |
| Matches all methods named "arraycopy", with the first parameter | |
| of type "Object", and four more parameters of any type. The | |
| packages of the parameter types are irrelevant. | |
| --------- | |
| org.graalvm.compiler.core.graph.PostOrderNodeIterator.* | |
| Matches all methods in the class "org.graalvm.compiler.core.graph.PostOrderNodeIterator". | |
| --------- | |
| * | |
| Matches all methods in all classes | |
| --------- | |
| org.graalvm.compiler.core.graph.*.visit | |
| Matches all methods named "visit" in classes in the package | |
| "org.graalvm.compiler.core.graph". | |
| --------- | |
| arraycopy,toString | |
| Matches all methods named "arraycopy" or "toString", meaning that ',' acts as an or operator. | |
| graal.MethodFilterRootOnly = false [Boolean] | |
| Only check MethodFilter against the root method in the context if true, | |
| otherwise check all methods | |
| graal.MethodInlineBailoutLimit = 5000 [Integer] | |
| Per-compilation method inlining exploration limit before giving up (use | |
| 0 to disable) | |
| graal.MetricsFile = null [String] | |
| File to which metrics are dumped per compilation. | |
| A CSV format is used if the file ends with .csv otherwise a more | |
| human readable format is used. The fields in the CSV format are: | |
| compilable - method being compiled | |
| compilable_identity - identity hash code of compilable | |
| compilation_nr - where this compilation lies in the ordered | |
| sequence of all compilations identified by | |
| compilable_identity | |
| compilation_id - runtime issued identifier for the compilation | |
| metric_name - name of metric | |
| metric_value - value of metric | |
| graal.MetricsThreadFilter = null [String] | |
| Only report metrics for threads whose name matches the regular | |
| expression. | |
| graal.MinimalRegions = true [Boolean] | |
| Try to reduce duplication code size to the minimal amount of code. | |
| graal.MinimumPeelProbability = 0.35 [Float] | |
| graal.MitigateSpeculativeExecutionAttacks = false [Boolean] | |
| AMD64: Emit lfence instructions at the beginning of basic blocks | |
| graal.NDCV = 0 [Integer] | |
| Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, | |
| 3 = fatal) | |
| graal.NodeCounters = false [Boolean] | |
| Counts the number of instances of each node class. | |
| graal.NonFatalIdenticalCompilationSnapshots = 20 [Integer] | |
| Number of contiguous identical compiler thread stack traces allowed | |
| before the VM exits on the basis of a stuck compilation. | |
| graal.OmitHotExceptionStacktrace = false [Boolean] | |
| graal.OptAssumptions = true [Boolean] | |
| graal.OptBulkAllocation = true [Boolean] | |
| graal.OptClearNonLiveLocals = true [Boolean] | |
| graal.OptCompressedFrameStateValues = true [Boolean] | |
| graal.OptConditionalMoves = true [Boolean] | |
| Optimize simple if branches with conditional moves | |
| graal.OptConvertDeoptsToGuards = true [Boolean] | |
| graal.OptDeDuplication = true [Boolean] | |
| graal.OptDeoptimizationGrouping = true [Boolean] | |
| graal.OptDevirtualizeInvokesOptimistically = true [Boolean] | |
| graal.OptDuplication = true [Boolean] | |
| graal.OptEarlyReadElimination = true [Boolean] | |
| graal.OptEliminateGuards = true [Boolean] | |
| graal.OptEliminatePartiallyRedundantGuards = true [Boolean] | |
| graal.OptExactArithmetic = true [Boolean] | |
| graal.OptFilterProfiledTypes = true [Boolean] | |
| graal.OptFloatingReads = true [Boolean] | |
| graal.OptGuardRangeGrouping = true [Boolean] | |
| graal.OptImplicitNullChecks = true [Boolean] | |
| graal.OptLateDuplication = false [Boolean] | |
| graal.OptLockElimination = true [Boolean] | |
| graal.OptLoopTransform = true [Boolean] | |
| graal.OptMethodDuplication = false [Boolean] | |
| graal.OptPullThroughPhi = true [Boolean] | |
| graal.OptReadElimination = true [Boolean] | |
| graal.OptScheduleOutOfLoops = true [Boolean] | |
| graal.OptSpeculativeGuardMovement = true [Boolean] | |
| graal.OptStringConcat = true [Boolean] | |
| Optimize StringBuilder construction | |
| graal.OptStringConcatDump = false [Boolean] | |
| Dump graphs to help debug operation | |
| graal.OptWriteBarrierElimination = true [Boolean] | |
| graal.OptimisticAliasingAnalysis = true [Boolean] | |
| graal.OptimizeDiv = true [Boolean] | |
| graal.OptimizeLoopAccesses = true [Boolean] | |
| Enable access node optimizations for loops | |
| graal.PEAInliningHints = false [Boolean] | |
| graal.PartialEscapeAnalysis = true [Boolean] | |
| graal.PartialRedundancyElimination = true [Boolean] | |
| Enable partial redundancy elimination | |
| graal.PartialUnroll = true [Boolean] | |
| graal.PathDuplicationPhiCutoff = 20 [Integer] | |
| graal.PeelALot = false [Boolean] | |
| graal.PeelBackFoldFactor = 100 [Integer] | |
| graal.PeelForwardFoldFactor = 20 [Integer] | |
| graal.PeelPotentialFoldFactor = 60 [Integer] | |
| graal.PrintBackendCFG = true [Boolean] | |
| Enable dumping LIR, register allocation and code generation info to the | |
| C1Visualizer. | |
| graal.PrintBinaryGraphPort = 4445 [Integer] | |
| Port part of the address to which graphs are dumped in binary format | |
| (ignored if PrintBinaryGraphs=false). | |
| graal.PrintCFG = false [Boolean] | |
| Enable dumping to the C1Visualizer. Enabling this option implies | |
| PrintBackendCFG. | |
| graal.PrintCanonicalGraphStringFlavor = 0 [Integer] | |
| Choose format used when dumping canonical text for graphs: 0 gives a | |
| scheduled graph (better for spotting changes involving the schedule) | |
| while 1 gives a CFG containing expressions rooted at fixed nodes | |
| (better for spotting small structure differences) | |
| graal.PrintCanonicalGraphStrings = false [Boolean] | |
| Enable dumping canonical text from for graphs. | |
| graal.PrintCompilation = false [Boolean] | |
| Print an informational line to the console for each completed | |
| compilation. | |
| graal.PrintGraph = true [Boolean] | |
| Enable dumping to the IdealGraphVisualizer. | |
| graal.PrintGraphFile = false [Boolean] | |
| Print graphs to files instead of sending them over the network. | |
| graal.PrintGraphHost = "127.0.0.1" [String] | |
| Host part of the address to which graphs are dumped. | |
| graal.PrintGraphProbabilities = false [Boolean] | |
| Output probabilities for fixed nodes during binary graph dumping. | |
| graal.PrintGraphWithSchedule = false [Boolean] | |
| Schedule graphs as they are dumped. | |
| graal.PrintIRWithLIR = false [Boolean] | |
| Print HIR along side LIR as the latter is generated | |
| graal.PrintIdealGraph = true [Boolean] | |
| Deprecated - use PrintGraph instead. | |
| graal.PrintIdealGraphAddress = "127.0.0.1" [String] | |
| Deprecated - use PrintGraphHost instead. | |
| graal.PrintIdealGraphFile = false [Boolean] | |
| Deprecated - use PrintGraphFile instead. | |
| graal.PrintIdealGraphPort = 4444 [Integer] | |
| Deprecated - use PrintXmlGraphPort instead. | |
| graal.PrintIdealGraphSchedule = false [Boolean] | |
| Deprecated - use PrintGraphWithSchedule instead. | |
| graal.PrintLIRWithAssembly = false [Boolean] | |
| Include the LIR as comments with the final assembly. | |
| graal.PrintProfilingInformation = false [Boolean] | |
| Print profiling information when parsing a method's bytecode | |
| graal.PrintTruffleExpansionHistogram = false [Boolean] | |
| Prints a histogram of all expanded Java methods. | |
| graal.PrintTruffleTrees = true [Boolean] | |
| Enable dumping Truffle ASTs to the IdealGraphVisualizer. | |
| graal.PrintXmlGraphPort = 4444 [Integer] | |
| Port part of the address to which graphs are dumped in XML format | |
| (ignored if PrintBinaryGraphs=true). | |
| graal.PriorityInliningPolicy = "" [String] | |
| The policy to use, must be empty for automatic resolution. | |
| graal.ProbabilisticProfiling = true [Boolean] | |
| Control probabilistic profiling on AMD64 | |
| graal.ProfileAllocations = false [Boolean] | |
| Enable profiling of allocation sites. | |
| graal.ProfileAllocationsContext = AllocatingMethod [String] | |
| Control the naming and granularity of the counters when using | |
| ProfileAllocations. | |
| The accepted values are: | |
| AllocatingMethod - a counter per method | |
| InstanceOrArray - one counter for all instance allocations and | |
| one counter for all array allocations | |
| AllocatedType - one counter per allocated type | |
| AllocatedTypesInMethod - one counter per allocated type, per method | |
| graal.ProfileBackedges = true [Boolean] | |
| Emit profiling of backedges | |
| graal.ProfileCompiledMethods = false [Boolean] | |
| graal.ProfileInvokes = true [Boolean] | |
| Emit profiling of invokes | |
| graal.ProfileLockElimination = false [Boolean] | |
| graal.ProfileMonitors = false [Boolean] | |
| Enable profiling of monitor operations. | |
| graal.ProfileSimpleMethods = true [Boolean] | |
| Profile simple methods | |
| graal.ProfileTypeSwitches = false [Boolean] | |
| Turn on typeswitch profiling. This tracks the stability of typeswitches | |
| after compilation. | |
| graal.PruneLargeDominatorUsageTrees = true [Boolean] | |
| graal.PullThroughPhiBudget = 4096.0 [Double] | |
| graal.RawConditionalElimination = true [Boolean] | |
| graal.ReadEliminationMaxLoopVisits = 5 [Integer] | |
| graal.ReassociateInvariants = true [Boolean] | |
| graal.ReduceDCE = true [Boolean] | |
| Disable optional dead code eliminations | |
| graal.RegisterPressure = null [String] | |
| Comma separated list of registers that register allocation is limited | |
| to. | |
| graal.RelativeBenefitInliningCoefficient = 0.005 [Double] | |
| The coefficient used to compute the inlining threshold; the higher, the | |
| hard to inline. | |
| graal.RemoveNeverExecutedCode = true [Boolean] | |
| graal.ReplaceInputsWithConstantsBasedOnStamps = true [Boolean] | |
| graal.ResolveClassBeforeStaticInvoke = false [Boolean] | |
| graal.ScheduledDuplicationSimulation = false [Boolean] | |
| Simulation can either only process fixed nodes or schedule the graph | |
| and also process floating nodes. | |
| graal.ShowConfiguration = none [String] | |
| Writes to the VM log information about the Graal compiler configuration | |
| selected. | |
| graal.ShowDumpFiles = false [Boolean] | |
| Print the name of each dump file path as it's created. | |
| graal.SimpleFastInflatedLocking = true [Boolean] | |
| Handle simple cases for inflated monitors in the fast-path. | |
| graal.SimpleMethodCalls = 1 [Integer] | |
| Maximum number of calls in a simple method | |
| graal.SimpleMethodGraphSize = 256 [Integer] | |
| Maximum number of nodes in a graph for a simple method | |
| graal.SimpleMethodIndirectCalls = 0 [Integer] | |
| Maximum number of indirect calls in a simple moethod | |
| graal.SimulationStopAtControlFlow = true [Boolean] | |
| Determines if simulation traversal should stop at control flow | |
| boundaries that cannot be duplicated. | |
| graal.SmallCompiledLowLevelGraphSize = 300 [Integer] | |
| If the previous low-level graph size of the method exceeds the | |
| threshold, it is not inlined. | |
| graal.SnippetCounters = false [Boolean] | |
| Enable counters for various paths in snippets. | |
| graal.SpeculativeRewriteCompare = true [Boolean] | |
| graal.SpeculativeStoreCheck = true [Boolean] | |
| Speculates that arrays have exact type to optimize store checks | |
| graal.StressExplicitExceptionCode = false [Boolean] | |
| Stress the code emitting explicit exception throwing code. | |
| graal.StressInvokeWithExceptionNode = false [Boolean] | |
| Stress the code emitting invokes with explicit exception edges. | |
| graal.StressTestEarlyReads = false [Boolean] | |
| Stress the code by emitting reads at earliest instead of latest point. | |
| graal.SupportJsrBytecodes = true [Boolean] | |
| graal.SupportOSRWithLocks = true [Boolean] | |
| Support OSR compilations with locks. If DeoptAfterOSR is true we can | |
| per definition not have unbalaced enter/extis mappings. If | |
| DeoptAfterOSR is false insert artificial monitor enters after the | |
| OSRStart to have balanced enter/exits in the graph. | |
| graal.TailDupOnly = "" [String] | |
| graal.TailDuplicationProbability = 0.5 [Double] | |
| graal.TailDuplicationTrivialSize = 1 [Integer] | |
| graal.TierABackedgeNotifyFreqLog = 16 [Integer] | |
| Backedge notification frequency | |
| graal.TierABackedgeProfileProbabilityLog = 12 [Integer] | |
| Backedge profile probability | |
| graal.TierAInvokeInlineeNotifyFreqLog = -1 [Integer] | |
| Inlinee invocation notification frequency (-1 means count, but do not | |
| notify) | |
| graal.TierAInvokeNotifyFreqLog = 13 [Integer] | |
| Invocation notification frequency | |
| graal.TierAInvokeProfileProbabilityLog = 8 [Integer] | |
| Invocation profile probability | |
| graal.TieredAOT = false [Boolean] | |
| Do profiling and callbacks to tiered runtime | |
| graal.Time = null [String] | |
| Pattern for specifying scopes in which timing is enabled. See the Dump | |
| option for the pattern syntax. An empty value enables all timers | |
| unconditionally. | |
| graal.TimedDynamicCounters = -1 [Integer] | |
| Turn on the benchmark counters, and displays the results every n | |
| milliseconds | |
| graal.Timers = null [String] | |
| Comma separated names of timers that are enabled irrespective of the | |
| value for Time option. An empty value enables all timers | |
| unconditionally. | |
| graal.TraceBuilding = UniDirectional [String] | |
| Trace building algorithm. | |
| graal.TraceBytecodeParserLevel = 0 [Integer] | |
| The trace level for the bytecode parser. A value of 1 enables | |
| instruction tracing and any greater value emits a frame state trace | |
| just prior to each instruction trace.Instruction tracing output from | |
| multiple compiler threads will be interleaved so use of this option | |
| make most sense for single threaded compilation.The MethodFilter option | |
| can be used to refine tracing to selected methods. | |
| graal.TraceEscapeAnalysis = false [Boolean] | |
| graal.TraceExceptionHandlerStub = false [Boolean] | |
| Trace execution of stub used to handle an exception thrown by a callee. | |
| graal.TraceInlineDuringParsing = false [Boolean] | |
| Traces inlining performed during bytecode parsing. | |
| graal.TraceInlining = false [Boolean] | |
| Enable tracing of inlining decisions. | |
| Output format: | |
| compilation of 'Signature of the compilation root method': | |
| at 'Signature of the root method' ['Bytecode index']: <'Phase'> 'Child method signature': 'Decision made about this callsite' | |
| at 'Signature of the child method' ['Bytecode index']: | |
| ├──<'Phase 1'> 'Grandchild method signature': 'First decision made about this callsite' | |
| └──<'Phase 2'> 'Grandchild method signature': 'Second decision made about this callsite' | |
| at 'Signature of the child method' ['Bytecode index']: <'Phase'> 'Another grandchild method signature': 'The only decision made about this callsite.' | |
| graal.TraceInliningForStubsAndSnippets = false [Boolean] | |
| Enable inlining decision tracing in stubs and snippets. | |
| graal.TraceLIRGeneratorLevel = 0 [Integer] | |
| The trace level for the LIR generator | |
| graal.TraceMonitorsMethodFilter = null [String] | |
| Trace monitor operations in methods whose fully qualified name contains | |
| this substring. | |
| graal.TraceMonitorsTypeFilter = null [String] | |
| Trace monitor operations on objects whose type contains this substring. | |
| graal.TraceNewArrayStub = false [Boolean] | |
| Trace execution of slow path stub for array allocation. | |
| graal.TraceNewInstanceStub = false [Boolean] | |
| Trace execution of slow path stub for non-array object allocation. | |
| graal.TraceParserPlugins = false [Boolean] | |
| Traces use of plugins during bytecode parsing. | |
| graal.TraceRA = false [Boolean] | |
| Enable experimental Trace Register Allocation. | |
| graal.TraceRACacheStackSlots = true [Boolean] | |
| Cache stack slots globally (i.e. a variable always gets the same slot | |
| in every trace). | |
| graal.TraceRAPolicy = Default [String] | |
| TraceRA allocation policy to use. | |
| graal.TraceRAScheduleTrivialTracesEarly = true [Boolean] | |
| Schedule trivial traces as early as possible. | |
| graal.TraceRAalmostTrivialSize = 2 [Integer] | |
| Use BottomUp if there is only one block with at most this number of | |
| instructions | |
| graal.TraceRAbottomUpRatio = 0.0 [Double] | |
| Use LSRA / BottomUp ratio | |
| graal.TraceRAnumVariables = null [Integer] | |
| Use BottomUp for traces with low number of variables at block | |
| boundaries | |
| graal.TraceRAprobalilityThreshold = 0.8 [Double] | |
| Probability Threshold | |
| graal.TraceRAreuseStackSlotsForMoveResolutionCycleBreaking = true [Boolean] | |
| Reuse spill slots for global move resolution cycle breaking. | |
| graal.TraceRAshareSpillInformation = true [Boolean] | |
| Share information about spilled values to other traces. | |
| graal.TraceRAsumBudget = 0.5 [Double] | |
| Sum Probability Budget Threshold | |
| graal.TraceRAtrivialBlockAllocator = true [Boolean] | |
| Use special allocator for trivial blocks. | |
| graal.TraceRAuseInterTraceHints = true [Boolean] | |
| Use inter-trace register hints. | |
| graal.TraceTruffleAssumptions = false [Boolean] | |
| Print stack trace on assumption invalidation | |
| graal.TraceTruffleCompilation = false [Boolean] | |
| Print information for compilation results | |
| graal.TraceTruffleCompilationAST = false [Boolean] | |
| Print all polymorphic and generic nodes after each compilation | |
| graal.TraceTruffleCompilationCallTree = false [Boolean] | |
| Print the inlined call tree for each compiled method | |
| graal.TraceTruffleCompilationDetails = false [Boolean] | |
| Print information for compilation queuing | |
| graal.TraceTruffleCompilationPolymorphism = false [Boolean] | |
| Print all polymorphic and generic nodes after each compilation | |
| graal.TraceTruffleExpansionSource = false [Boolean] | |
| Print source secions for printed expansion trees | |
| graal.TraceTruffleInlining = false [Boolean] | |
| Print information for inlining for each compilation. | |
| graal.TraceTruffleLoopPeeling = false [Boolean] | |
| Traces loop peeling decisions. | |
| graal.TraceTrufflePerformanceWarnings = false [Boolean] | |
| Print potential performance problems | |
| graal.TraceTruffleSplitting = false [Boolean] | |
| Print information for each splitted call site. | |
| graal.TraceTruffleStackTraceLimit = 20 [Integer] | |
| Number of stack trace elements printed by | |
| TraceTruffleTransferToInterpreter and TraceTruffleAssumptions | |
| graal.TraceTruffleTransferToInterpreter = false [Boolean] | |
| Print stack trace on transfer to interpreter | |
| graal.TraceUnwindStub = false [Boolean] | |
| Trace execution of the stub that routes an exception to a handler in | |
| the calling frame. | |
| graal.TrackGraphSizesInDuplication = false [Boolean] | |
| Enable (if Count is enabled) graph size tracking during every | |
| duplication iteration. | |
| graal.TrackMemUse = null [String] | |
| Pattern for specifying scopes in which memory use tracking is enabled. | |
| See the Dump option for the pattern syntax. An empty value enables all | |
| memory use trackers unconditionally. | |
| graal.TrackNodeInsertion = false [Boolean] | |
| Track source stack trace where a node was inserted into the graph. | |
| graal.TrackNodeSourcePosition = false [Boolean] | |
| Track the NodeSourcePosition. | |
| graal.TrivialInliningSize = 10 [Integer] | |
| Graphs with less than this number of nodes are trivial and therefore | |
| always inlined. | |
| graal.TruffleArgumentTypeSpeculation = true [Boolean] | |
| graal.TruffleBackgroundCompilation = true [Boolean] | |
| Enable asynchronous truffle compilation in background thread | |
| graal.TruffleCompilationExceptionsAreFatal = false [Boolean] | |
| Treat compilation exceptions as fatal exceptions that will exit the | |
| application | |
| graal.TruffleCompilationExceptionsArePrinted = true [Boolean] | |
| Prints the exception stack trace for compilation exceptions | |
| graal.TruffleCompilationExceptionsAreThrown = false [Boolean] | |
| Treat compilation exceptions as thrown runtime exceptions | |
| graal.TruffleCompilationStatisticDetails = false [Boolean] | |
| Print additional more verbose Truffle compilation statistics at the end | |
| of a run. | |
| graal.TruffleCompilationStatistics = false [Boolean] | |
| Print Truffle compilation statistics at the end of a run. | |
| graal.TruffleCompilationThreshold = 1000 [Integer] | |
| Compile call target when call count exceeds this threshold | |
| graal.TruffleCompileImmediately = false [Boolean] | |
| Compile immediately to test truffle compiler | |
| graal.TruffleCompileOnly = null [String] | |
| Restrict compilation to comma-separated list of includes (or excludes | |
| prefixed with tilde) | |
| graal.TruffleCompilerConfiguration = null [String] | |
| Select a Graal compiler configuration for Truffle compilation (default: | |
| use Graal system compiler configuration). | |
| graal.TruffleCompilerThreads = 0 [Integer] | |
| Manually set the number of compiler threads | |
| graal.TruffleEnableInfopoints = false [Boolean] | |
| Enable support for simple infopoints in truffle partial evaluations. | |
| graal.TruffleExcludeAssertions = true [Boolean] | |
| Exclude assertion code from Truffle compilations | |
| graal.TruffleExperimentalSplitting = false [Boolean] | |
| Use the splitting strategy that relies on language implementations | |
| reporting polymorpic specializations. Disables forced splits. | |
| graal.TruffleExperimentalSplittingAllowForcedSplits = false [Boolean] | |
| Should forced splits be allowed (when using experimental splitting) | |
| graal.TruffleExperimentalSplittingDumpDecisions = false [Boolean] | |
| Dumps to IGV information on polymorphic events | |
| graal.TruffleExperimentalSplittingMaxPropagationDepth = 5 [Integer] | |
| Propagate info about a polymorphic specialize through maximum this many | |
| call targets | |
| graal.TruffleFunctionInlining = true [Boolean] | |
| Enable automatic inlining of call targets | |
| graal.TruffleInlineAcrossTruffleBoundary = false [Boolean] | |
| Enable inlining across Truffle boundary | |
| graal.TruffleInliningMaxCallerSize = 2250 [Integer] | |
| Stop inlining if caller's cumulative tree size would exceed this limit | |
| graal.TruffleInstrumentBoundaries = false [Boolean] | |
| Instrument Truffle boundaries and output profiling information to the | |
| standard output. | |
| graal.TruffleInstrumentBoundariesPerInlineSite = false [Boolean] | |
| Instrument Truffle boundaries by considering different inlining sites | |
| as different branches. | |
| graal.TruffleInstrumentBranches = false [Boolean] | |
| Instrument branches and output profiling information to the standard | |
| output. | |
| graal.TruffleInstrumentBranchesCount = 10000 [Integer] | |
| Maximum number of instrumentation counters available. | |
| graal.TruffleInstrumentBranchesFilter = null [String] | |
| Method filter for methods in which to add branch instrumentation. | |
| graal.TruffleInstrumentBranchesPerInlineSite = false [Boolean] | |
| Instrument branches by considering different inlining sites as | |
| different branches. | |
| graal.TruffleInstrumentBranchesPretty = true [Boolean] | |
| Prettify stack traces for branch-instrumented callsites. | |
| graal.TruffleInstrumentFilter = "*.*.*" [String] | |
| Method filter for host methods in which to add instrumentation. | |
| graal.TruffleInstrumentationTableSize = 10000 [Integer] | |
| Maximum number of instrumentation counters available. | |
| graal.TruffleIntrinsifyFrameAccess = true [Boolean] | |
| Intrinsify get/set/is methods of FrameWithoutBoxing to improve Truffle | |
| compilation time | |
| graal.TruffleInvalidationReprofileCount = 3 [Integer] | |
| Delay compilation after an invalidation to allow for reprofiling | |
| graal.TruffleIterativePartialEscape = false [Boolean] | |
| Run the partial escape analysis iteratively in Truffle compilation. | |
| graal.TruffleLoopPeeling = true [Boolean] | |
| Enables loop peeling. | |
| graal.TruffleLoopPeelingMaximumSize = 250 [Integer] | |
| Maximum loop body node count for loop peeling or a value <= 0 for no | |
| limit. | |
| graal.TruffleLoopPeelingProfiling = 2 [Integer] | |
| Number of loop invocations until loop peeling is decided. | |
| graal.TruffleMaximumRecursiveInlining = 4 [Integer] | |
| Maximum level of recursive inlining | |
| graal.TruffleMinInvokeThreshold = 3 [Integer] | |
| Minimum number of calls before a call target is compiled | |
| graal.TruffleOSR = true [Boolean] | |
| Enable on stack replacement for Truffle loops. | |
| graal.TruffleOSRCompilationThreshold = 100000 [Integer] | |
| Number of loop iterations until on-stack-replacement compilation is | |
| triggered. | |
| graal.TrufflePerformanceWarningsAreFatal = false [Boolean] | |
| Treat performance warnings as fatal occurrences that will exit the | |
| applications | |
| graal.TruffleProfilingEnabled = true [Boolean] | |
| Enable/disable builtin profiles in com.oracle.truffle.api.profiles. | |
| graal.TruffleReplaceReprofileCount = 3 [Integer] | |
| Delay compilation after a node replacement | |
| graal.TruffleReturnTypeSpeculation = true [Boolean] | |
| graal.TruffleSplitting = true [Boolean] | |
| Enable call target splitting | |
| graal.TruffleSplittingGrowthLimit = 1.5 [Double] | |
| Disable call target splitting if the number of nodes created by | |
| splitting exceeds this factor times node count | |
| graal.TruffleSplittingMaxCalleeSize = 100 [Integer] | |
| Disable call target splitting if tree size exceeds this limit | |
| graal.TruffleSplittingMaxNumberOfSplitNodes = 500000 [Integer] | |
| Disable call target splitting if number of nodes created by splitting | |
| exceeds this limit | |
| graal.TruffleTimeThreshold = 50000 [Integer] | |
| Defines the maximum timespan in milliseconds that is required for a | |
| call target to be queued for compilation. | |
| graal.TruffleTraceSplittingSummary = false [Boolean] | |
| Used for debugging the splitting implementation. Prints splitting | |
| summary directly to stdout on shutdown | |
| graal.TruffleUseFrameWithoutBoxing = true [Boolean] | |
| graal.TrustFinalDefaultFields = true [Boolean] | |
| Determines whether to treat final fields with default values as | |
| constant. | |
| graal.TryExplodeOverPhis = true [Boolean] | |
| graal.TryPhiPhiPulls = true [Boolean] | |
| graal.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. | |
| graal.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 | |
| graal.TypicalGraphSize = 3250 [Integer] | |
| The typical graph size at which inlining pressure must start growing. | |
| graal.TypicalGraphSizeInvokeBonus = 70 [Integer] | |
| The increase in estimated typical graph size after inlining, per each | |
| extra invoke. | |
| graal.TypicalGraphSizeMax = 10000 [Integer] | |
| The maximum in estimated inlined typical graph size. | |
| graal.UnrollMaxIterations = 16 [Integer] | |
| graal.UseCompilationStatistics = false [Boolean] | |
| Enables CompilationStatistics. | |
| graal.UseExceptionProbability = true [Boolean] | |
| graal.UseGraphCache = true [Boolean] | |
| Turn on graph caching. | |
| graal.UseGuardedIntrinsics = true [Boolean] | |
| Use intrinsics guarded by a virtual dispatch test at indirect call | |
| sites. | |
| graal.UseLoopLimitChecks = true [Boolean] | |
| graal.UsePolymorphicInlining = true [Boolean] | |
| Inline polymorphic calls based on callsite receiver profiles. | |
| graal.UsePriorityInlining = true [Boolean] | |
| Use priority-based inlining. | |
| graal.UseSnippetGraphCache = true [Boolean] | |
| Use a cache for snippet graphs. | |
| graal.UseSnippetTemplateCache = true [Boolean] | |
| Use a LRU cache for snippet templates. | |
| graal.UseTrappingNullChecks = true [Boolean] | |
| Use traps for null checks instead of explicit null-checks | |
| graal.UseTypeCheckHints = true [Boolean] | |
| graal.VectorIntrinsics = true [Boolean] | |
| Enable vectorized array copy intrinsics | |
| graal.VectorUnroll = 1 [Integer] | |
| Unroll vectorized loops | |
| graal.Vectorization = true [Boolean] | |
| Enable vectorization | |
| graal.VectorizeAllocation = true [Boolean] | |
| Enable vectorized array initialization | |
| graal.VectorizeConditional = false [Boolean] | |
| Enable vectorization of conditional code. | |
| graal.VectorizeFoldShaped = true [Boolean] | |
| Enable vectorization of loops implementing a higher-order 'fold' | |
| function. | |
| graal.VectorizeLoops = true [Boolean] | |
| Enable vectorization of loops | |
| graal.VectorizeMapShaped = true [Boolean] | |
| Enable vectorization of loops implementing a higher-order 'map' | |
| function. | |
| graal.VectorizeNegativeStride = true [Boolean] | |
| Enable vectorization of loops with negative strides. | |
| graal.VectorizeSIMD = false [Boolean] | |
| Enable detection of SIMD patterns | |
| graal.VectorizeSequence = true [Boolean] | |
| Enable vectorization of sequence values. | |
| graal.Verify = null [String] | |
| Pattern for specifying scopes in which logging is enabled. See the Dump | |
| option for the pattern syntax. | |
| graal.VerifyBalancedMonitors = false [Boolean] | |
| Emit extra code to dynamically check monitor operations are balanced. | |
| graal.VerifyDuplicationOperations = false [Boolean] | |
| graal.VerifyGraalGraphEdges = false [Boolean] | |
| Perform expensive verification of graph inputs, usages, successors and | |
| predecessors | |
| graal.VerifyGraalGraphs = true [Boolean] | |
| Verify graphs often during compilation when assertions are turned on | |
| graal.VerifyGraalPhasesSize = false [Boolean] | |
| Verify before - after relation of the relative, computed, code size of | |
| a graph | |
| graal.VerifyHeapAtReturn = false [Boolean] | |
| Perform platform dependent validation of the Java heap at returns | |
| graal.VerifyKillCFGUnusedNodes = false [Boolean] | |
| Verify that there are no new unused nodes when performing killCFG | |
| graal.VerifyPhases = false [Boolean] | |
| graal.VerifyWriteBarrierElimination = false [Boolean] | |
| Add code to verify that eliminated barriers weren't needed. Not | |
| implemented for G1. | |
| graal.ZapStackOnMethodEntry = false [Boolean] |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment