< prev index next >

src/hotspot/share/runtime/globals.hpp

Print this page

 108 // Default and minimum StringTable and SymbolTable size values
 109 // Must be powers of 2
 110 const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536);
 111 const size_t minimumStringTableSize = 128;
 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)                                               \

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









2088   develop(bool, TraceOptimizedUpcallStubs, false,                              \
2089                 "Trace optimized upcall stub generation")                      \
2090 
2091 // end of RUNTIME_FLAGS
2092 
2093 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
2094 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
2095 DECLARE_FLAGS(RUNTIME_FLAGS)
2096 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2097 
2098 #endif // SHARE_RUNTIME_GLOBALS_HPP

 108 // Default and minimum StringTable and SymbolTable size values
 109 // Must be powers of 2
 110 const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536);
 111 const size_t minimumStringTableSize = 128;
 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, true,                           \
 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, true, 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)                                               \

2072   JFR_ONLY(product(ccstr, FlightRecorderOptions, NULL,                      \
2073           "Flight Recorder options"))                                       \
2074                                                                             \
2075   JFR_ONLY(product(ccstr, StartFlightRecording, NULL,                       \
2076           "Start flight recording with options"))                           \
2077                                                                             \
2078   product(bool, UseFastUnorderedTimeStamps, false, EXPERIMENTAL,            \
2079           "Use platform unstable time where supported for timestamps only") \
2080                                                                             \
2081   product(bool, UseEmptySlotsInSupers, true,                                \
2082                 "Allow allocating fields in empty slots of super-classes")  \
2083                                                                             \
2084   product(bool, DeoptimizeNMethodBarriersALot, false, DIAGNOSTIC,           \
2085                 "Make nmethod barriers deoptimise a lot.")                  \
2086                                                                             \
2087   develop(bool, VerifyCrossModifyFence,                                     \
2088           false AARCH64_ONLY(DEBUG_ONLY(||true)),                           \
2089              "Mark all threads after a safepoint, and clear on a modify "   \
2090              "fence. Add cleanliness checks.")                              \
2091                                                                             \
2092   product(bool, HeapObjectStats, false, DIAGNOSTIC,                         \
2093              "Enable gathering of heap object statistics")                  \
2094                                                                             \
2095   product(size_t, HeapObjectStatsSamplingInterval, 500, DIAGNOSTIC,         \
2096              "Heap object statistics sampling interval (ms)")               \
2097                                                                             \
2098   product(bool, UseFastLocking, false, EXPERIMENTAL,                        \
2099                 "Use fast-locking instead of stack-locking")                \
2100                                                                             \
2101   develop(bool, TraceOptimizedUpcallStubs, false,                              \
2102                 "Trace optimized upcall stub generation")                      \
2103 
2104 // end of RUNTIME_FLAGS
2105 
2106 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
2107 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
2108 DECLARE_FLAGS(RUNTIME_FLAGS)
2109 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2110 
2111 #endif // SHARE_RUNTIME_GLOBALS_HPP
< prev index next >