< prev index next >

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

Print this page




   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This code is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * version 2 for more details (a copy is included in the LICENSE file that
  12  * accompanied this code).
  13  *
  14  * You should have received a copy of the GNU General Public License version
  15  * 2 along with this work; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  19  * or visit www.oracle.com if you need additional information or have any
  20  * questions.
  21  *
  22  */
  23 
  24 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
  25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
  26 
  27 #define GC_SHENANDOAH_FLAGS(develop,                                        \
  28                             develop_pd,                                     \
  29                             product,                                        \
  30                             product_pd,                                     \
  31                             diagnostic,                                     \
  32                             diagnostic_pd,                                  \
  33                             experimental,                                   \
  34                             notproduct,                                     \
  35                             manageable,                                     \
  36                             product_rw,                                     \
  37                             lp64_product,                                   \
  38                             range,                                          \
  39                             constraint,                                     \
  40                             writeable)                                      \
  41                                                                             \
  42   experimental(size_t, ShenandoahHeapRegionSize, 0,                         \
  43           "Size of the Shenandoah regions. Set to zero to detect "          \
  44           "automatically.")                                                 \
  45                                                                             \


 168           "Sampling rate for heap region sampling. "                        \
 169           "Number of milliseconds between samples")                         \
 170                                                                             \
 171   experimental(uintx, ShenandoahControlIntervalMin, 1,                      \
 172           "The minumum sleep interval for control loop that drives "        \
 173           "the cycles. Lower values would increase GC responsiveness "      \
 174           "to changing heap conditions, at the expense of higher perf "     \
 175           "overhead. Time is in milliseconds.")                             \
 176                                                                             \
 177   experimental(uintx, ShenandoahControlIntervalMax, 10,                     \
 178           "The maximum sleep interval for control loop that drives "        \
 179           "the cycles. Lower values would increase GC responsiveness "      \
 180           "to changing heap conditions, at the expense of higher perf "     \
 181           "overhead. Time is in milliseconds.")                             \
 182                                                                             \
 183   experimental(uintx, ShenandoahControlIntervalAdjustPeriod, 1000,          \
 184           "The time period for one step in control loop interval "          \
 185           "adjustment. Lower values make adjustments faster, at the "       \
 186           "expense of higher perf overhead. Time is in milliseconds.")      \
 187                                                                             \



 188   diagnostic(bool, ShenandoahVerify, false,                                 \
 189           "Verify the Shenandoah garbage collector")                        \
 190                                                                             \
 191   diagnostic(intx, ShenandoahVerifyLevel, 4,                                \
 192           "Shenandoah verification level: "                                 \
 193           "0 = basic heap checks; "                                         \
 194           "1 = previous level, plus basic region checks; "                  \
 195           "2 = previous level, plus all roots; "                            \
 196           "3 = previous level, plus all reachable objects; "                \
 197           "4 = previous level, plus all marked objects")                    \
 198                                                                             \
 199   diagnostic(bool, ShenandoahElasticTLAB, true,                             \
 200           "Use Elastic TLABs with Shenandoah")                              \
 201                                                                             \
 202   diagnostic(bool, ShenandoahAllowMixedAllocs, true,                        \
 203           "Allow mixing mutator and collector allocations in a single "     \
 204           "region")                                                         \
 205                                                                             \
 206   experimental(uintx, ShenandoahAllocSpikeFactor, 5,                        \
 207           "The amount of heap space to reserve for absorbing the "          \


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



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


   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This code is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * version 2 for more details (a copy is included in the LICENSE file that
  12  * accompanied this code).
  13  *
  14  * You should have received a copy of the GNU General Public License version
  15  * 2 along with this work; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  19  * or visit www.oracle.com if you need additional information or have any
  20  * questions.
  21  *
  22  */
  23 
  24 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
  25 #define SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
  26 
  27 #define GC_SHENANDOAH_FLAGS(develop,                                        \
  28                             develop_pd,                                     \
  29                             product,                                        \
  30                             product_pd,                                     \
  31                             diagnostic,                                     \
  32                             diagnostic_pd,                                  \
  33                             experimental,                                   \
  34                             notproduct,                                     \
  35                             manageable,                                     \
  36                             product_rw,                                     \
  37                             lp64_product,                                   \
  38                             range,                                          \
  39                             constraint,                                     \
  40                             writeable)                                      \
  41                                                                             \
  42   experimental(size_t, ShenandoahHeapRegionSize, 0,                         \
  43           "Size of the Shenandoah regions. Set to zero to detect "          \
  44           "automatically.")                                                 \
  45                                                                             \


 168           "Sampling rate for heap region sampling. "                        \
 169           "Number of milliseconds between samples")                         \
 170                                                                             \
 171   experimental(uintx, ShenandoahControlIntervalMin, 1,                      \
 172           "The minumum sleep interval for control loop that drives "        \
 173           "the cycles. Lower values would increase GC responsiveness "      \
 174           "to changing heap conditions, at the expense of higher perf "     \
 175           "overhead. Time is in milliseconds.")                             \
 176                                                                             \
 177   experimental(uintx, ShenandoahControlIntervalMax, 10,                     \
 178           "The maximum sleep interval for control loop that drives "        \
 179           "the cycles. Lower values would increase GC responsiveness "      \
 180           "to changing heap conditions, at the expense of higher perf "     \
 181           "overhead. Time is in milliseconds.")                             \
 182                                                                             \
 183   experimental(uintx, ShenandoahControlIntervalAdjustPeriod, 1000,          \
 184           "The time period for one step in control loop interval "          \
 185           "adjustment. Lower values make adjustments faster, at the "       \
 186           "expense of higher perf overhead. Time is in milliseconds.")      \
 187                                                                             \
 188   experimental(bool, ShenandoahCriticalControlThreadPriority, false,        \
 189           "Shenandoah control thread runs at critical scheduling priority.")\
 190                                                                             \
 191   diagnostic(bool, ShenandoahVerify, false,                                 \
 192           "Verify the Shenandoah garbage collector")                        \
 193                                                                             \
 194   diagnostic(intx, ShenandoahVerifyLevel, 4,                                \
 195           "Shenandoah verification level: "                                 \
 196           "0 = basic heap checks; "                                         \
 197           "1 = previous level, plus basic region checks; "                  \
 198           "2 = previous level, plus all roots; "                            \
 199           "3 = previous level, plus all reachable objects; "                \
 200           "4 = previous level, plus all marked objects")                    \
 201                                                                             \
 202   diagnostic(bool, ShenandoahElasticTLAB, true,                             \
 203           "Use Elastic TLABs with Shenandoah")                              \
 204                                                                             \
 205   diagnostic(bool, ShenandoahAllowMixedAllocs, true,                        \
 206           "Allow mixing mutator and collector allocations in a single "     \
 207           "region")                                                         \
 208                                                                             \
 209   experimental(uintx, ShenandoahAllocSpikeFactor, 5,                        \
 210           "The amount of heap space to reserve for absorbing 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 write barrier expansion")           \
 403 
 404 #endif // SHARE_GC_SHENANDOAH_SHENANDOAH_GLOBALS_HPP
< prev index next >