< prev index next >

src/hotspot/share/runtime/globals.hpp

Print this page

 113 const size_t defaultSymbolTableSize = 32768; // 2^15
 114 const size_t minimumSymbolTableSize = 1024;
 115 
 116 #ifdef _LP64
 117 #define LP64_RUNTIME_FLAGS(develop,                                         \
 118                            develop_pd,                                      \
 119                            product,                                         \
 120                            product_pd,                                      \
 121                            notproduct,                                      \
 122                            range,                                           \
 123                            constraint)                                      \
 124                                                                             \
 125   product(bool, UseCompressedOops, false,                                   \
 126           "Use 32-bit object references in 64-bit VM. "                     \
 127           "lp64_product means flag is always constant in 32 bit VM")        \
 128                                                                             \
 129   product(bool, UseCompressedClassPointers, false,                          \
 130           "Use 32-bit class pointers in 64-bit VM. "                        \
 131           "lp64_product means flag is always constant in 32 bit VM")        \
 132                                                                             \



 133   product(intx, ObjectAlignmentInBytes, 8,                                  \
 134           "Default object alignment in bytes, 8 is minimum")                \
 135           range(8, 256)                                                     \
 136           constraint(ObjectAlignmentInBytesConstraintFunc, AtParse)
 137 
 138 #else
 139 // !_LP64
 140 
 141 #define LP64_RUNTIME_FLAGS(develop,                                         \
 142                            develop_pd,                                      \
 143                            product,                                         \
 144                            product_pd,                                      \
 145                            notproduct,                                      \
 146                            range,                                           \
 147                            constraint)
 148 const bool UseCompressedOops = false;
 149 const bool UseCompressedClassPointers = false;

 150 const intx ObjectAlignmentInBytes = 8;
 151 
 152 #endif // _LP64
 153 
 154 #define RUNTIME_FLAGS(develop,                                              \
 155                       develop_pd,                                           \
 156                       product,                                              \
 157                       product_pd,                                           \
 158                       notproduct,                                           \
 159                       range,                                                \
 160                       constraint)                                           \
 161                                                                             \
 162   notproduct(bool, CheckCompressedOops, true,                               \
 163           "Generate checks in encoding/decoding code in debug VM")          \
 164                                                                             \
 165   product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17),                        \
 166           "Heap allocation steps through preferred address regions to find" \
 167           " where it can allocate the heap. Number of steps to take per "   \
 168           "region.")                                                        \
 169           range(1, max_uintx)                                               \

2077   JFR_ONLY(product(ccstr, FlightRecorderOptions, NULL,                      \
2078           "Flight Recorder options"))                                       \
2079                                                                             \
2080   JFR_ONLY(product(ccstr, StartFlightRecording, NULL,                       \
2081           "Start flight recording with options"))                           \
2082                                                                             \
2083   product(bool, UseFastUnorderedTimeStamps, false, EXPERIMENTAL,            \
2084           "Use platform unstable time where supported for timestamps only") \
2085                                                                             \
2086   product(bool, UseEmptySlotsInSupers, true,                                \
2087                 "Allow allocating fields in empty slots of super-classes")  \
2088                                                                             \
2089   product(bool, DeoptimizeNMethodBarriersALot, false, DIAGNOSTIC,           \
2090                 "Make nmethod barriers deoptimise a lot.")                  \
2091                                                                             \
2092   develop(bool, VerifyCrossModifyFence,                                     \
2093           false AARCH64_ONLY(DEBUG_ONLY(||true)),                           \
2094              "Mark all threads after a safepoint, and clear on a modify "   \
2095              "fence. Add cleanliness checks.")                              \
2096                                                                             \













2097   develop(bool, TraceOptimizedUpcallStubs, false,                              \
2098                 "Trace optimized upcall stub generation")                      \
2099                                                                             \
2100   product(uint, TrimNativeHeapInterval, 0, EXPERIMENTAL,                    \
2101           "Interval, in ms, at which the JVM will trim the native heap if " \
2102           "the platform supports that. Lower values will reclaim memory "   \
2103           "more eagerly at the cost of higher overhead. A value of 0 "      \
2104           "(default) disables native heap trimming.")                       \
2105           range(0, UINT_MAX)                                                \
2106 
2107 // end of RUNTIME_FLAGS
2108 
2109 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
2110 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
2111 DECLARE_FLAGS(RUNTIME_FLAGS)
2112 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2113 
2114 #endif // SHARE_RUNTIME_GLOBALS_HPP

 113 const size_t defaultSymbolTableSize = 32768; // 2^15
 114 const size_t minimumSymbolTableSize = 1024;
 115 
 116 #ifdef _LP64
 117 #define LP64_RUNTIME_FLAGS(develop,                                         \
 118                            develop_pd,                                      \
 119                            product,                                         \
 120                            product_pd,                                      \
 121                            notproduct,                                      \
 122                            range,                                           \
 123                            constraint)                                      \
 124                                                                             \
 125   product(bool, UseCompressedOops, false,                                   \
 126           "Use 32-bit object references in 64-bit VM. "                     \
 127           "lp64_product means flag is always constant in 32 bit VM")        \
 128                                                                             \
 129   product(bool, UseCompressedClassPointers, false,                          \
 130           "Use 32-bit class pointers in 64-bit VM. "                        \
 131           "lp64_product means flag is always constant in 32 bit VM")        \
 132                                                                             \
 133   product(bool, UseCompactObjectHeaders, false, EXPERIMENTAL,               \
 134           "Use 64-bit object headers instead of 96-bit headers")            \
 135                                                                             \
 136   product(intx, ObjectAlignmentInBytes, 8,                                  \
 137           "Default object alignment in bytes, 8 is minimum")                \
 138           range(8, 256)                                                     \
 139           constraint(ObjectAlignmentInBytesConstraintFunc, AtParse)
 140 
 141 #else
 142 // !_LP64
 143 
 144 #define LP64_RUNTIME_FLAGS(develop,                                         \
 145                            develop_pd,                                      \
 146                            product,                                         \
 147                            product_pd,                                      \
 148                            notproduct,                                      \
 149                            range,                                           \
 150                            constraint)
 151 const bool UseCompressedOops = false;
 152 const bool UseCompressedClassPointers = false;
 153 const bool UseCompactObjectHeaders = false;
 154 const intx ObjectAlignmentInBytes = 8;
 155 
 156 #endif // _LP64
 157 
 158 #define RUNTIME_FLAGS(develop,                                              \
 159                       develop_pd,                                           \
 160                       product,                                              \
 161                       product_pd,                                           \
 162                       notproduct,                                           \
 163                       range,                                                \
 164                       constraint)                                           \
 165                                                                             \
 166   notproduct(bool, CheckCompressedOops, true,                               \
 167           "Generate checks in encoding/decoding code in debug VM")          \
 168                                                                             \
 169   product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17),                        \
 170           "Heap allocation steps through preferred address regions to find" \
 171           " where it can allocate the heap. Number of steps to take per "   \
 172           "region.")                                                        \
 173           range(1, max_uintx)                                               \

2081   JFR_ONLY(product(ccstr, FlightRecorderOptions, NULL,                      \
2082           "Flight Recorder options"))                                       \
2083                                                                             \
2084   JFR_ONLY(product(ccstr, StartFlightRecording, NULL,                       \
2085           "Start flight recording with options"))                           \
2086                                                                             \
2087   product(bool, UseFastUnorderedTimeStamps, false, EXPERIMENTAL,            \
2088           "Use platform unstable time where supported for timestamps only") \
2089                                                                             \
2090   product(bool, UseEmptySlotsInSupers, true,                                \
2091                 "Allow allocating fields in empty slots of super-classes")  \
2092                                                                             \
2093   product(bool, DeoptimizeNMethodBarriersALot, false, DIAGNOSTIC,           \
2094                 "Make nmethod barriers deoptimise a lot.")                  \
2095                                                                             \
2096   develop(bool, VerifyCrossModifyFence,                                     \
2097           false AARCH64_ONLY(DEBUG_ONLY(||true)),                           \
2098              "Mark all threads after a safepoint, and clear on a modify "   \
2099              "fence. Add cleanliness checks.")                              \
2100                                                                             \
2101   product(bool, HeapObjectStats, false, DIAGNOSTIC,                         \
2102              "Enable gathering of heap object statistics")                  \
2103                                                                             \
2104   product(size_t, HeapObjectStatsSamplingInterval, 500, DIAGNOSTIC,         \
2105              "Heap object statistics sampling interval (ms)")               \
2106                                                                             \
2107   product(int, LockingMode, LM_LEGACY, EXPERIMENTAL,                        \
2108           "Select locking mode: "                                           \
2109           "0: monitors only (LM_MONITOR), "                                 \
2110           "1: monitors & legacy stack-locking (LM_LEGACY, default), "       \
2111           "2: monitors & new lightweight locking (LM_LIGHTWEIGHT)")         \
2112           range(0, 2)                                                       \
2113                                                                             \
2114   develop(bool, TraceOptimizedUpcallStubs, false,                              \
2115                 "Trace optimized upcall stub generation")                      \
2116                                                                             \
2117   product(uint, TrimNativeHeapInterval, 0, EXPERIMENTAL,                    \
2118           "Interval, in ms, at which the JVM will trim the native heap if " \
2119           "the platform supports that. Lower values will reclaim memory "   \
2120           "more eagerly at the cost of higher overhead. A value of 0 "      \
2121           "(default) disables native heap trimming.")                       \
2122           range(0, UINT_MAX)                                                \
2123 
2124 // end of RUNTIME_FLAGS
2125 
2126 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
2127 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
2128 DECLARE_FLAGS(RUNTIME_FLAGS)
2129 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2130 
2131 #endif // SHARE_RUNTIME_GLOBALS_HPP
< prev index next >