< 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(int, 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 int 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)                                               \

1039   product(ccstr, ErrorFile, nullptr,                                           \
1040           "If an error occurs, save the error data to this file "           \
1041           "[default: ./hs_err_pid%p.log] (%p replaced with pid)")           \
1042                                                                             \
1043   product(bool, ExtensiveErrorReports,                                      \
1044           PRODUCT_ONLY(false) NOT_PRODUCT(true),                            \
1045           "Error reports are more extensive.")                              \
1046                                                                             \
1047   product(bool, DisplayVMOutputToStderr, false,                             \
1048           "If DisplayVMOutput is true, display all VM output to stderr")    \
1049                                                                             \
1050   product(bool, DisplayVMOutputToStdout, false,                             \
1051           "If DisplayVMOutput is true, display all VM output to stdout")    \
1052                                                                             \
1053   product(bool, ErrorFileToStderr, false,                                   \
1054           "If true, error data is printed to stderr instead of a file")     \
1055                                                                             \
1056   product(bool, ErrorFileToStdout, false,                                   \
1057           "If true, error data is printed to stdout instead of a file")     \
1058                                                                             \
1059   develop(bool, UseHeavyMonitors, false,                                    \
1060           "(Deprecated) Use heavyweight instead of lightweight Java "       \
1061           "monitors")                                                       \
1062                                                                             \
1063   develop(bool, VerifyHeavyMonitors, false,                                 \
1064           "Checks that no stack locking happens when using "                \
1065           "+UseHeavyMonitors")                                              \
1066                                                                             \
1067   product(bool, PrintStringTableStatistics, false,                          \
1068           "print statistics about the StringTable and SymbolTable")         \
1069                                                                             \
1070   product(bool, VerifyStringTableAtExit, false, DIAGNOSTIC,                 \
1071           "verify StringTable contents at exit")                            \
1072                                                                             \
1073   notproduct(bool, PrintSymbolTableSizeHistogram, false,                    \
1074           "print histogram of the symbol table")                            \
1075                                                                             \
1076   product(ccstr, AbortVMOnException, nullptr, DIAGNOSTIC,                      \
1077           "Call fatal if this exception is thrown.  Example: "              \
1078           "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
1079                                                                             \

1396   develop(intx, InlineThrowCount,    50,                                    \
1397           "Force inlining of interpreted methods that throw this often")    \
1398           range(0, max_jint)                                                \
1399                                                                             \
1400   develop(intx, InlineThrowMaxSize,   200,                                  \
1401           "Force inlining of throwing methods smaller than this")           \
1402           range(0, max_jint)                                                \
1403                                                                             \
1404   product(size_t, MetaspaceSize, NOT_LP64(16 * M) LP64_ONLY(21 * M),        \
1405           "Initial threshold (in bytes) at which a garbage collection "     \
1406           "is done to reduce Metaspace usage")                              \
1407           constraint(MetaspaceSizeConstraintFunc,AfterErgo)                 \
1408                                                                             \
1409   product(size_t, MaxMetaspaceSize, max_uintx,                              \
1410           "Maximum size of Metaspaces (in bytes)")                          \
1411           constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo)              \
1412                                                                             \
1413   product(size_t, CompressedClassSpaceSize, 1*G,                            \
1414           "Maximum size of class area in Metaspace when compressed "        \
1415           "class pointers are used")                                        \
1416           range(1*M, 3*G)                                                   \
1417                                                                             \
1418   develop(size_t, CompressedClassSpaceBaseAddress, 0,                       \
1419           "Force the class space to be allocated at this address or "       \
1420           "fails VM initialization (requires -Xshare=off.")                 \
1421                                                                             \
1422   product(ccstr, MetaspaceReclaimPolicy, "balanced", DIAGNOSTIC,            \
1423           "options: balanced, aggressive")                                  \
1424                                                                             \
1425   product(bool, PrintMetaspaceStatisticsAtExit, false, DIAGNOSTIC,          \
1426           "Print metaspace statistics upon VM exit.")                       \
1427                                                                             \
1428   develop(bool, MetaspaceGuardAllocations, false,                           \
1429           "Metapace allocations are guarded.")                              \
1430                                                                             \
1431   product(uintx, MinHeapFreeRatio, 40, MANAGEABLE,                          \
1432           "The minimum percentage of heap free after GC to avoid expansion."\
1433           " For most GCs this applies to the old generation. In G1 and"     \
1434           " ParallelGC it applies to the whole heap.")                      \
1435           range(0, 100)                                                     \
1436           constraint(MinHeapFreeRatioConstraintFunc,AfterErgo)              \
1437                                                                             \
1438   product(uintx, MaxHeapFreeRatio, 70, MANAGEABLE,                          \

1961                                                                             \
1962   JFR_ONLY(product(ccstr, FlightRecorderOptions, nullptr,                      \
1963           "Flight Recorder options"))                                       \
1964                                                                             \
1965   JFR_ONLY(product(ccstr, StartFlightRecording, nullptr,                       \
1966           "Start flight recording with options"))                           \
1967                                                                             \
1968   product(bool, UseFastUnorderedTimeStamps, false, EXPERIMENTAL,            \
1969           "Use platform unstable time where supported for timestamps only") \
1970                                                                             \
1971   product(bool, UseEmptySlotsInSupers, true,                                \
1972                 "Allow allocating fields in empty slots of super-classes")  \
1973                                                                             \
1974   product(bool, DeoptimizeNMethodBarriersALot, false, DIAGNOSTIC,           \
1975                 "Make nmethod barriers deoptimise a lot.")                  \
1976                                                                             \
1977   develop(bool, VerifyCrossModifyFence,                                     \
1978           false AARCH64_ONLY(DEBUG_ONLY(||true)),                           \
1979              "Mark all threads after a safepoint, and clear on a modify "   \
1980              "fence. Add cleanliness checks.")                              \









1981 
1982 // end of RUNTIME_FLAGS
1983 
1984 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
1985 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
1986 DECLARE_FLAGS(RUNTIME_FLAGS)
1987 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
1988 
1989 #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(int, 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 int 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)                                               \

1043   product(ccstr, ErrorFile, nullptr,                                           \
1044           "If an error occurs, save the error data to this file "           \
1045           "[default: ./hs_err_pid%p.log] (%p replaced with pid)")           \
1046                                                                             \
1047   product(bool, ExtensiveErrorReports,                                      \
1048           PRODUCT_ONLY(false) NOT_PRODUCT(true),                            \
1049           "Error reports are more extensive.")                              \
1050                                                                             \
1051   product(bool, DisplayVMOutputToStderr, false,                             \
1052           "If DisplayVMOutput is true, display all VM output to stderr")    \
1053                                                                             \
1054   product(bool, DisplayVMOutputToStdout, false,                             \
1055           "If DisplayVMOutput is true, display all VM output to stdout")    \
1056                                                                             \
1057   product(bool, ErrorFileToStderr, false,                                   \
1058           "If true, error data is printed to stderr instead of a file")     \
1059                                                                             \
1060   product(bool, ErrorFileToStdout, false,                                   \
1061           "If true, error data is printed to stdout instead of a file")     \
1062                                                                             \
1063   product(bool, UseHeavyMonitors, false, DIAGNOSTIC,                        \
1064           "(Deprecated) Use heavyweight instead of lightweight Java "       \
1065           "monitors")                                                       \
1066                                                                             \
1067   develop(bool, VerifyHeavyMonitors, false,                                 \
1068           "Checks that no stack locking happens when using "                \
1069           "+UseHeavyMonitors")                                              \
1070                                                                             \
1071   product(bool, PrintStringTableStatistics, false,                          \
1072           "print statistics about the StringTable and SymbolTable")         \
1073                                                                             \
1074   product(bool, VerifyStringTableAtExit, false, DIAGNOSTIC,                 \
1075           "verify StringTable contents at exit")                            \
1076                                                                             \
1077   notproduct(bool, PrintSymbolTableSizeHistogram, false,                    \
1078           "print histogram of the symbol table")                            \
1079                                                                             \
1080   product(ccstr, AbortVMOnException, nullptr, DIAGNOSTIC,                      \
1081           "Call fatal if this exception is thrown.  Example: "              \
1082           "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
1083                                                                             \

1400   develop(intx, InlineThrowCount,    50,                                    \
1401           "Force inlining of interpreted methods that throw this often")    \
1402           range(0, max_jint)                                                \
1403                                                                             \
1404   develop(intx, InlineThrowMaxSize,   200,                                  \
1405           "Force inlining of throwing methods smaller than this")           \
1406           range(0, max_jint)                                                \
1407                                                                             \
1408   product(size_t, MetaspaceSize, NOT_LP64(16 * M) LP64_ONLY(21 * M),        \
1409           "Initial threshold (in bytes) at which a garbage collection "     \
1410           "is done to reduce Metaspace usage")                              \
1411           constraint(MetaspaceSizeConstraintFunc,AfterErgo)                 \
1412                                                                             \
1413   product(size_t, MaxMetaspaceSize, max_uintx,                              \
1414           "Maximum size of Metaspaces (in bytes)")                          \
1415           constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo)              \
1416                                                                             \
1417   product(size_t, CompressedClassSpaceSize, 1*G,                            \
1418           "Maximum size of class area in Metaspace when compressed "        \
1419           "class pointers are used")                                        \
1420           constraint(CompressedClassSpaceSizeConstraintFunc, AfterErgo)     \
1421                                                                             \
1422   product(size_t, CompressedClassSpaceBaseAddress, 0, DIAGNOSTIC,           \
1423           "Force the class space to be allocated at this address or "       \
1424           "fails VM initialization (requires -Xshare=off.")                 \
1425                                                                             \
1426   product(ccstr, MetaspaceReclaimPolicy, "balanced", DIAGNOSTIC,            \
1427           "options: balanced, aggressive")                                  \
1428                                                                             \
1429   product(bool, PrintMetaspaceStatisticsAtExit, false, DIAGNOSTIC,          \
1430           "Print metaspace statistics upon VM exit.")                       \
1431                                                                             \
1432   develop(bool, MetaspaceGuardAllocations, false,                           \
1433           "Metapace allocations are guarded.")                              \
1434                                                                             \
1435   product(uintx, MinHeapFreeRatio, 40, MANAGEABLE,                          \
1436           "The minimum percentage of heap free after GC to avoid expansion."\
1437           " For most GCs this applies to the old generation. In G1 and"     \
1438           " ParallelGC it applies to the whole heap.")                      \
1439           range(0, 100)                                                     \
1440           constraint(MinHeapFreeRatioConstraintFunc,AfterErgo)              \
1441                                                                             \
1442   product(uintx, MaxHeapFreeRatio, 70, MANAGEABLE,                          \

1965                                                                             \
1966   JFR_ONLY(product(ccstr, FlightRecorderOptions, nullptr,                      \
1967           "Flight Recorder options"))                                       \
1968                                                                             \
1969   JFR_ONLY(product(ccstr, StartFlightRecording, nullptr,                       \
1970           "Start flight recording with options"))                           \
1971                                                                             \
1972   product(bool, UseFastUnorderedTimeStamps, false, EXPERIMENTAL,            \
1973           "Use platform unstable time where supported for timestamps only") \
1974                                                                             \
1975   product(bool, UseEmptySlotsInSupers, true,                                \
1976                 "Allow allocating fields in empty slots of super-classes")  \
1977                                                                             \
1978   product(bool, DeoptimizeNMethodBarriersALot, false, DIAGNOSTIC,           \
1979                 "Make nmethod barriers deoptimise a lot.")                  \
1980                                                                             \
1981   develop(bool, VerifyCrossModifyFence,                                     \
1982           false AARCH64_ONLY(DEBUG_ONLY(||true)),                           \
1983              "Mark all threads after a safepoint, and clear on a modify "   \
1984              "fence. Add cleanliness checks.")                              \
1985                                                                             \
1986   product(bool, HeapObjectStats, false, DIAGNOSTIC,                         \
1987              "Enable gathering of heap object statistics")                  \
1988                                                                             \
1989   product(size_t, HeapObjectStatsSamplingInterval, 500, DIAGNOSTIC,         \
1990              "Heap object statistics sampling interval (ms)")               \
1991                                                                             \
1992   product(bool, UseFastLocking, false, EXPERIMENTAL,                        \
1993                 "Use fast-locking instead of stack-locking")                \
1994 
1995 // end of RUNTIME_FLAGS
1996 
1997 DECLARE_FLAGS(LP64_RUNTIME_FLAGS)
1998 DECLARE_ARCH_FLAGS(ARCH_FLAGS)
1999 DECLARE_FLAGS(RUNTIME_FLAGS)
2000 DECLARE_FLAGS(RUNTIME_OS_FLAGS)
2001 
2002 #endif // SHARE_RUNTIME_GLOBALS_HPP
< prev index next >