< prev index next >

src/hotspot/share/runtime/globals.hpp

Print this page

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



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

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

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













2096   develop(bool, TraceOptimizedUpcallStubs, false,                              \
2097                 "Trace optimized upcall stub generation")                      \
2098 
2099 // end of RUNTIME_FLAGS
2100 
2101 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
2102 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
2103 DECLARE_FLAGS(RUNTIME_FLAGS)
2104 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2105 
2106 #endif // SHARE_RUNTIME_GLOBALS_HPP

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

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