< prev index next >
src/hotspot/share/gc/epsilon/epsilon_globals.hpp
Print this page
*** 27,97 ****
#define SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP
#include "runtime/globals_shared.hpp"
//
! // Defines all globals flags used by the Epsilon GC.
//
! #define GC_EPSILON_FLAGS(develop, \
! develop_pd, \
! product, \
! product_pd, \
! diagnostic, \
! diagnostic_pd, \
! experimental, \
! notproduct, \
! manageable, \
! product_rw, \
! lp64_product, \
! range, \
! constraint) \
! \
! experimental(size_t, EpsilonPrintHeapSteps, 20, \
! "Print heap occupancy stats with this number of steps. " \
! "0 turns the printing off.") \
! range(0, max_intx) \
! \
! experimental(size_t, EpsilonUpdateCountersStep, 1 * M, \
! "Update heap occupancy counters after allocating this much " \
! "memory. Higher values would make allocations faster at " \
! "the expense of lower resolution in heap counters.") \
! range(1, max_intx) \
! \
! experimental(size_t, EpsilonMaxTLABSize, 4 * M, \
! "Max TLAB size to use with Epsilon GC. Larger value improves " \
! "performance at the expense of per-thread memory waste. This " \
! "asks TLAB machinery to cap TLAB sizes at this value.") \
! range(1, max_intx) \
! \
! experimental(bool, EpsilonElasticTLAB, true, \
! "Use elastic policy to manage TLAB sizes. This conserves memory " \
! "for non-actively allocating threads, even when they request " \
! "large TLABs for themselves. Active threads would experience " \
! "smaller TLABs until policy catches up.") \
! \
! experimental(bool, EpsilonElasticTLABDecay, true, \
! "Use timed decays to shrik TLAB sizes. This conserves memory " \
! "for the threads that allocate in bursts of different sizes, " \
! "for example the small/rare allocations coming after the initial "\
! "large burst.") \
! \
! experimental(double, EpsilonTLABElasticity, 1.1, \
! "Multiplier to use when deciding on next TLAB size. Larger value "\
! "improves performance at the expense of per-thread memory waste. "\
! "Lower value improves memory footprint, but penalizes actively " \
! "allocating threads.") \
! range(1.0, DBL_MAX) \
! \
! experimental(size_t, EpsilonTLABDecayTime, 1000, \
! "TLAB sizing policy decays to initial size after thread had not " \
! "allocated for this long. Time is in milliseconds. Lower value " \
! "improves memory footprint, but penalizes actively allocating " \
! "threads.") \
! range(1, max_intx) \
! \
! experimental(size_t, EpsilonMinHeapExpand, 128 * M, \
! "Min expansion step for heap. Larger value improves performance " \
! "at the potential expense of memory waste.") \
! range(1, max_intx)
#endif // SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP
--- 27,87 ----
#define SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP
#include "runtime/globals_shared.hpp"
//
! // Declare all globals flags used by the Epsilon GC.
//
! #include "utilities/macros.hpp"
! #if INCLUDE_EPSILONGC
! #include "runtime/flags/jvmFlag.hpp"
! PRODUCT_FLAG(size_t, EpsilonPrintHeapSteps, 20, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "Print heap occupancy stats with this number of steps. "
! "0 turns the printing off.");
! FLAG_RANGE( EpsilonPrintHeapSteps, 0, max_intx);
!
! PRODUCT_FLAG(size_t, EpsilonUpdateCountersStep, 1 * M, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "Update heap occupancy counters after allocating this much "
! "memory. Higher values would make allocations faster at "
! "the expense of lower resolution in heap counters.");
! FLAG_RANGE( EpsilonUpdateCountersStep, 1, max_intx);
!
! PRODUCT_FLAG(size_t, EpsilonMaxTLABSize, 4 * M, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "Max TLAB size to use with Epsilon GC. Larger value improves "
! "performance at the expense of per-thread memory waste. This "
! "asks TLAB machinery to cap TLAB sizes at this value.");
! FLAG_RANGE( EpsilonMaxTLABSize, 1, max_intx);
!
! PRODUCT_FLAG(bool, EpsilonElasticTLAB, true, JVMFlag::EXPERIMENTAL,
! "Use elastic policy to manage TLAB sizes. This conserves memory "
! "for non-actively allocating threads, even when they request "
! "large TLABs for themselves. Active threads would experience "
! "smaller TLABs until policy catches up.");
!
! PRODUCT_FLAG(bool, EpsilonElasticTLABDecay, true, JVMFlag::EXPERIMENTAL,
! "Use timed decays to shrik TLAB sizes. This conserves memory "
! "for the threads that allocate in bursts of different sizes, "
! "for example the small/rare allocations coming after the initial "
! "large burst.");
!
! PRODUCT_FLAG(double, EpsilonTLABElasticity, 1.1, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "Multiplier to use when deciding on next TLAB size. Larger value "
! "improves performance at the expense of per-thread memory waste. "
! "Lower value improves memory footprint, but penalizes actively "
! "allocating threads.");
! FLAG_RANGE( EpsilonTLABElasticity, 1.0, DBL_MAX);
!
! PRODUCT_FLAG(size_t, EpsilonTLABDecayTime, 1000, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "TLAB sizing policy decays to initial size after thread had not "
! "allocated for this long. Time is in milliseconds. Lower value "
! "improves memory footprint, but penalizes actively allocating "
! "threads.");
! FLAG_RANGE( EpsilonTLABDecayTime, 1, max_intx);
!
! PRODUCT_FLAG(size_t, EpsilonMinHeapExpand, 128 * M, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
! "Min expansion step for heap. Larger value improves performance "
! "at the potential expense of memory waste.");
! FLAG_RANGE( EpsilonMinHeapExpand, 1, max_intx);
! #endif // INCLUDE_EPSILONGC
#endif // SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP
< prev index next >