< prev index next >

src/hotspot/share/compiler/compiler_globals.hpp

Print this page

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











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

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






































































































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

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

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