src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File 6914622 Sdiff src/share/vm/runtime

src/share/vm/runtime/globals.hpp

Print this page




 194 
 195   static bool uint64_tAt(char* name, size_t len, uint64_t* value);
 196   static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }
 197   static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin);
 198   static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
 199 
 200   static bool doubleAt(char* name, size_t len, double* value);
 201   static bool doubleAt(char* name, double* value)    { return doubleAt(name, strlen(name), value); }
 202   static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);
 203   static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }
 204 
 205   static bool ccstrAt(char* name, size_t len, ccstr* value);
 206   static bool ccstrAt(char* name, ccstr* value)    { return ccstrAt(name, strlen(name), value); }
 207   static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);
 208   static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }
 209 
 210   // Returns false if name is not a command line flag.
 211   static bool wasSetOnCmdline(const char* name, bool* value);
 212   static void printSetFlags();
 213 
 214   static void printFlags() PRODUCT_RETURN;
 215 
 216   static void verify() PRODUCT_RETURN;
 217 };
 218 
 219 // use this for flags that are true by default in the debug version but
 220 // false in the optimized version, and vice versa
 221 #ifdef ASSERT
 222 #define trueInDebug  true
 223 #define falseInDebug false
 224 #else
 225 #define trueInDebug  false
 226 #define falseInDebug true
 227 #endif
 228 
 229 // use this for flags that are true per default in the product build
 230 // but false in development builds, and vice versa
 231 #ifdef PRODUCT
 232 #define trueInProduct  true
 233 #define falseInProduct false
 234 #else


 310                                                                             \
 311   lp64_product(bool, UseCompressedOops, false,                              \
 312             "Use 32-bit object references in 64-bit VM. "                   \
 313             "lp64_product means flag is always constant in 32 bit VM")      \
 314                                                                             \
 315   notproduct(bool, CheckCompressedOops, true,                               \
 316             "generate checks in encoding/decoding code in debug VM")        \
 317                                                                             \
 318   product_pd(uintx, HeapBaseMinAddress,                                     \
 319             "OS specific low limit for heap base address")                  \
 320                                                                             \
 321   diagnostic(bool, PrintCompressedOopsMode, false,                          \
 322             "Print compressed oops base address and encoding mode")         \
 323                                                                             \
 324   /* UseMembar is theoretically a temp flag used for memory barrier         \
 325    * removal testing.  It was supposed to be removed before FCS but has     \
 326    * been re-added (see 6401008) */                                         \
 327   product(bool, UseMembar, false,                                           \
 328           "(Unstable) Issues membars on thread state transitions")          \
 329                                                                             \
 330   product(bool, PrintCommandLineFlags, false,                               \
 331           "Prints flags that appeared on the command line")                 \
 332                                                                             \
 333   diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \
 334           "Enable normal processing of flags relating to field diagnostics")\
 335                                                                             \
 336   experimental(bool, UnlockExperimentalVMOptions, false,                    \
 337           "Enable normal processing of flags relating to experimental features")\
 338                                                                             \
 339   product(bool, JavaMonitorsInStackTrace, true,                             \
 340           "Print info. about Java monitor locks when the stacks are dumped")\
 341                                                                             \
 342   product_pd(bool, UseLargePages,                                           \
 343           "Use large page memory")                                          \
 344                                                                             \
 345   product_pd(bool, UseLargePagesIndividualAllocation,                       \
 346           "Allocate large pages individually for better affinity")          \
 347                                                                             \
 348   develop(bool, LargePagesIndividualAllocationInjectError, false,           \
 349           "Fail large pages individual allocation")                         \
 350                                                                             \
 351   develop(bool, TracePageSizes, false,                                      \
 352           "Trace page size selection and usage.")                           \


1950   diagnostic(uintx, CPUForCMSThread, 0,                                     \
1951           "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
1952                                                                             \
1953   product(bool, BindGCTaskThreadsToCPUs, false,                             \
1954           "Bind GCTaskThreads to CPUs if possible")                         \
1955                                                                             \
1956   product(bool, UseGCTaskAffinity, false,                                   \
1957           "Use worker affinity when asking for GCTasks")                    \
1958                                                                             \
1959   product(uintx, ProcessDistributionStride, 4,                              \
1960           "Stride through processors when distributing processes")          \
1961                                                                             \
1962   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
1963           "number of times the coordinator GC thread will sleep while "     \
1964           "yielding before giving up and resuming GC")                      \
1965                                                                             \
1966   product(uintx, CMSYieldSleepCount, 0,                                     \
1967           "number of times a GC thread (minus the coordinator) "            \
1968           "will sleep while yielding before giving up and resuming GC")     \
1969                                                                             \
1970   notproduct(bool, PrintFlagsFinal, false,                                  \
1971           "Print all command line flags after argument processing")         \
1972                                                                             \
1973   /* gc tracing */                                                          \
1974   manageable(bool, PrintGC, false,                                          \
1975           "Print message at garbage collect")                               \
1976                                                                             \
1977   manageable(bool, PrintGCDetails, false,                                   \
1978           "Print more details at garbage collect")                          \
1979                                                                             \
1980   manageable(bool, PrintGCDateStamps, false,                                \
1981           "Print date stamps at garbage collect")                           \
1982                                                                             \
1983   manageable(bool, PrintGCTimeStamps, false,                                \
1984           "Print timestamps at garbage collect")                            \
1985                                                                             \
1986   product(bool, PrintGCTaskTimeStamps, false,                               \
1987           "Print timestamps for individual gc worker thread tasks")         \
1988                                                                             \
1989   develop(intx, ConcGCYieldTimeout, 0,                                      \
1990           "If non-zero, assert that GC threads yield within this # of ms.") \
1991                                                                             \
1992   notproduct(bool, TraceMarkSweep, false,                                   \


2252   develop(bool, PrintMethodFlushing, false,                                 \
2253           "print the nmethods being flushed")                               \
2254                                                                             \
2255   notproduct(bool, LogMultipleMutexLocking, false,                          \
2256           "log locking and unlocking of mutexes (only if multiple locks "   \
2257           "are held)")                                                      \
2258                                                                             \
2259   develop(bool, UseRelocIndex, false,                                       \
2260          "use an index to speed random access to relocations")              \
2261                                                                             \
2262   develop(bool, StressCodeBuffers, false,                                   \
2263          "Exercise code buffer expansion and other rare state changes")     \
2264                                                                             \
2265   diagnostic(bool, DebugNonSafepoints, trueInDebug,                         \
2266          "Generate extra debugging info for non-safepoints in nmethods")    \
2267                                                                             \
2268   diagnostic(bool, DebugInlinedCalls, true,                                 \
2269          "If false, restricts profiled locations to the root method only")  \
2270                                                                             \
2271   product(bool, PrintVMOptions, trueInDebug,                                \
2272          "print VM flag settings")                                          \
2273                                                                             \
2274   product(bool, IgnoreUnrecognizedVMOptions, false,                         \
2275          "Ignore unrecognized VM options")                                  \
2276                                                                             \









2277   diagnostic(bool, SerializeVMOutput, true,                                 \
2278          "Use a mutex to serialize output to tty and hotspot.log")          \
2279                                                                             \
2280   diagnostic(bool, DisplayVMOutput, true,                                   \
2281          "Display all VM output on the tty, independently of LogVMOutput")  \
2282                                                                             \
2283   diagnostic(bool, LogVMOutput, trueInDebug,                                \
2284          "Save VM output to hotspot.log, or to LogFile")                    \
2285                                                                             \
2286   diagnostic(ccstr, LogFile, NULL,                                          \
2287          "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
2288                                                                             \
2289   product(ccstr, ErrorFile, NULL,                                           \
2290          "If an error occurs, save the error data to this file "            \
2291          "[default: ./hs_err_pid%p.log] (%p replaced with pid)")            \
2292                                                                             \
2293   product(bool, DisplayVMOutputToStderr, false,                             \
2294          "If DisplayVMOutput is true, display all VM output to stderr")     \
2295                                                                             \
2296   product(bool, DisplayVMOutputToStdout, false,                             \




 194 
 195   static bool uint64_tAt(char* name, size_t len, uint64_t* value);
 196   static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }
 197   static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin);
 198   static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
 199 
 200   static bool doubleAt(char* name, size_t len, double* value);
 201   static bool doubleAt(char* name, double* value)    { return doubleAt(name, strlen(name), value); }
 202   static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);
 203   static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }
 204 
 205   static bool ccstrAt(char* name, size_t len, ccstr* value);
 206   static bool ccstrAt(char* name, ccstr* value)    { return ccstrAt(name, strlen(name), value); }
 207   static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);
 208   static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }
 209 
 210   // Returns false if name is not a command line flag.
 211   static bool wasSetOnCmdline(const char* name, bool* value);
 212   static void printSetFlags();
 213 
 214   static void printFlags();
 215 
 216   static void verify() PRODUCT_RETURN;
 217 };
 218 
 219 // use this for flags that are true by default in the debug version but
 220 // false in the optimized version, and vice versa
 221 #ifdef ASSERT
 222 #define trueInDebug  true
 223 #define falseInDebug false
 224 #else
 225 #define trueInDebug  false
 226 #define falseInDebug true
 227 #endif
 228 
 229 // use this for flags that are true per default in the product build
 230 // but false in development builds, and vice versa
 231 #ifdef PRODUCT
 232 #define trueInProduct  true
 233 #define falseInProduct false
 234 #else


 310                                                                             \
 311   lp64_product(bool, UseCompressedOops, false,                              \
 312             "Use 32-bit object references in 64-bit VM. "                   \
 313             "lp64_product means flag is always constant in 32 bit VM")      \
 314                                                                             \
 315   notproduct(bool, CheckCompressedOops, true,                               \
 316             "generate checks in encoding/decoding code in debug VM")        \
 317                                                                             \
 318   product_pd(uintx, HeapBaseMinAddress,                                     \
 319             "OS specific low limit for heap base address")                  \
 320                                                                             \
 321   diagnostic(bool, PrintCompressedOopsMode, false,                          \
 322             "Print compressed oops base address and encoding mode")         \
 323                                                                             \
 324   /* UseMembar is theoretically a temp flag used for memory barrier         \
 325    * removal testing.  It was supposed to be removed before FCS but has     \
 326    * been re-added (see 6401008) */                                         \
 327   product(bool, UseMembar, false,                                           \
 328           "(Unstable) Issues membars on thread state transitions")          \
 329                                                                             \



 330   diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \
 331           "Enable normal processing of flags relating to field diagnostics")\
 332                                                                             \
 333   experimental(bool, UnlockExperimentalVMOptions, false,                    \
 334           "Enable normal processing of flags relating to experimental features")\
 335                                                                             \
 336   product(bool, JavaMonitorsInStackTrace, true,                             \
 337           "Print info. about Java monitor locks when the stacks are dumped")\
 338                                                                             \
 339   product_pd(bool, UseLargePages,                                           \
 340           "Use large page memory")                                          \
 341                                                                             \
 342   product_pd(bool, UseLargePagesIndividualAllocation,                       \
 343           "Allocate large pages individually for better affinity")          \
 344                                                                             \
 345   develop(bool, LargePagesIndividualAllocationInjectError, false,           \
 346           "Fail large pages individual allocation")                         \
 347                                                                             \
 348   develop(bool, TracePageSizes, false,                                      \
 349           "Trace page size selection and usage.")                           \


1947   diagnostic(uintx, CPUForCMSThread, 0,                                     \
1948           "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
1949                                                                             \
1950   product(bool, BindGCTaskThreadsToCPUs, false,                             \
1951           "Bind GCTaskThreads to CPUs if possible")                         \
1952                                                                             \
1953   product(bool, UseGCTaskAffinity, false,                                   \
1954           "Use worker affinity when asking for GCTasks")                    \
1955                                                                             \
1956   product(uintx, ProcessDistributionStride, 4,                              \
1957           "Stride through processors when distributing processes")          \
1958                                                                             \
1959   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
1960           "number of times the coordinator GC thread will sleep while "     \
1961           "yielding before giving up and resuming GC")                      \
1962                                                                             \
1963   product(uintx, CMSYieldSleepCount, 0,                                     \
1964           "number of times a GC thread (minus the coordinator) "            \
1965           "will sleep while yielding before giving up and resuming GC")     \
1966                                                                             \



1967   /* gc tracing */                                                          \
1968   manageable(bool, PrintGC, false,                                          \
1969           "Print message at garbage collect")                               \
1970                                                                             \
1971   manageable(bool, PrintGCDetails, false,                                   \
1972           "Print more details at garbage collect")                          \
1973                                                                             \
1974   manageable(bool, PrintGCDateStamps, false,                                \
1975           "Print date stamps at garbage collect")                           \
1976                                                                             \
1977   manageable(bool, PrintGCTimeStamps, false,                                \
1978           "Print timestamps at garbage collect")                            \
1979                                                                             \
1980   product(bool, PrintGCTaskTimeStamps, false,                               \
1981           "Print timestamps for individual gc worker thread tasks")         \
1982                                                                             \
1983   develop(intx, ConcGCYieldTimeout, 0,                                      \
1984           "If non-zero, assert that GC threads yield within this # of ms.") \
1985                                                                             \
1986   notproduct(bool, TraceMarkSweep, false,                                   \


2246   develop(bool, PrintMethodFlushing, false,                                 \
2247           "print the nmethods being flushed")                               \
2248                                                                             \
2249   notproduct(bool, LogMultipleMutexLocking, false,                          \
2250           "log locking and unlocking of mutexes (only if multiple locks "   \
2251           "are held)")                                                      \
2252                                                                             \
2253   develop(bool, UseRelocIndex, false,                                       \
2254          "use an index to speed random access to relocations")              \
2255                                                                             \
2256   develop(bool, StressCodeBuffers, false,                                   \
2257          "Exercise code buffer expansion and other rare state changes")     \
2258                                                                             \
2259   diagnostic(bool, DebugNonSafepoints, trueInDebug,                         \
2260          "Generate extra debugging info for non-safepoints in nmethods")    \
2261                                                                             \
2262   diagnostic(bool, DebugInlinedCalls, true,                                 \
2263          "If false, restricts profiled locations to the root method only")  \
2264                                                                             \
2265   product(bool, PrintVMOptions, trueInDebug,                                \
2266          "Print flags that appeared on the command line")                   \
2267                                                                             \
2268   product(bool, IgnoreUnrecognizedVMOptions, false,                         \
2269          "Ignore unrecognized VM options")                                  \
2270                                                                             \
2271   product(bool, PrintCommandLineFlags, false,                               \
2272          "Print flags specified on command line or set by ergonomic")       \
2273                                                                             \
2274   product(bool, PrintFlagsInitial, false,                                   \
2275          "Print all VM flags before arguments processing")                  \
2276                                                                             \
2277   product(bool, PrintFlagsFinal, false,                                     \
2278          "Print all VM flags after arguments processing and ergonomic")     \
2279                                                                             \
2280   diagnostic(bool, SerializeVMOutput, true,                                 \
2281          "Use a mutex to serialize output to tty and hotspot.log")          \
2282                                                                             \
2283   diagnostic(bool, DisplayVMOutput, true,                                   \
2284          "Display all VM output on the tty, independently of LogVMOutput")  \
2285                                                                             \
2286   diagnostic(bool, LogVMOutput, trueInDebug,                                \
2287          "Save VM output to hotspot.log, or to LogFile")                    \
2288                                                                             \
2289   diagnostic(ccstr, LogFile, NULL,                                          \
2290          "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
2291                                                                             \
2292   product(ccstr, ErrorFile, NULL,                                           \
2293          "If an error occurs, save the error data to this file "            \
2294          "[default: ./hs_err_pid%p.log] (%p replaced with pid)")            \
2295                                                                             \
2296   product(bool, DisplayVMOutputToStderr, false,                             \
2297          "If DisplayVMOutput is true, display all VM output to stderr")     \
2298                                                                             \
2299   product(bool, DisplayVMOutputToStdout, false,                             \


src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File