< prev index next >
src/hotspot/share/gc/epsilon/epsilon_globals.hpp
Print this page
@@ -27,71 +27,61 @@
#define SHARE_GC_EPSILON_EPSILON_GLOBALS_HPP
#include "runtime/globals_shared.hpp"
//
-// Defines all globals flags used by the Epsilon GC.
+// Declare 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)
+#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 >