< prev index next >

src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp

Print this page
rev 54386 : 8221766: Load-reference barriers for Shenandoah


 227           "on each cycle.")                                                 \
 228           range(1.0,100.0)                                                  \
 229                                                                             \
 230   experimental(bool, ShenandoahEvacReserveOverflow, true,                   \
 231           "Allow evacuations to overflow the reserved space. "              \
 232           "Enabling it will make evacuations more resilient when "          \
 233           "evacuation reserve/waste is incorrect, at the risk that "        \
 234           "application allocations run out of memory too early.")           \
 235                                                                             \
 236   diagnostic(bool, ShenandoahAllocationTrace, false,                        \
 237           "Trace allocation latencies and stalls. Can be expensive when "   \
 238           "lots of allocations happen, and may introduce scalability "      \
 239           "bottlenecks.")                                                   \
 240                                                                             \
 241   diagnostic(intx, ShenandoahAllocationStallThreshold, 10000,               \
 242           "When allocation tracing is enabled, the allocation stalls "      \
 243           "larger than this threshold would be reported as warnings. "      \
 244           "Time is in microseconds.")                                       \
 245                                                                             \
 246   experimental(uintx, ShenandoahEvacAssist, 10,                             \
 247           "How many objects to evacuate on WB assist path. "                \
 248           "Use zero to disable.")                                           \
 249                                                                             \
 250   experimental(bool, ShenandoahPacing, true,                                \
 251           "Pace application allocations to give GC chance to start "        \
 252           "and complete before allocation failure is reached.")             \
 253                                                                             \
 254   experimental(uintx, ShenandoahPacingMaxDelay, 10,                         \
 255           "Max delay for pacing application allocations. "                  \
 256           "Time is in milliseconds.")                                       \
 257                                                                             \
 258   experimental(uintx, ShenandoahPacingIdleSlack, 2,                         \
 259           "Percent of heap counted as non-taxable allocations during idle. "\
 260           "Larger value makes the pacing milder during idle phases, "       \
 261           "requiring less rendezvous with control thread. Lower value "     \
 262           "makes the pacing control less responsive to out-of-cycle allocs.")\
 263           range(0, 100)                                                     \
 264                                                                             \
 265   experimental(uintx, ShenandoahPacingCycleSlack, 10,                       \
 266           "Percent of free space taken as non-taxable allocations during "  \
 267           "the GC cycle. Larger value makes the pacing milder at the "      \


 335           "Forcefully flush non-empty SATB buffers at this interval. "      \
 336           "Time is in milliseconds.")                                       \
 337                                                                             \
 338   experimental(uint, ShenandoahParallelSafepointThreads, 4,                 \
 339           "Number of parallel threads used for safepoint prolog/epilog")    \
 340                                                                             \
 341   experimental(bool, ShenandoahPreclean, true,                              \
 342           "Do concurrent preclean phase before final mark: process "        \
 343           "definitely alive references to avoid dealing with them during "  \
 344           "pause.")                                                         \
 345                                                                             \
 346   experimental(bool, ShenandoahSuspendibleWorkers, false,                   \
 347           "Suspend concurrent GC worker threads at safepoints")             \
 348                                                                             \
 349   diagnostic(bool, ShenandoahSATBBarrier, true,                             \
 350           "Turn on/off SATB barriers in Shenandoah")                        \
 351                                                                             \
 352   diagnostic(bool, ShenandoahKeepAliveBarrier, true,                        \
 353           "Turn on/off keep alive barriers in Shenandoah")                  \
 354                                                                             \
 355   diagnostic(bool, ShenandoahWriteBarrier, true,                            \
 356           "Turn on/off write barriers in Shenandoah")                       \
 357                                                                             \
 358   diagnostic(bool, ShenandoahReadBarrier, true,                             \
 359           "Turn on/off read barriers in Shenandoah")                        \
 360                                                                             \
 361   diagnostic(bool, ShenandoahStoreValEnqueueBarrier, false,                 \
 362           "Turn on/off enqueuing of oops for storeval barriers")            \
 363                                                                             \
 364   diagnostic(bool, ShenandoahStoreValReadBarrier, true,                     \
 365           "Turn on/off store val read barriers in Shenandoah")              \
 366                                                                             \
 367   diagnostic(bool, ShenandoahCASBarrier, true,                              \
 368           "Turn on/off CAS barriers in Shenandoah")                         \
 369                                                                             \
 370   diagnostic(bool, ShenandoahAcmpBarrier, true,                             \
 371           "Turn on/off acmp barriers in Shenandoah")                        \
 372                                                                             \
 373   diagnostic(bool, ShenandoahCloneBarrier, true,                            \
 374           "Turn on/off clone barriers in Shenandoah")                       \
 375                                                                             \



 376   diagnostic(bool, ShenandoahStoreCheck, false,                             \
 377           "Emit additional code that checks objects are written to only"    \
 378           " in to-space")                                                   \
 379                                                                             \
 380   experimental(bool, ShenandoahConcurrentScanCodeRoots, true,               \
 381           "Scan code roots concurrently, instead of during a pause")        \
 382                                                                             \
 383   experimental(uintx, ShenandoahCodeRootsStyle, 2,                          \
 384           "Use this style to scan code cache:"                              \
 385           " 0 - sequential iterator;"                                       \
 386           " 1 - parallel iterator;"                                         \
 387           " 2 - parallel iterator with cset filters;")                      \
 388                                                                             \
 389   experimental(bool, ShenandoahOptimizeStaticFinals, true,                  \
 390           "Optimize barriers on static final fields. "                      \
 391           "Turn it off for maximum compatibility with reflection or JNI "   \
 392           "code that manipulates final fields.")                            \
 393                                                                             \
 394   experimental(bool, ShenandoahOptimizeInstanceFinals, false,               \
 395           "Optimize barriers on final instance fields."                     \
 396           "Turn it off for maximum compatibility with reflection or JNI "   \
 397           "code that manipulates final fields.")                            \
 398                                                                             \
 399   experimental(bool, ShenandoahOptimizeStableFinals, false,                 \
 400           "Optimize barriers on stable fields."                             \
 401           "Turn it off for maximum compatibility with reflection or JNI "   \
 402           "code that manipulates final fields.")                            \
 403                                                                             \
 404   diagnostic(bool, ShenandoahDecreaseRegisterPressure, false,               \
 405           "Try to reuse after-barrier values to reduce register pressure")  \
 406                                                                             \
 407   experimental(bool, ShenandoahCommonGCStateLoads, false,                   \
 408          "Enable commonming for GC state loads in generated code.")         \
 409                                                                             \
 410   develop(bool, ShenandoahVerifyOptoBarriers, false,                        \
 411           "Verify no missing barriers in C2")                               \
 412                                                                             \
 413   experimental(bool, ShenandoahDontIncreaseWBFreq, true,                    \
 414           "Common 2 WriteBarriers or WriteBarrier and a ReadBarrier only "  \
 415           "if the resulting WriteBarrier isn't executed more frequently")   \
 416                                                                             \
 417   experimental(bool, ShenandoahLoopOptsAfterExpansion, true,                \
 418           "Attempt more loop opts after write barrier expansion")           \
 419 
 420 #endif // SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP


 227           "on each cycle.")                                                 \
 228           range(1.0,100.0)                                                  \
 229                                                                             \
 230   experimental(bool, ShenandoahEvacReserveOverflow, true,                   \
 231           "Allow evacuations to overflow the reserved space. "              \
 232           "Enabling it will make evacuations more resilient when "          \
 233           "evacuation reserve/waste is incorrect, at the risk that "        \
 234           "application allocations run out of memory too early.")           \
 235                                                                             \
 236   diagnostic(bool, ShenandoahAllocationTrace, false,                        \
 237           "Trace allocation latencies and stalls. Can be expensive when "   \
 238           "lots of allocations happen, and may introduce scalability "      \
 239           "bottlenecks.")                                                   \
 240                                                                             \
 241   diagnostic(intx, ShenandoahAllocationStallThreshold, 10000,               \
 242           "When allocation tracing is enabled, the allocation stalls "      \
 243           "larger than this threshold would be reported as warnings. "      \
 244           "Time is in microseconds.")                                       \
 245                                                                             \
 246   experimental(uintx, ShenandoahEvacAssist, 10,                             \
 247           "How many objects to evacuate on LRB assist path. "               \
 248           "Use zero to disable.")                                           \
 249                                                                             \
 250   experimental(bool, ShenandoahPacing, true,                                \
 251           "Pace application allocations to give GC chance to start "        \
 252           "and complete before allocation failure is reached.")             \
 253                                                                             \
 254   experimental(uintx, ShenandoahPacingMaxDelay, 10,                         \
 255           "Max delay for pacing application allocations. "                  \
 256           "Time is in milliseconds.")                                       \
 257                                                                             \
 258   experimental(uintx, ShenandoahPacingIdleSlack, 2,                         \
 259           "Percent of heap counted as non-taxable allocations during idle. "\
 260           "Larger value makes the pacing milder during idle phases, "       \
 261           "requiring less rendezvous with control thread. Lower value "     \
 262           "makes the pacing control less responsive to out-of-cycle allocs.")\
 263           range(0, 100)                                                     \
 264                                                                             \
 265   experimental(uintx, ShenandoahPacingCycleSlack, 10,                       \
 266           "Percent of free space taken as non-taxable allocations during "  \
 267           "the GC cycle. Larger value makes the pacing milder at the "      \


 335           "Forcefully flush non-empty SATB buffers at this interval. "      \
 336           "Time is in milliseconds.")                                       \
 337                                                                             \
 338   experimental(uint, ShenandoahParallelSafepointThreads, 4,                 \
 339           "Number of parallel threads used for safepoint prolog/epilog")    \
 340                                                                             \
 341   experimental(bool, ShenandoahPreclean, true,                              \
 342           "Do concurrent preclean phase before final mark: process "        \
 343           "definitely alive references to avoid dealing with them during "  \
 344           "pause.")                                                         \
 345                                                                             \
 346   experimental(bool, ShenandoahSuspendibleWorkers, false,                   \
 347           "Suspend concurrent GC worker threads at safepoints")             \
 348                                                                             \
 349   diagnostic(bool, ShenandoahSATBBarrier, true,                             \
 350           "Turn on/off SATB barriers in Shenandoah")                        \
 351                                                                             \
 352   diagnostic(bool, ShenandoahKeepAliveBarrier, true,                        \
 353           "Turn on/off keep alive barriers in Shenandoah")                  \
 354                                                                             \






 355   diagnostic(bool, ShenandoahStoreValEnqueueBarrier, false,                 \
 356           "Turn on/off enqueuing of oops for storeval barriers")            \
 357                                                                             \



 358   diagnostic(bool, ShenandoahCASBarrier, true,                              \
 359           "Turn on/off CAS barriers in Shenandoah")                         \
 360                                                                             \



 361   diagnostic(bool, ShenandoahCloneBarrier, true,                            \
 362           "Turn on/off clone barriers in Shenandoah")                       \
 363                                                                             \
 364   diagnostic(bool, ShenandoahLoadRefBarrier, true,                          \
 365           "Turn on/off load-reference barriers in Shenandoah")              \
 366                                                                             \
 367   diagnostic(bool, ShenandoahStoreCheck, false,                             \
 368           "Emit additional code that checks objects are written to only"    \
 369           " in to-space")                                                   \
 370                                                                             \
 371   experimental(bool, ShenandoahConcurrentScanCodeRoots, true,               \
 372           "Scan code roots concurrently, instead of during a pause")        \
 373                                                                             \
 374   experimental(uintx, ShenandoahCodeRootsStyle, 2,                          \
 375           "Use this style to scan code cache:"                              \
 376           " 0 - sequential iterator;"                                       \
 377           " 1 - parallel iterator;"                                         \
 378           " 2 - parallel iterator with cset filters;")                      \
 379                                                                             \
 380   experimental(bool, ShenandoahOptimizeStaticFinals, true,                  \
 381           "Optimize barriers on static final fields. "                      \
 382           "Turn it off for maximum compatibility with reflection or JNI "   \
 383           "code that manipulates final fields.")                            \
 384                                                                             \
 385   experimental(bool, ShenandoahOptimizeInstanceFinals, false,               \
 386           "Optimize barriers on final instance fields."                     \
 387           "Turn it off for maximum compatibility with reflection or JNI "   \
 388           "code that manipulates final fields.")                            \
 389                                                                             \
 390   experimental(bool, ShenandoahOptimizeStableFinals, false,                 \
 391           "Optimize barriers on stable fields."                             \
 392           "Turn it off for maximum compatibility with reflection or JNI "   \
 393           "code that manipulates final fields.")                            \
 394                                                                             \



 395   experimental(bool, ShenandoahCommonGCStateLoads, false,                   \
 396          "Enable commonming for GC state loads in generated code.")         \
 397                                                                             \
 398   develop(bool, ShenandoahVerifyOptoBarriers, false,                        \
 399           "Verify no missing barriers in C2")                               \
 400                                                                             \




 401   experimental(bool, ShenandoahLoopOptsAfterExpansion, true,                \
 402           "Attempt more loop opts after barrier expansion")                 \
 403 
 404 #endif // SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
< prev index next >