< prev index next >

src/hotspot/share/compiler/compiler_globals.hpp

Print this page

253           range(0, 4)                                                       \
254                                                                             \
255   product(intx, Tier0ProfilingStartPercentage, 200,                         \
256           "Start profiling in interpreter if the counters exceed the "      \
257           "specified percentage of tier 3 thresholds")                      \
258           range(0, max_jint)                                                \
259                                                                             \
260   product(uintx, IncreaseFirstTierCompileThresholdAt, 50,                   \
261           "Increase the compile threshold for C1 compilation if the code "  \
262           "cache is filled by the specified percentage")                    \
263           range(0, 99)                                                      \
264                                                                             \
265   product(intx, TieredRateUpdateMinTime, 1,                                 \
266           "Minimum rate sampling interval (in milliseconds)")               \
267           range(0, max_intx)                                                \
268                                                                             \
269   product(intx, TieredRateUpdateMaxTime, 25,                                \
270           "Maximum rate sampling interval (in milliseconds)")               \
271           range(0, max_intx)                                                \
272                                                                             \











273   product(ccstr, CompilationMode, "default",                                \
274           "Compilation modes: "                                             \
275           "default: normal tiered compilation; "                            \
276           "quick-only: C1-only mode; "                                      \
277           "high-only: C2/JVMCI-only mode; "                                 \
278           "high-only-quick-internal: C2/JVMCI-only mode, "                  \
279           "with JVMCI compiler compiled with C1.")                          \
280                                                                             \
281   product(bool, PrintTieredEvents, false,                                   \
282           "Print tiered events notifications")                              \
283                                                                             \
284   product_pd(intx, OnStackReplacePercentage,                                \
285           "NON_TIERED number of method invocations/branches (expressed as " \
286           "% of CompileThreshold) before (re-)compiling OSR code")          \
287           constraint(OnStackReplacePercentageConstraintFunc, AfterErgo)     \
288                                                                             \
289   product(intx, InterpreterProfilePercentage, 33,                           \
290           "NON_TIERED number of method invocations/branches (expressed as " \
291           "% of CompileThreshold) before profiling in the interpreter")     \
292           range(0, 100)                                                     \

366   product(bool, AbortVMOnCompilationFailure, false, DIAGNOSTIC,             \
367           "Abort VM when method had failed to compile.")                    \
368                                                                             \
369   develop(intx, OSROnlyBCI, -1,                                             \
370           "OSR only at this bci.  Negative values mean exclude that bci")   \
371                                                                             \
372   develop(intx, DesiredMethodLimit,  8000,                                  \
373           "The desired maximum method size (in bytecodes) after inlining")  \
374                                                                             \
375   product(bool, DontCompileHugeMethods, true,                               \
376           "Do not compile methods > HugeMethodLimit")                       \
377                                                                             \
378   develop(intx, HugeMethodLimit,  8000,                                     \
379           "Don't compile methods larger than this if "                      \
380           "+DontCompileHugeMethods")                                        \
381                                                                             \
382   product(bool, CaptureBailoutInformation, trueInDebug, DIAGNOSTIC,         \
383           "If compilation is stopped with an error, capture diagnostic "    \
384           "information at the bailout point")                               \
385                                                                             \
































































































386 
387 // end of COMPILER_FLAGS
388 
389 DECLARE_FLAGS(COMPILER_FLAGS)
390 
391 #endif // SHARE_COMPILER_COMPILER_GLOBALS_HPP

253           range(0, 4)                                                       \
254                                                                             \
255   product(intx, Tier0ProfilingStartPercentage, 200,                         \
256           "Start profiling in interpreter if the counters exceed the "      \
257           "specified percentage of tier 3 thresholds")                      \
258           range(0, max_jint)                                                \
259                                                                             \
260   product(uintx, IncreaseFirstTierCompileThresholdAt, 50,                   \
261           "Increase the compile threshold for C1 compilation if the code "  \
262           "cache is filled by the specified percentage")                    \
263           range(0, 99)                                                      \
264                                                                             \
265   product(intx, TieredRateUpdateMinTime, 1,                                 \
266           "Minimum rate sampling interval (in milliseconds)")               \
267           range(0, max_intx)                                                \
268                                                                             \
269   product(intx, TieredRateUpdateMaxTime, 25,                                \
270           "Maximum rate sampling interval (in milliseconds)")               \
271           range(0, max_intx)                                                \
272                                                                             \
273   product(double, Tier0ProfileDelayFactor, 100.0, DIAGNOSTIC,               \
274           "Delay profiling/compiling of methods that were "                 \
275           "observed to be lukewarm")                                        \
276                                                                             \
277   product(double, Tier2ProfileDelayFactor, 250.0, DIAGNOSTIC,               \
278           "Delay profiling of methods that were observed to be lukewarm")   \
279                                                                             \
280   product(bool, SkipTier2IfPossible, false, DIAGNOSTIC,                     \
281           "Compile at tier 4 instead of tier 2 in training replay "         \
282           "mode if posssible")                                              \
283                                                                             \
284   product(ccstr, CompilationMode, "default",                                \
285           "Compilation modes: "                                             \
286           "default: normal tiered compilation; "                            \
287           "quick-only: C1-only mode; "                                      \
288           "high-only: C2/JVMCI-only mode; "                                 \
289           "high-only-quick-internal: C2/JVMCI-only mode, "                  \
290           "with JVMCI compiler compiled with C1.")                          \
291                                                                             \
292   product(bool, PrintTieredEvents, false,                                   \
293           "Print tiered events notifications")                              \
294                                                                             \
295   product_pd(intx, OnStackReplacePercentage,                                \
296           "NON_TIERED number of method invocations/branches (expressed as " \
297           "% of CompileThreshold) before (re-)compiling OSR code")          \
298           constraint(OnStackReplacePercentageConstraintFunc, AfterErgo)     \
299                                                                             \
300   product(intx, InterpreterProfilePercentage, 33,                           \
301           "NON_TIERED number of method invocations/branches (expressed as " \
302           "% of CompileThreshold) before profiling in the interpreter")     \
303           range(0, 100)                                                     \

377   product(bool, AbortVMOnCompilationFailure, false, DIAGNOSTIC,             \
378           "Abort VM when method had failed to compile.")                    \
379                                                                             \
380   develop(intx, OSROnlyBCI, -1,                                             \
381           "OSR only at this bci.  Negative values mean exclude that bci")   \
382                                                                             \
383   develop(intx, DesiredMethodLimit,  8000,                                  \
384           "The desired maximum method size (in bytecodes) after inlining")  \
385                                                                             \
386   product(bool, DontCompileHugeMethods, true,                               \
387           "Do not compile methods > HugeMethodLimit")                       \
388                                                                             \
389   develop(intx, HugeMethodLimit,  8000,                                     \
390           "Don't compile methods larger than this if "                      \
391           "+DontCompileHugeMethods")                                        \
392                                                                             \
393   product(bool, CaptureBailoutInformation, trueInDebug, DIAGNOSTIC,         \
394           "If compilation is stopped with an error, capture diagnostic "    \
395           "information at the bailout point")                               \
396                                                                             \
397   /* flags to control training and deployment modes  */                     \
398                                                                             \
399   product(bool, RecordTraining, false,                                      \
400           "Request output of training data for improved deployment.")       \
401                                                                             \
402   product(bool, ReplayTraining, false,                                      \
403           "Read training data, if available, for use in this execution")    \
404                                                                             \
405   product(bool, PrintTrainingInfo, false, DIAGNOSTIC,                       \
406           "Print additional information about training")                    \
407                                                                             \
408   product(ccstr, TrainingFile, nullptr,                                     \
409           "If training record or replay is enabled, store or load VM data " \
410           "to or from this file [default: ./hs_training_%p.log] "           \
411           "(_%p replaced with _pidNNN on output, empty string on input)")   \
412                                                                             \
413   product(bool, RecordOptCompilationOrder, false,                           \
414           "Record c2/jvmci nmethod temperature to guide compilation order.")\
415                                                                             \
416   product(bool, RecordOnlyTopCompilations, false,                           \
417           "Record only top compilations (non-zero counts)")                 \
418                                                                             \
419   product(int, RecordOptCompilationOrderInterval, 10,                       \
420           "Sampling interval for RecordOptCompilationOrder")                \
421                                                                             \
422   /* Code Caching flags */                                                  \
423                                                                             \
424   product(bool, UseC2asC3, false,                                           \
425           "Use C2 as 3rd compiler when other high-optimizing compiler "     \
426           "is used")                                                        \
427                                                                             \
428   product(bool, StoreCachedCode, false,                                     \
429           "Store cached compiled code")                                     \
430                                                                             \
431   product(bool, LoadCachedCode, false,                                      \
432           "Load cached compiled code")                                      \
433                                                                             \
434   product(uint, DisableCachedCode, 0,                                       \
435           "Disable cached code on some compilation levels "                 \
436           "(T1=1; T2=2; T4=4; T5/preload=8")                                \
437                                                                             \
438   product(uint, ClassInitBarrierMode, 0,                                    \
439           "Produce and use startup code which could be called "             \
440           "on first method invocation, add class initialization barriers, " \
441           "other checks and constrains if needed "                          \
442           "(0: no barriers; 1: uncommon trap; 2: full barrier)")            \
443                                                                             \
444   product(bool, StressClassInitBarriers, false, DIAGNOSTIC,                 \
445           "Force slow path in class initialization barriers")               \
446                                                                             \
447   product(bool, UseMetadataPointers, true,                                  \
448           "Store Metadata pointers in Relocation Info for cached code")     \
449                                                                             \
450   product(bool, UseCodeLoadThread, true,                                    \
451           "Use separate thread for cached code load")                       \
452                                                                             \
453   product(uint, SCLoadStart, 0,                                             \
454           "The id of the first cached code to load")                        \
455                                                                             \
456   product(uint, SCLoadStop, max_jint,                                       \
457           "The id of the last cached code to load")                         \
458                                                                             \
459   product(ccstr, CachedCodeFile, "code.jsa",                                \
460           "File with cached compiled code")                                 \
461                                                                             \
462   product(uint, CachedCodeMaxSize, 10*M,                                    \
463           "Buffer size in bytes for code caching")                          \
464                                                                             \
465   product(bool, VerifyCachedCode, false, DIAGNOSTIC,                        \
466           "Load compiled code but not publish")                             \
467                                                                             \
468   /* Recompilation flags */                                                 \
469                                                                             \
470   product(int, RecompilationLoadAverageThreshold, 5,                        \
471           "Queues load avergage after while recompilations are allowed")    \
472                                                                             \
473   product(int, RecompilationWorkUnitSize, 5,                                \
474           "Queues load avergage after while recompilations are allowed")    \
475                                                                             \
476   product(bool, UseRecompilation, false,                                    \
477           "Recompile methods for peak performance")                         \
478                                                                             \
479   product(bool, ForceRecompilation, false,                                  \
480           "Testing mode for recompilation")                                 \
481                                                                             \
482   product(double, DelayRecompilation, 0.0,                                  \
483           "Delay recompilation for given number of seconds")                \
484                                                                             \
485   product(bool, UseConcurrentTrainingReplay, true,                          \
486           "Replay training after class initialization in a separate thread")\
487                                                                             \
488   product(bool, UseGlobalCompileQueueLock, false,                           \
489           "Use a global lock for all compilation queues")                   \
490                                                                             \
491   product(bool, UseLockFreeCompileQueues, true,                             \
492           "Use lock free compile queues")                                   \
493 
494 // end of COMPILER_FLAGS
495 
496 DECLARE_FLAGS(COMPILER_FLAGS)
497 
498 #endif // SHARE_COMPILER_COMPILER_GLOBALS_HPP
< prev index next >