annotate src/share/vm/runtime/globals.hpp @ 94:0834225a7916

6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction Summary: The option CMSInitiatingPermOccupancyFraction now controls perm triggering threshold. Even though the actual value of the threshold has not yet been changed, so there is no change in policy, we now have the infrastructure in place for dynamically deciding when to collect the perm gen, an issue that will be addressed in the near future. Reviewed-by: jmasa
author ysr
date Sun, 16 Mar 2008 21:57:25 -0700
parents d825a8a2bd39
children d05ebaf00ed0
rev   line source
duke@0 1 /*
duke@0 2 * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
duke@0 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 *
duke@0 5 * This code is free software; you can redistribute it and/or modify it
duke@0 6 * under the terms of the GNU General Public License version 2 only, as
duke@0 7 * published by the Free Software Foundation.
duke@0 8 *
duke@0 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@0 13 * accompanied this code).
duke@0 14 *
duke@0 15 * You should have received a copy of the GNU General Public License version
duke@0 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@0 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 18 *
duke@0 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@0 20 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@0 21 * have any questions.
duke@0 22 *
duke@0 23 */
duke@0 24
duke@0 25 #if !defined(COMPILER1) && !defined(COMPILER2)
duke@0 26 define_pd_global(bool, BackgroundCompilation, false);
duke@0 27 define_pd_global(bool, UseTLAB, false);
duke@0 28 define_pd_global(bool, CICompileOSR, false);
duke@0 29 define_pd_global(bool, UseTypeProfile, false);
duke@0 30 define_pd_global(bool, UseOnStackReplacement, false);
duke@0 31 define_pd_global(bool, InlineIntrinsics, false);
duke@0 32 define_pd_global(bool, PreferInterpreterNativeStubs, true);
duke@0 33 define_pd_global(bool, ProfileInterpreter, false);
duke@0 34 define_pd_global(bool, ProfileTraps, false);
duke@0 35 define_pd_global(bool, TieredCompilation, false);
duke@0 36
duke@0 37 define_pd_global(intx, CompileThreshold, 0);
duke@0 38 define_pd_global(intx, Tier2CompileThreshold, 0);
duke@0 39 define_pd_global(intx, Tier3CompileThreshold, 0);
duke@0 40 define_pd_global(intx, Tier4CompileThreshold, 0);
duke@0 41
duke@0 42 define_pd_global(intx, BackEdgeThreshold, 0);
duke@0 43 define_pd_global(intx, Tier2BackEdgeThreshold, 0);
duke@0 44 define_pd_global(intx, Tier3BackEdgeThreshold, 0);
duke@0 45 define_pd_global(intx, Tier4BackEdgeThreshold, 0);
duke@0 46
duke@0 47 define_pd_global(intx, OnStackReplacePercentage, 0);
duke@0 48 define_pd_global(bool, ResizeTLAB, false);
duke@0 49 define_pd_global(intx, FreqInlineSize, 0);
duke@0 50 define_pd_global(intx, NewSizeThreadIncrease, 4*K);
duke@0 51 define_pd_global(intx, NewRatio, 4);
duke@0 52 define_pd_global(intx, InlineClassNatives, true);
duke@0 53 define_pd_global(intx, InlineUnsafeOps, true);
duke@0 54 define_pd_global(intx, InitialCodeCacheSize, 160*K);
duke@0 55 define_pd_global(intx, ReservedCodeCacheSize, 32*M);
duke@0 56 define_pd_global(intx, CodeCacheExpansionSize, 32*K);
duke@0 57 define_pd_global(intx, CodeCacheMinBlockLength, 1);
duke@0 58 define_pd_global(uintx,PermSize, ScaleForWordSize(4*M));
duke@0 59 define_pd_global(uintx,MaxPermSize, ScaleForWordSize(64*M));
duke@0 60 define_pd_global(bool, NeverActAsServerClassMachine, true);
duke@0 61 define_pd_global(uintx, DefaultMaxRAM, 1*G);
duke@0 62 #define CI_COMPILER_COUNT 0
duke@0 63 #else
duke@0 64
duke@0 65 #ifdef COMPILER2
duke@0 66 #define CI_COMPILER_COUNT 2
duke@0 67 #else
duke@0 68 #define CI_COMPILER_COUNT 1
duke@0 69 #endif // COMPILER2
duke@0 70
duke@0 71 #endif // no compilers
duke@0 72
duke@0 73
duke@0 74 // string type aliases used only in this file
duke@0 75 typedef const char* ccstr;
duke@0 76 typedef const char* ccstrlist; // represents string arguments which accumulate
duke@0 77
duke@0 78 enum FlagValueOrigin {
duke@0 79 DEFAULT = 0,
duke@0 80 COMMAND_LINE = 1,
duke@0 81 ENVIRON_VAR = 2,
duke@0 82 CONFIG_FILE = 3,
duke@0 83 MANAGEMENT = 4,
duke@0 84 ERGONOMIC = 5,
duke@0 85 ATTACH_ON_DEMAND = 6,
duke@0 86 INTERNAL = 99
duke@0 87 };
duke@0 88
duke@0 89 struct Flag {
duke@0 90 const char *type;
duke@0 91 const char *name;
duke@0 92 void* addr;
duke@0 93 const char *kind;
duke@0 94 FlagValueOrigin origin;
duke@0 95
duke@0 96 // points to all Flags static array
duke@0 97 static Flag *flags;
duke@0 98
duke@0 99 // number of flags
duke@0 100 static size_t numFlags;
duke@0 101
duke@0 102 static Flag* find_flag(char* name, size_t length);
duke@0 103
duke@0 104 bool is_bool() const { return strcmp(type, "bool") == 0; }
duke@0 105 bool get_bool() const { return *((bool*) addr); }
duke@0 106 void set_bool(bool value) { *((bool*) addr) = value; }
duke@0 107
duke@0 108 bool is_intx() const { return strcmp(type, "intx") == 0; }
duke@0 109 intx get_intx() const { return *((intx*) addr); }
duke@0 110 void set_intx(intx value) { *((intx*) addr) = value; }
duke@0 111
duke@0 112 bool is_uintx() const { return strcmp(type, "uintx") == 0; }
duke@0 113 uintx get_uintx() const { return *((uintx*) addr); }
duke@0 114 void set_uintx(uintx value) { *((uintx*) addr) = value; }
duke@0 115
duke@0 116 bool is_double() const { return strcmp(type, "double") == 0; }
duke@0 117 double get_double() const { return *((double*) addr); }
duke@0 118 void set_double(double value) { *((double*) addr) = value; }
duke@0 119
duke@0 120 bool is_ccstr() const { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; }
duke@0 121 bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; }
duke@0 122 ccstr get_ccstr() const { return *((ccstr*) addr); }
duke@0 123 void set_ccstr(ccstr value) { *((ccstr*) addr) = value; }
duke@0 124
duke@0 125 bool is_unlocker() const;
duke@0 126 bool is_unlocked() const;
duke@0 127 bool is_writeable() const;
duke@0 128 bool is_external() const;
duke@0 129
duke@0 130 void print_on(outputStream* st);
duke@0 131 void print_as_flag(outputStream* st);
duke@0 132 };
duke@0 133
duke@0 134 // debug flags control various aspects of the VM and are global accessible
duke@0 135
duke@0 136 // use FlagSetting to temporarily change some debug flag
duke@0 137 // e.g. FlagSetting fs(DebugThisAndThat, true);
duke@0 138 // restored to previous value upon leaving scope
duke@0 139 class FlagSetting {
duke@0 140 bool val;
duke@0 141 bool* flag;
duke@0 142 public:
duke@0 143 FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }
duke@0 144 ~FlagSetting() { *flag = val; }
duke@0 145 };
duke@0 146
duke@0 147
duke@0 148 class CounterSetting {
duke@0 149 intx* counter;
duke@0 150 public:
duke@0 151 CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }
duke@0 152 ~CounterSetting() { (*counter)--; }
duke@0 153 };
duke@0 154
duke@0 155
duke@0 156 class IntFlagSetting {
duke@0 157 intx val;
duke@0 158 intx* flag;
duke@0 159 public:
duke@0 160 IntFlagSetting(intx& fl, intx newValue) { flag = &fl; val = fl; fl = newValue; }
duke@0 161 ~IntFlagSetting() { *flag = val; }
duke@0 162 };
duke@0 163
duke@0 164
duke@0 165 class DoubleFlagSetting {
duke@0 166 double val;
duke@0 167 double* flag;
duke@0 168 public:
duke@0 169 DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }
duke@0 170 ~DoubleFlagSetting() { *flag = val; }
duke@0 171 };
duke@0 172
duke@0 173
duke@0 174 class CommandLineFlags {
duke@0 175 public:
duke@0 176 static bool boolAt(char* name, size_t len, bool* value);
duke@0 177 static bool boolAt(char* name, bool* value) { return boolAt(name, strlen(name), value); }
duke@0 178 static bool boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin);
duke@0 179 static bool boolAtPut(char* name, bool* value, FlagValueOrigin origin) { return boolAtPut(name, strlen(name), value, origin); }
duke@0 180
duke@0 181 static bool intxAt(char* name, size_t len, intx* value);
duke@0 182 static bool intxAt(char* name, intx* value) { return intxAt(name, strlen(name), value); }
duke@0 183 static bool intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin);
duke@0 184 static bool intxAtPut(char* name, intx* value, FlagValueOrigin origin) { return intxAtPut(name, strlen(name), value, origin); }
duke@0 185
duke@0 186 static bool uintxAt(char* name, size_t len, uintx* value);
duke@0 187 static bool uintxAt(char* name, uintx* value) { return uintxAt(name, strlen(name), value); }
duke@0 188 static bool uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin);
duke@0 189 static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin origin) { return uintxAtPut(name, strlen(name), value, origin); }
duke@0 190
duke@0 191 static bool doubleAt(char* name, size_t len, double* value);
duke@0 192 static bool doubleAt(char* name, double* value) { return doubleAt(name, strlen(name), value); }
duke@0 193 static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);
duke@0 194 static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }
duke@0 195
duke@0 196 static bool ccstrAt(char* name, size_t len, ccstr* value);
duke@0 197 static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); }
duke@0 198 static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);
duke@0 199 static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }
duke@0 200
duke@0 201 // Returns false if name is not a command line flag.
duke@0 202 static bool wasSetOnCmdline(const char* name, bool* value);
duke@0 203 static void printSetFlags();
duke@0 204
duke@0 205 static void printFlags() PRODUCT_RETURN;
duke@0 206
duke@0 207 static void verify() PRODUCT_RETURN;
duke@0 208 };
duke@0 209
duke@0 210 // use this for flags that are true by default in the debug version but
duke@0 211 // false in the optimized version, and vice versa
duke@0 212 #ifdef ASSERT
duke@0 213 #define trueInDebug true
duke@0 214 #define falseInDebug false
duke@0 215 #else
duke@0 216 #define trueInDebug false
duke@0 217 #define falseInDebug true
duke@0 218 #endif
duke@0 219
duke@0 220 // use this for flags that are true per default in the product build
duke@0 221 // but false in development builds, and vice versa
duke@0 222 #ifdef PRODUCT
duke@0 223 #define trueInProduct true
duke@0 224 #define falseInProduct false
duke@0 225 #else
duke@0 226 #define trueInProduct false
duke@0 227 #define falseInProduct true
duke@0 228 #endif
duke@0 229
duke@0 230 // use this for flags that are true per default in the tiered build
duke@0 231 // but false in non-tiered builds, and vice versa
duke@0 232 #ifdef TIERED
duke@0 233 #define trueInTiered true
duke@0 234 #define falseInTiered false
duke@0 235 #else
duke@0 236 #define trueInTiered false
duke@0 237 #define falseInTiered true
duke@0 238 #endif
duke@0 239
duke@0 240
duke@0 241 // develop flags are settable / visible only during development and are constant in the PRODUCT version
duke@0 242 // product flags are always settable / visible
duke@0 243 // notproduct flags are settable / visible only during development and are not declared in the PRODUCT version
duke@0 244
duke@0 245 // A flag must be declared with one of the following types:
duke@0 246 // bool, intx, uintx, ccstr.
duke@0 247 // The type "ccstr" is an alias for "const char*" and is used
duke@0 248 // only in this file, because the macrology requires single-token type names.
duke@0 249
duke@0 250 // Note: Diagnostic options not meant for VM tuning or for product modes.
duke@0 251 // They are to be used for VM quality assurance or field diagnosis
duke@0 252 // of VM bugs. They are hidden so that users will not be encouraged to
duke@0 253 // try them as if they were VM ordinary execution options. However, they
duke@0 254 // are available in the product version of the VM. Under instruction
duke@0 255 // from support engineers, VM customers can turn them on to collect
duke@0 256 // diagnostic information about VM problems. To use a VM diagnostic
duke@0 257 // option, you must first specify +UnlockDiagnosticVMOptions.
duke@0 258 // (This master switch also affects the behavior of -Xprintflags.)
duke@0 259
duke@0 260 // manageable flags are writeable external product flags.
duke@0 261 // They are dynamically writeable through the JDK management interface
duke@0 262 // (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
duke@0 263 // These flags are external exported interface (see CCC). The list of
duke@0 264 // manageable flags can be queried programmatically through the management
duke@0 265 // interface.
duke@0 266 //
duke@0 267 // A flag can be made as "manageable" only if
duke@0 268 // - the flag is defined in a CCC as an external exported interface.
duke@0 269 // - the VM implementation supports dynamic setting of the flag.
duke@0 270 // This implies that the VM must *always* query the flag variable
duke@0 271 // and not reuse state related to the flag state at any given time.
duke@0 272 // - you want the flag to be queried programmatically by the customers.
duke@0 273 //
duke@0 274 // product_rw flags are writeable internal product flags.
duke@0 275 // They are like "manageable" flags but for internal/private use.
duke@0 276 // The list of product_rw flags are internal/private flags which
duke@0 277 // may be changed/removed in a future release. It can be set
duke@0 278 // through the management interface to get/set value
duke@0 279 // when the name of flag is supplied.
duke@0 280 //
duke@0 281 // A flag can be made as "product_rw" only if
duke@0 282 // - the VM implementation supports dynamic setting of the flag.
duke@0 283 // This implies that the VM must *always* query the flag variable
duke@0 284 // and not reuse state related to the flag state at any given time.
duke@0 285 //
duke@0 286 // Note that when there is a need to support develop flags to be writeable,
duke@0 287 // it can be done in the same way as product_rw.
duke@0 288
duke@0 289 #define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, notproduct, manageable, product_rw) \
duke@0 290 \
duke@0 291 /* UseMembar is theoretically a temp flag used for memory barrier \
duke@0 292 * removal testing. It was supposed to be removed before FCS but has \
duke@0 293 * been re-added (see 6401008) */ \
duke@0 294 product(bool, UseMembar, false, \
duke@0 295 "(Unstable) Issues membars on thread state transitions") \
duke@0 296 \
duke@0 297 product(bool, PrintCommandLineFlags, false, \
duke@0 298 "Prints flags that appeared on the command line") \
duke@0 299 \
duke@0 300 diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \
duke@0 301 "Enable processing of flags relating to field diagnostics") \
duke@0 302 \
duke@0 303 product(bool, JavaMonitorsInStackTrace, true, \
duke@0 304 "Print info. about Java monitor locks when the stacks are dumped")\
duke@0 305 \
duke@0 306 product_pd(bool, UseLargePages, \
duke@0 307 "Use large page memory") \
duke@0 308 \
duke@0 309 develop(bool, TracePageSizes, false, \
duke@0 310 "Trace page size selection and usage.") \
duke@0 311 \
duke@0 312 product(bool, UseNUMA, false, \
duke@0 313 "Use NUMA if available") \
duke@0 314 \
duke@0 315 product(intx, NUMAChunkResizeWeight, 20, \
duke@0 316 "Percentage (0-100) used to weight the current sample when " \
duke@0 317 "computing exponentially decaying average for " \
duke@0 318 "AdaptiveNUMAChunkSizing") \
duke@0 319 \
duke@0 320 product(intx, NUMASpaceResizeRate, 1*G, \
duke@0 321 "Do not reallocate more that this amount per collection") \
duke@0 322 \
duke@0 323 product(bool, UseAdaptiveNUMAChunkSizing, true, \
duke@0 324 "Enable adaptive chunk sizing for NUMA") \
duke@0 325 \
duke@0 326 product(bool, NUMAStats, false, \
duke@0 327 "Print NUMA stats in detailed heap information") \
duke@0 328 \
duke@0 329 product(intx, NUMAPageScanRate, 256, \
duke@0 330 "Maximum number of pages to include in the page scan procedure") \
duke@0 331 \
duke@0 332 product_pd(bool, NeedsDeoptSuspend, \
duke@0 333 "True for register window machines (sparc/ia64)") \
duke@0 334 \
duke@0 335 product(intx, UseSSE, 99, \
duke@0 336 "Highest supported SSE instructions set on x86/x64") \
duke@0 337 \
duke@0 338 product(uintx, LargePageSizeInBytes, 0, \
duke@0 339 "Large page size (0 to let VM choose the page size") \
duke@0 340 \
duke@0 341 product(uintx, LargePageHeapSizeThreshold, 128*M, \
duke@0 342 "Use large pages if max heap is at least this big") \
duke@0 343 \
duke@0 344 product(bool, ForceTimeHighResolution, false, \
duke@0 345 "Using high time resolution(For Win32 only)") \
duke@0 346 \
duke@0 347 product(bool, CacheTimeMillis, false, \
duke@0 348 "Cache os::javaTimeMillis with CacheTimeMillisGranularity") \
duke@0 349 \
duke@0 350 diagnostic(uintx, CacheTimeMillisGranularity, 50, \
duke@0 351 "Granularity for CacheTimeMillis") \
duke@0 352 \
duke@0 353 develop(bool, TraceItables, false, \
duke@0 354 "Trace initialization and use of itables") \
duke@0 355 \
duke@0 356 develop(bool, TracePcPatching, false, \
duke@0 357 "Trace usage of frame::patch_pc") \
duke@0 358 \
duke@0 359 develop(bool, TraceJumps, false, \
duke@0 360 "Trace assembly jumps in thread ring buffer") \
duke@0 361 \
duke@0 362 develop(bool, TraceRelocator, false, \
duke@0 363 "Trace the bytecode relocator") \
duke@0 364 \
duke@0 365 develop(bool, TraceLongCompiles, false, \
duke@0 366 "Print out every time compilation is longer than " \
duke@0 367 "a given threashold") \
duke@0 368 \
duke@0 369 develop(bool, SafepointALot, false, \
duke@0 370 "Generates a lot of safepoints. Works with " \
duke@0 371 "GuaranteedSafepointInterval") \
duke@0 372 \
duke@0 373 product_pd(bool, BackgroundCompilation, \
duke@0 374 "A thread requesting compilation is not blocked during " \
duke@0 375 "compilation") \
duke@0 376 \
duke@0 377 product(bool, PrintVMQWaitTime, false, \
duke@0 378 "Prints out the waiting time in VM operation queue") \
duke@0 379 \
duke@0 380 develop(bool, BailoutToInterpreterForThrows, false, \
duke@0 381 "Compiled methods which throws/catches exceptions will be " \
duke@0 382 "deopt and intp.") \
duke@0 383 \
duke@0 384 develop(bool, NoYieldsInMicrolock, false, \
duke@0 385 "Disable yields in microlock") \
duke@0 386 \
duke@0 387 develop(bool, TraceOopMapGeneration, false, \
duke@0 388 "Shows oopmap generation") \
duke@0 389 \
duke@0 390 product(bool, MethodFlushing, true, \
duke@0 391 "Reclamation of zombie and not-entrant methods") \
duke@0 392 \
duke@0 393 develop(bool, VerifyStack, false, \
duke@0 394 "Verify stack of each thread when it is entering a runtime call") \
duke@0 395 \
duke@0 396 develop(bool, ForceUnreachable, false, \
duke@0 397 "(amd64) Make all non code cache addresses to be unreachable with rip-rel forcing use of 64bit literal fixups") \
duke@0 398 \
duke@0 399 notproduct(bool, StressDerivedPointers, false, \
duke@0 400 "Force scavenge when a derived pointers is detected on stack " \
duke@0 401 "after rtm call") \
duke@0 402 \
duke@0 403 develop(bool, TraceDerivedPointers, false, \
duke@0 404 "Trace traversal of derived pointers on stack") \
duke@0 405 \
duke@0 406 notproduct(bool, TraceCodeBlobStacks, false, \
duke@0 407 "Trace stack-walk of codeblobs") \
duke@0 408 \
duke@0 409 product(bool, PrintJNIResolving, false, \
duke@0 410 "Used to implement -v:jni") \
duke@0 411 \
duke@0 412 notproduct(bool, PrintRewrites, false, \
duke@0 413 "Print methods that are being rewritten") \
duke@0 414 \
duke@0 415 product(bool, UseInlineCaches, true, \
duke@0 416 "Use Inline Caches for virtual calls ") \
duke@0 417 \
duke@0 418 develop(bool, InlineArrayCopy, true, \
duke@0 419 "inline arraycopy native that is known to be part of " \
duke@0 420 "base library DLL") \
duke@0 421 \
duke@0 422 develop(bool, InlineObjectHash, true, \
duke@0 423 "inline Object::hashCode() native that is known to be part " \
duke@0 424 "of base library DLL") \
duke@0 425 \
duke@0 426 develop(bool, InlineObjectCopy, true, \
duke@0 427 "inline Object.clone and Arrays.copyOf[Range] intrinsics") \
duke@0 428 \
duke@0 429 develop(bool, InlineNatives, true, \
duke@0 430 "inline natives that are known to be part of base library DLL") \
duke@0 431 \
duke@0 432 develop(bool, InlineMathNatives, true, \
duke@0 433 "inline SinD, CosD, etc.") \
duke@0 434 \
duke@0 435 develop(bool, InlineClassNatives, true, \
duke@0 436 "inline Class.isInstance, etc") \
duke@0 437 \
duke@0 438 develop(bool, InlineAtomicLong, true, \
duke@0 439 "inline sun.misc.AtomicLong") \
duke@0 440 \
duke@0 441 develop(bool, InlineThreadNatives, true, \
duke@0 442 "inline Thread.currentThread, etc") \
duke@0 443 \
duke@0 444 develop(bool, InlineReflectionGetCallerClass, true, \
duke@0 445 "inline sun.reflect.Reflection.getCallerClass(), known to be part "\
duke@0 446 "of base library DLL") \
duke@0 447 \
duke@0 448 develop(bool, InlineUnsafeOps, true, \
duke@0 449 "inline memory ops (native methods) from sun.misc.Unsafe") \
duke@0 450 \
duke@0 451 develop(bool, ConvertCmpD2CmpF, true, \
duke@0 452 "Convert cmpD to cmpF when one input is constant in float range") \
duke@0 453 \
duke@0 454 develop(bool, ConvertFloat2IntClipping, true, \
duke@0 455 "Convert float2int clipping idiom to integer clipping") \
duke@0 456 \
duke@0 457 develop(bool, SpecialStringCompareTo, true, \
duke@0 458 "special version of string compareTo") \
duke@0 459 \
duke@0 460 develop(bool, SpecialStringIndexOf, true, \
duke@0 461 "special version of string indexOf") \
duke@0 462 \
duke@0 463 develop(bool, TraceCallFixup, false, \
duke@0 464 "traces all call fixups") \
duke@0 465 \
duke@0 466 develop(bool, DeoptimizeALot, false, \
duke@0 467 "deoptimize at every exit from the runtime system") \
duke@0 468 \
duke@0 469 develop(ccstrlist, DeoptimizeOnlyAt, "", \
duke@0 470 "a comma separated list of bcis to deoptimize at") \
duke@0 471 \
duke@0 472 product(bool, DeoptimizeRandom, false, \
duke@0 473 "deoptimize random frames on random exit from the runtime system")\
duke@0 474 \
duke@0 475 notproduct(bool, ZombieALot, false, \
duke@0 476 "creates zombies (non-entrant) at exit from the runt. system") \
duke@0 477 \
duke@0 478 notproduct(bool, WalkStackALot, false, \
duke@0 479 "trace stack (no print) at every exit from the runtime system") \
duke@0 480 \
duke@0 481 develop(bool, Debugging, false, \
duke@0 482 "set when executing debug methods in debug.ccp " \
duke@0 483 "(to prevent triggering assertions)") \
duke@0 484 \
duke@0 485 notproduct(bool, StrictSafepointChecks, trueInDebug, \
duke@0 486 "Enable strict checks that safepoints cannot happen for threads " \
duke@0 487 "that used No_Safepoint_Verifier") \
duke@0 488 \
duke@0 489 notproduct(bool, VerifyLastFrame, false, \
duke@0 490 "Verify oops on last frame on entry to VM") \
duke@0 491 \
duke@0 492 develop(bool, TraceHandleAllocation, false, \
duke@0 493 "Prints out warnings when suspicious many handles are allocated") \
duke@0 494 \
duke@0 495 product(bool, UseCompilerSafepoints, true, \
duke@0 496 "Stop at safepoints in compiled code") \
duke@0 497 \
duke@0 498 product(bool, UseSplitVerifier, true, \
duke@0 499 "use split verifier with StackMapTable attributes") \
duke@0 500 \
duke@0 501 product(bool, FailOverToOldVerifier, true, \
duke@0 502 "fail over to old verifier when split verifier fails") \
duke@0 503 \
duke@0 504 develop(bool, ShowSafepointMsgs, false, \
duke@0 505 "Show msg. about safepoint synch.") \
duke@0 506 \
duke@0 507 product(bool, SafepointTimeout, false, \
duke@0 508 "Time out and warn or fail after SafepointTimeoutDelay " \
duke@0 509 "milliseconds if failed to reach safepoint") \
duke@0 510 \
duke@0 511 develop(bool, DieOnSafepointTimeout, false, \
duke@0 512 "Die upon failure to reach safepoint (see SafepointTimeout)") \
duke@0 513 \
duke@0 514 /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */ \
duke@0 515 /* typically, at most a few retries are needed */ \
duke@0 516 product(intx, SuspendRetryCount, 50, \
duke@0 517 "Maximum retry count for an external suspend request") \
duke@0 518 \
duke@0 519 product(intx, SuspendRetryDelay, 5, \
duke@0 520 "Milliseconds to delay per retry (* current_retry_count)") \
duke@0 521 \
duke@0 522 product(bool, AssertOnSuspendWaitFailure, false, \
duke@0 523 "Assert/Guarantee on external suspend wait failure") \
duke@0 524 \
duke@0 525 product(bool, TraceSuspendWaitFailures, false, \
duke@0 526 "Trace external suspend wait failures") \
duke@0 527 \
duke@0 528 product(bool, MaxFDLimit, true, \
duke@0 529 "Bump the number of file descriptors to max in solaris.") \
duke@0 530 \
duke@0 531 notproduct(bool, LogEvents, trueInDebug, \
duke@0 532 "Enable Event log") \
duke@0 533 \
duke@0 534 product(bool, BytecodeVerificationRemote, true, \
duke@0 535 "Enables the Java bytecode verifier for remote classes") \
duke@0 536 \
duke@0 537 product(bool, BytecodeVerificationLocal, false, \
duke@0 538 "Enables the Java bytecode verifier for local classes") \
duke@0 539 \
duke@0 540 develop(bool, ForceFloatExceptions, trueInDebug, \
duke@0 541 "Force exceptions on FP stack under/overflow") \
duke@0 542 \
duke@0 543 develop(bool, SoftMatchFailure, trueInProduct, \
duke@0 544 "If the DFA fails to match a node, print a message and bail out") \
duke@0 545 \
duke@0 546 develop(bool, VerifyStackAtCalls, false, \
duke@0 547 "Verify that the stack pointer is unchanged after calls") \
duke@0 548 \
duke@0 549 develop(bool, TraceJavaAssertions, false, \
duke@0 550 "Trace java language assertions") \
duke@0 551 \
duke@0 552 notproduct(bool, CheckAssertionStatusDirectives, false, \
duke@0 553 "temporary - see javaClasses.cpp") \
duke@0 554 \
duke@0 555 notproduct(bool, PrintMallocFree, false, \
duke@0 556 "Trace calls to C heap malloc/free allocation") \
duke@0 557 \
duke@0 558 notproduct(bool, PrintOopAddress, false, \
duke@0 559 "Always print the location of the oop") \
duke@0 560 \
duke@0 561 notproduct(bool, VerifyCodeCacheOften, false, \
duke@0 562 "Verify compiled-code cache often") \
duke@0 563 \
duke@0 564 develop(bool, ZapDeadCompiledLocals, false, \
duke@0 565 "Zap dead locals in compiler frames") \
duke@0 566 \
duke@0 567 notproduct(bool, ZapDeadLocalsOld, false, \
duke@0 568 "Zap dead locals (old version, zaps all frames when " \
duke@0 569 "entering the VM") \
duke@0 570 \
duke@0 571 notproduct(bool, CheckOopishValues, false, \
duke@0 572 "Warn if value contains oop ( requires ZapDeadLocals)") \
duke@0 573 \
duke@0 574 develop(bool, UseMallocOnly, false, \
duke@0 575 "use only malloc/free for allocation (no resource area/arena)") \
duke@0 576 \
duke@0 577 develop(bool, PrintMalloc, false, \
duke@0 578 "print all malloc/free calls") \
duke@0 579 \
duke@0 580 develop(bool, ZapResourceArea, trueInDebug, \
duke@0 581 "Zap freed resource/arena space with 0xABABABAB") \
duke@0 582 \
duke@0 583 notproduct(bool, ZapVMHandleArea, trueInDebug, \
duke@0 584 "Zap freed VM handle space with 0xBCBCBCBC") \
duke@0 585 \
duke@0 586 develop(bool, ZapJNIHandleArea, trueInDebug, \
duke@0 587 "Zap freed JNI handle space with 0xFEFEFEFE") \
duke@0 588 \
jmasa@15 589 develop(bool, ZapUnusedHeapArea, false, \
duke@0 590 "Zap unused heap space with 0xBAADBABE") \
duke@0 591 \
duke@0 592 develop(bool, PrintVMMessages, true, \
duke@0 593 "Print vm messages on console") \
duke@0 594 \
duke@0 595 product(bool, PrintGCApplicationConcurrentTime, false, \
duke@0 596 "Print the time the application has been running") \
duke@0 597 \
duke@0 598 product(bool, PrintGCApplicationStoppedTime, false, \
duke@0 599 "Print the time the application has been stopped") \
duke@0 600 \
duke@0 601 develop(bool, Verbose, false, \
duke@0 602 "Prints additional debugging information from other modes") \
duke@0 603 \
duke@0 604 develop(bool, PrintMiscellaneous, false, \
duke@0 605 "Prints uncategorized debugging information (requires +Verbose)") \
duke@0 606 \
duke@0 607 develop(bool, WizardMode, false, \
duke@0 608 "Prints much more debugging information") \
duke@0 609 \
duke@0 610 product(bool, ShowMessageBoxOnError, false, \
duke@0 611 "Keep process alive on VM fatal error") \
duke@0 612 \
duke@0 613 product_pd(bool, UseOSErrorReporting, \
duke@0 614 "Let VM fatal error propagate to the OS (ie. WER on Windows)") \
duke@0 615 \
duke@0 616 product(bool, SuppressFatalErrorMessage, false, \
duke@0 617 "Do NO Fatal Error report [Avoid deadlock]") \
duke@0 618 \
duke@0 619 product(ccstrlist, OnError, "", \
duke@0 620 "Run user-defined commands on fatal error; see VMError.cpp " \
duke@0 621 "for examples") \
duke@0 622 \
duke@0 623 product(ccstrlist, OnOutOfMemoryError, "", \
duke@0 624 "Run user-defined commands on first java.lang.OutOfMemoryError") \
duke@0 625 \
duke@0 626 manageable(bool, HeapDumpOnOutOfMemoryError, false, \
duke@0 627 "Dump heap to file when java.lang.OutOfMemoryError is thrown") \
duke@0 628 \
duke@0 629 manageable(ccstr, HeapDumpPath, NULL, \
duke@0 630 "When HeapDumpOnOutOfMemoryError is on, the path (filename or" \
duke@0 631 "directory) of the dump file (defaults to java_pid<pid>.hprof" \
duke@0 632 "in the working directory)") \
duke@0 633 \
duke@0 634 develop(uintx, SegmentedHeapDumpThreshold, 2*G, \
duke@0 635 "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) " \
duke@0 636 "when the heap usage is larger than this") \
duke@0 637 \
duke@0 638 develop(uintx, HeapDumpSegmentSize, 1*G, \
duke@0 639 "Approximate segment size when generating a segmented heap dump") \
duke@0 640 \
duke@0 641 develop(bool, BreakAtWarning, false, \
duke@0 642 "Execute breakpoint upon encountering VM warning") \
duke@0 643 \
duke@0 644 product_pd(bool, UseVectoredExceptions, \
duke@0 645 "Temp Flag - Use Vectored Exceptions rather than SEH (Windows Only)") \
duke@0 646 \
duke@0 647 develop(bool, TraceVMOperation, false, \
duke@0 648 "Trace vm operations") \
duke@0 649 \
duke@0 650 develop(bool, UseFakeTimers, false, \
duke@0 651 "Tells whether the VM should use system time or a fake timer") \
duke@0 652 \
duke@0 653 diagnostic(bool, LogCompilation, false, \
duke@0 654 "Log compilation activity in detail to hotspot.log or LogFile") \
duke@0 655 \
duke@0 656 product(bool, PrintCompilation, false, \
duke@0 657 "Print compilations") \
duke@0 658 \
duke@0 659 diagnostic(bool, TraceNMethodInstalls, false, \
duke@0 660 "Trace nmethod intallation") \
duke@0 661 \
duke@0 662 diagnostic(bool, TraceOSRBreakpoint, false, \
duke@0 663 "Trace OSR Breakpoint ") \
duke@0 664 \
duke@0 665 diagnostic(bool, TraceCompileTriggered, false, \
duke@0 666 "Trace compile triggered") \
duke@0 667 \
duke@0 668 diagnostic(bool, TraceTriggers, false, \
duke@0 669 "Trace triggers") \
duke@0 670 \
duke@0 671 product(bool, AlwaysRestoreFPU, false, \
duke@0 672 "Restore the FPU control word after every JNI call (expensive)") \
duke@0 673 \
duke@0 674 notproduct(bool, PrintCompilation2, false, \
duke@0 675 "Print additional statistics per compilation") \
duke@0 676 \
duke@0 677 notproduct(bool, PrintAdapterHandlers, false, \
duke@0 678 "Print code generated for i2c/c2i adapters") \
duke@0 679 \
duke@0 680 develop(bool, PrintAssembly, false, \
duke@0 681 "Print assembly code") \
duke@0 682 \
duke@0 683 develop(bool, PrintNMethods, false, \
duke@0 684 "Print assembly code for nmethods when generated") \
duke@0 685 \
duke@0 686 develop(bool, PrintNativeNMethods, false, \
duke@0 687 "Print assembly code for native nmethods when generated") \
duke@0 688 \
duke@0 689 develop(bool, PrintDebugInfo, false, \
duke@0 690 "Print debug information for all nmethods when generated") \
duke@0 691 \
duke@0 692 develop(bool, PrintRelocations, false, \
duke@0 693 "Print relocation information for all nmethods when generated") \
duke@0 694 \
duke@0 695 develop(bool, PrintDependencies, false, \
duke@0 696 "Print dependency information for all nmethods when generated") \
duke@0 697 \
duke@0 698 develop(bool, PrintExceptionHandlers, false, \
duke@0 699 "Print exception handler tables for all nmethods when generated") \
duke@0 700 \
duke@0 701 develop(bool, InterceptOSException, false, \
duke@0 702 "Starts debugger when an implicit OS (e.g., NULL) " \
duke@0 703 "exception happens") \
duke@0 704 \
duke@0 705 notproduct(bool, PrintCodeCache, false, \
duke@0 706 "Print the compiled_code cache when exiting") \
duke@0 707 \
duke@0 708 develop(bool, PrintCodeCache2, false, \
duke@0 709 "Print detailed info on the compiled_code cache when exiting") \
duke@0 710 \
duke@0 711 develop(bool, PrintStubCode, false, \
duke@0 712 "Print generated stub code") \
duke@0 713 \
duke@0 714 product(bool, StackTraceInThrowable, true, \
duke@0 715 "Collect backtrace in throwable when exception happens") \
duke@0 716 \
duke@0 717 product(bool, OmitStackTraceInFastThrow, true, \
duke@0 718 "Omit backtraces for some 'hot' exceptions in optimized code") \
duke@0 719 \
duke@0 720 product(bool, ProfilerPrintByteCodeStatistics, false, \
duke@0 721 "Prints byte code statictics when dumping profiler output") \
duke@0 722 \
duke@0 723 product(bool, ProfilerRecordPC, false, \
duke@0 724 "Collects tick for each 16 byte interval of compiled code") \
duke@0 725 \
duke@0 726 product(bool, ProfileVM, false, \
duke@0 727 "Profiles ticks that fall within VM (either in the VM Thread " \
duke@0 728 "or VM code called through stubs)") \
duke@0 729 \
duke@0 730 product(bool, ProfileIntervals, false, \
duke@0 731 "Prints profiles for each interval (see ProfileIntervalsTicks)") \
duke@0 732 \
duke@0 733 notproduct(bool, ProfilerCheckIntervals, false, \
duke@0 734 "Collect and print info on spacing of profiler ticks") \
duke@0 735 \
duke@0 736 develop(bool, PrintJVMWarnings, false, \
duke@0 737 "Prints warnings for unimplemented JVM functions") \
duke@0 738 \
duke@0 739 notproduct(uintx, WarnOnStalledSpinLock, 0, \
duke@0 740 "Prints warnings for stalled SpinLocks") \
duke@0 741 \
duke@0 742 develop(bool, InitializeJavaLangSystem, true, \
duke@0 743 "Initialize java.lang.System - turn off for individual " \
duke@0 744 "method debugging") \
duke@0 745 \
duke@0 746 develop(bool, InitializeJavaLangString, true, \
duke@0 747 "Initialize java.lang.String - turn off for individual " \
duke@0 748 "method debugging") \
duke@0 749 \
duke@0 750 develop(bool, InitializeJavaLangExceptionsErrors, true, \
duke@0 751 "Initialize various error and exception classes - turn off for " \
duke@0 752 "individual method debugging") \
duke@0 753 \
duke@0 754 product(bool, RegisterFinalizersAtInit, true, \
duke@0 755 "Register finalizable objects at end of Object.<init> or " \
duke@0 756 "after allocation.") \
duke@0 757 \
duke@0 758 develop(bool, RegisterReferences, true, \
duke@0 759 "Tells whether the VM should register soft/weak/final/phantom " \
duke@0 760 "references") \
duke@0 761 \
duke@0 762 develop(bool, IgnoreRewrites, false, \
duke@0 763 "Supress rewrites of bytecodes in the oopmap generator. " \
duke@0 764 "This is unsafe!") \
duke@0 765 \
duke@0 766 develop(bool, PrintCodeCacheExtension, false, \
duke@0 767 "Print extension of code cache") \
duke@0 768 \
duke@0 769 develop(bool, UsePrivilegedStack, true, \
duke@0 770 "Enable the security JVM functions") \
duke@0 771 \
duke@0 772 develop(bool, IEEEPrecision, true, \
duke@0 773 "Enables IEEE precision (for INTEL only)") \
duke@0 774 \
duke@0 775 develop(bool, ProtectionDomainVerification, true, \
duke@0 776 "Verifies protection domain before resolution in system " \
duke@0 777 "dictionary") \
duke@0 778 \
duke@0 779 product(bool, ClassUnloading, true, \
duke@0 780 "Do unloading of classes") \
duke@0 781 \
duke@0 782 develop(bool, DisableStartThread, false, \
duke@0 783 "Disable starting of additional Java threads " \
duke@0 784 "(for debugging only)") \
duke@0 785 \
duke@0 786 develop(bool, MemProfiling, false, \
duke@0 787 "Write memory usage profiling to log file") \
duke@0 788 \
duke@0 789 notproduct(bool, PrintSystemDictionaryAtExit, false, \
duke@0 790 "Prints the system dictionary at exit") \
duke@0 791 \
duke@0 792 diagnostic(bool, UnsyncloadClass, false, \
duke@0 793 "Unstable: VM calls loadClass unsynchronized. Custom classloader "\
duke@0 794 "must call VM synchronized for findClass & defineClass") \
duke@0 795 \
duke@0 796 product_pd(bool, DontYieldALot, \
duke@0 797 "Throw away obvious excess yield calls (for SOLARIS only)") \
duke@0 798 \
duke@0 799 product_pd(bool, ConvertSleepToYield, \
duke@0 800 "Converts sleep(0) to thread yield " \
duke@0 801 "(may be off for SOLARIS to improve GUI)") \
duke@0 802 \
duke@0 803 product(bool, ConvertYieldToSleep, false, \
duke@0 804 "Converts yield to a sleep of MinSleepInterval to simulate Win32 "\
duke@0 805 "behavior (SOLARIS only)") \
duke@0 806 \
duke@0 807 product(bool, UseBoundThreads, true, \
duke@0 808 "Bind user level threads to kernel threads (for SOLARIS only)") \
duke@0 809 \
duke@0 810 develop(bool, UseDetachedThreads, true, \
duke@0 811 "Use detached threads that are recycled upon termination " \
duke@0 812 "(for SOLARIS only)") \
duke@0 813 \
duke@0 814 product(bool, UseLWPSynchronization, true, \
duke@0 815 "Use LWP-based instead of libthread-based synchronization " \
duke@0 816 "(SPARC only)") \
duke@0 817 \
duke@0 818 product(ccstr, SyncKnobs, "", \
duke@0 819 "(Unstable) Various monitor synchronization tunables") \
duke@0 820 \
duke@0 821 product(intx, EmitSync, 0, \
duke@0 822 "(Unsafe,Unstable) " \
duke@0 823 " Controls emission of inline sync fast-path code") \
duke@0 824 \
duke@0 825 product(intx, AlwaysInflate, 0, "(Unstable) Force inflation") \
duke@0 826 \
duke@0 827 product(intx, Atomics, 0, \
duke@0 828 "(Unsafe,Unstable) Diagnostic - Controls emission of atomics") \
duke@0 829 \
duke@0 830 product(intx, FenceInstruction, 0, \
duke@0 831 "(Unsafe,Unstable) Experimental") \
duke@0 832 \
duke@0 833 product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
duke@0 834 \
duke@0 835 product(intx, SyncVerbose, 0, "(Unstable)" ) \
duke@0 836 \
duke@0 837 product(intx, ClearFPUAtPark, 0, "(Unsafe,Unstable)" ) \
duke@0 838 \
duke@0 839 product(intx, hashCode, 0, \
duke@0 840 "(Unstable) select hashCode generation algorithm" ) \
duke@0 841 \
duke@0 842 product(intx, WorkAroundNPTLTimedWaitHang, 1, \
duke@0 843 "(Unstable, Linux-specific)" \
duke@0 844 " avoid NPTL-FUTEX hang pthread_cond_timedwait" ) \
duke@0 845 \
duke@0 846 product(bool, FilterSpuriousWakeups , true, \
duke@0 847 "Prevent spurious or premature wakeups from object.wait" \
duke@0 848 "(Solaris only)") \
duke@0 849 \
duke@0 850 product(intx, NativeMonitorTimeout, -1, "(Unstable)" ) \
duke@0 851 product(intx, NativeMonitorFlags, 0, "(Unstable)" ) \
duke@0 852 product(intx, NativeMonitorSpinLimit, 20, "(Unstable)" ) \
duke@0 853 \
duke@0 854 develop(bool, UsePthreads, false, \
duke@0 855 "Use pthread-based instead of libthread-based synchronization " \
duke@0 856 "(SPARC only)") \
duke@0 857 \
duke@0 858 product(bool, AdjustConcurrency, false, \
duke@0 859 "call thr_setconcurrency at thread create time to avoid " \
duke@0 860 "LWP starvation on MP systems (For Solaris Only)") \
duke@0 861 \
duke@0 862 develop(bool, UpdateHotSpotCompilerFileOnError, true, \
duke@0 863 "Should the system attempt to update the compiler file when " \
duke@0 864 "an error occurs?") \
duke@0 865 \
duke@0 866 product(bool, ReduceSignalUsage, false, \
duke@0 867 "Reduce the use of OS signals in Java and/or the VM") \
duke@0 868 \
duke@0 869 notproduct(bool, ValidateMarkSweep, false, \
duke@0 870 "Do extra validation during MarkSweep collection") \
duke@0 871 \
duke@0 872 notproduct(bool, RecordMarkSweepCompaction, false, \
duke@0 873 "Enable GC-to-GC recording and querying of compaction during " \
duke@0 874 "MarkSweep") \
duke@0 875 \
duke@0 876 develop_pd(bool, ShareVtableStubs, \
duke@0 877 "Share vtable stubs (smaller code but worse branch prediction") \
duke@0 878 \
duke@0 879 develop(bool, LoadLineNumberTables, true, \
duke@0 880 "Tells whether the class file parser loads line number tables") \
duke@0 881 \
duke@0 882 develop(bool, LoadLocalVariableTables, true, \
duke@0 883 "Tells whether the class file parser loads local variable tables")\
duke@0 884 \
duke@0 885 develop(bool, LoadLocalVariableTypeTables, true, \
duke@0 886 "Tells whether the class file parser loads local variable type tables")\
duke@0 887 \
duke@0 888 product(bool, AllowUserSignalHandlers, false, \
duke@0 889 "Do not complain if the application installs signal handlers " \
duke@0 890 "(Solaris & Linux only)") \
duke@0 891 \
duke@0 892 product(bool, UseSignalChaining, true, \
duke@0 893 "Use signal-chaining to invoke signal handlers installed " \
duke@0 894 "by the application (Solaris & Linux only)") \
duke@0 895 \
duke@0 896 product(bool, UseAltSigs, false, \
duke@0 897 "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM " \
duke@0 898 "internal signals. (Solaris only)") \
duke@0 899 \
duke@0 900 product(bool, UseSpinning, false, \
duke@0 901 "Use spinning in monitor inflation and before entry") \
duke@0 902 \
duke@0 903 product(bool, PreSpinYield, false, \
duke@0 904 "Yield before inner spinning loop") \
duke@0 905 \
duke@0 906 product(bool, PostSpinYield, true, \
duke@0 907 "Yield after inner spinning loop") \
duke@0 908 \
duke@0 909 product(bool, AllowJNIEnvProxy, false, \
duke@0 910 "Allow JNIEnv proxies for jdbx") \
duke@0 911 \
duke@0 912 product(bool, JNIDetachReleasesMonitors, true, \
duke@0 913 "JNI DetachCurrentThread releases monitors owned by thread") \
duke@0 914 \
duke@0 915 product(bool, RestoreMXCSROnJNICalls, false, \
duke@0 916 "Restore MXCSR when returning from JNI calls") \
duke@0 917 \
duke@0 918 product(bool, CheckJNICalls, false, \
duke@0 919 "Verify all arguments to JNI calls") \
duke@0 920 \
duke@0 921 product(bool, UseFastJNIAccessors, true, \
duke@0 922 "Use optimized versions of Get<Primitive>Field") \
duke@0 923 \
duke@0 924 product(bool, EagerXrunInit, false, \
duke@0 925 "Eagerly initialize -Xrun libraries; allows startup profiling, " \
duke@0 926 " but not all -Xrun libraries may support the state of the VM at this time") \
duke@0 927 \
duke@0 928 product(bool, PreserveAllAnnotations, false, \
duke@0 929 "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations") \
duke@0 930 \
duke@0 931 develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
duke@0 932 "Number of OutOfMemoryErrors preallocated with backtrace") \
duke@0 933 \
duke@0 934 product(bool, LazyBootClassLoader, true, \
duke@0 935 "Enable/disable lazy opening of boot class path entries") \
duke@0 936 \
duke@0 937 diagnostic(bool, UseIncDec, true, \
duke@0 938 "Use INC, DEC instructions on x86") \
duke@0 939 \
duke@0 940 product(bool, UseStoreImmI16, true, \
duke@0 941 "Use store immediate 16-bits value instruction on x86") \
duke@0 942 \
duke@0 943 product(bool, UseAddressNop, false, \
duke@0 944 "Use '0F 1F [addr]' NOP instructions on x86 cpus") \
duke@0 945 \
duke@0 946 product(bool, UseXmmLoadAndClearUpper, true, \
duke@0 947 "Load low part of XMM register and clear upper part") \
duke@0 948 \
duke@0 949 product(bool, UseXmmRegToRegMoveAll, false, \
duke@0 950 "Copy all XMM register bits when moving value between registers") \
duke@0 951 \
duke@0 952 product(intx, FieldsAllocationStyle, 1, \
duke@0 953 "0 - type based with oops first, 1 - with oops last") \
duke@0 954 \
duke@0 955 product(bool, CompactFields, true, \
duke@0 956 "Allocate nonstatic fields in gaps between previous fields") \
duke@0 957 \
duke@0 958 notproduct(bool, PrintCompactFieldsSavings, false, \
duke@0 959 "Print how many words were saved with CompactFields") \
duke@0 960 \
duke@0 961 product(bool, UseBiasedLocking, true, \
duke@0 962 "Enable biased locking in JVM") \
duke@0 963 \
duke@0 964 product(intx, BiasedLockingStartupDelay, 4000, \
duke@0 965 "Number of milliseconds to wait before enabling biased locking") \
duke@0 966 \
duke@0 967 diagnostic(bool, PrintBiasedLockingStatistics, false, \
duke@0 968 "Print statistics of biased locking in JVM") \
duke@0 969 \
duke@0 970 product(intx, BiasedLockingBulkRebiasThreshold, 20, \
duke@0 971 "Threshold of number of revocations per type to try to " \
duke@0 972 "rebias all objects in the heap of that type") \
duke@0 973 \
duke@0 974 product(intx, BiasedLockingBulkRevokeThreshold, 40, \
duke@0 975 "Threshold of number of revocations per type to permanently " \
duke@0 976 "revoke biases of all objects in the heap of that type") \
duke@0 977 \
duke@0 978 product(intx, BiasedLockingDecayTime, 25000, \
duke@0 979 "Decay time (in milliseconds) to re-enable bulk rebiasing of a " \
duke@0 980 "type after previous bulk rebias") \
duke@0 981 \
duke@0 982 /* tracing */ \
duke@0 983 \
duke@0 984 notproduct(bool, TraceRuntimeCalls, false, \
duke@0 985 "Trace run-time calls") \
duke@0 986 \
duke@0 987 develop(bool, TraceJNICalls, false, \
duke@0 988 "Trace JNI calls") \
duke@0 989 \
duke@0 990 notproduct(bool, TraceJVMCalls, false, \
duke@0 991 "Trace JVM calls") \
duke@0 992 \
duke@0 993 product(ccstr, TraceJVMTI, "", \
duke@0 994 "Trace flags for JVMTI functions and events") \
duke@0 995 \
duke@0 996 /* This option can change an EMCP method into an obsolete method. */ \
duke@0 997 /* This can affect tests that except specific methods to be EMCP. */ \
duke@0 998 /* This option should be used with caution. */ \
duke@0 999 product(bool, StressLdcRewrite, false, \
duke@0 1000 "Force ldc -> ldc_w rewrite during RedefineClasses") \
duke@0 1001 \
duke@0 1002 product(intx, TraceRedefineClasses, 0, \
duke@0 1003 "Trace level for JVMTI RedefineClasses") \
duke@0 1004 \
duke@0 1005 /* change to false by default sometime after Mustang */ \
duke@0 1006 product(bool, VerifyMergedCPBytecodes, true, \
duke@0 1007 "Verify bytecodes after RedefineClasses constant pool merging") \
duke@0 1008 \
duke@0 1009 develop(bool, TraceJNIHandleAllocation, false, \
duke@0 1010 "Trace allocation/deallocation of JNI handle blocks") \
duke@0 1011 \
duke@0 1012 develop(bool, TraceThreadEvents, false, \
duke@0 1013 "Trace all thread events") \
duke@0 1014 \
duke@0 1015 develop(bool, TraceBytecodes, false, \
duke@0 1016 "Trace bytecode execution") \
duke@0 1017 \
duke@0 1018 develop(bool, TraceClassInitialization, false, \
duke@0 1019 "Trace class initialization") \
duke@0 1020 \
duke@0 1021 develop(bool, TraceExceptions, false, \
duke@0 1022 "Trace exceptions") \
duke@0 1023 \
duke@0 1024 develop(bool, TraceICs, false, \
duke@0 1025 "Trace inline cache changes") \
duke@0 1026 \
duke@0 1027 notproduct(bool, TraceInvocationCounterOverflow, false, \
duke@0 1028 "Trace method invocation counter overflow") \
duke@0 1029 \
duke@0 1030 develop(bool, TraceInlineCacheClearing, false, \
duke@0 1031 "Trace clearing of inline caches in nmethods") \
duke@0 1032 \
duke@0 1033 develop(bool, TraceDependencies, false, \
duke@0 1034 "Trace dependencies") \
duke@0 1035 \
duke@0 1036 develop(bool, VerifyDependencies, trueInDebug, \
duke@0 1037 "Exercise and verify the compilation dependency mechanism") \
duke@0 1038 \
duke@0 1039 develop(bool, TraceNewOopMapGeneration, false, \
duke@0 1040 "Trace OopMapGeneration") \
duke@0 1041 \
duke@0 1042 develop(bool, TraceNewOopMapGenerationDetailed, false, \
duke@0 1043 "Trace OopMapGeneration: print detailed cell states") \
duke@0 1044 \
duke@0 1045 develop(bool, TimeOopMap, false, \
duke@0 1046 "Time calls to GenerateOopMap::compute_map() in sum") \
duke@0 1047 \
duke@0 1048 develop(bool, TimeOopMap2, false, \
duke@0 1049 "Time calls to GenerateOopMap::compute_map() individually") \
duke@0 1050 \
duke@0 1051 develop(bool, TraceMonitorMismatch, false, \
duke@0 1052 "Trace monitor matching failures during OopMapGeneration") \
duke@0 1053 \
duke@0 1054 develop(bool, TraceOopMapRewrites, false, \
duke@0 1055 "Trace rewritting of method oops during oop map generation") \
duke@0 1056 \
duke@0 1057 develop(bool, TraceSafepoint, false, \
duke@0 1058 "Trace safepoint operations") \
duke@0 1059 \
duke@0 1060 develop(bool, TraceICBuffer, false, \
duke@0 1061 "Trace usage of IC buffer") \
duke@0 1062 \
duke@0 1063 develop(bool, TraceCompiledIC, false, \
duke@0 1064 "Trace changes of compiled IC") \
duke@0 1065 \
duke@0 1066 notproduct(bool, TraceZapDeadLocals, false, \
duke@0 1067 "Trace zapping dead locals") \
duke@0 1068 \
duke@0 1069 develop(bool, TraceStartupTime, false, \
duke@0 1070 "Trace setup time") \
duke@0 1071 \
duke@0 1072 develop(bool, TraceHPI, false, \
duke@0 1073 "Trace Host Porting Interface (HPI)") \
duke@0 1074 \
duke@0 1075 product(ccstr, HPILibPath, NULL, \
duke@0 1076 "Specify alternate path to HPI library") \
duke@0 1077 \
duke@0 1078 develop(bool, TraceProtectionDomainVerification, false, \
duke@0 1079 "Trace protection domain verifcation") \
duke@0 1080 \
duke@0 1081 develop(bool, TraceClearedExceptions, false, \
duke@0 1082 "Prints when an exception is forcibly cleared") \
duke@0 1083 \
duke@0 1084 product(bool, TraceClassResolution, false, \
duke@0 1085 "Trace all constant pool resolutions (for debugging)") \
duke@0 1086 \
duke@0 1087 product(bool, TraceBiasedLocking, false, \
duke@0 1088 "Trace biased locking in JVM") \
duke@0 1089 \
duke@0 1090 product(bool, TraceMonitorInflation, false, \
duke@0 1091 "Trace monitor inflation in JVM") \
duke@0 1092 \
duke@0 1093 /* assembler */ \
duke@0 1094 product(bool, Use486InstrsOnly, false, \
duke@0 1095 "Use 80486 Compliant instruction subset") \
duke@0 1096 \
duke@0 1097 /* gc */ \
duke@0 1098 \
duke@0 1099 product(bool, UseSerialGC, false, \
duke@0 1100 "Tells whether the VM should use serial garbage collector") \
duke@0 1101 \
duke@0 1102 product(bool, UseParallelGC, false, \
duke@0 1103 "Use the Parallel Scavenge garbage collector") \
duke@0 1104 \
duke@0 1105 product(bool, UseParallelOldGC, false, \
duke@0 1106 "Use the Parallel Old garbage collector") \
duke@0 1107 \
duke@0 1108 product(bool, UseParallelOldGCCompacting, true, \
duke@0 1109 "In the Parallel Old garbage collector use parallel compaction") \
duke@0 1110 \
duke@0 1111 product(bool, UseParallelDensePrefixUpdate, true, \
duke@0 1112 "In the Parallel Old garbage collector use parallel dense" \
duke@0 1113 " prefix update") \
duke@0 1114 \
duke@0 1115 develop(bool, UseParallelOldGCChunkPointerCalc, true, \
duke@0 1116 "In the Parallel Old garbage collector use chucks to calculate" \
duke@0 1117 " new object locations") \
duke@0 1118 \
duke@0 1119 product(uintx, HeapMaximumCompactionInterval, 20, \
duke@0 1120 "How often should we maximally compact the heap (not allowing " \
duke@0 1121 "any dead space)") \
duke@0 1122 \
duke@0 1123 product(uintx, HeapFirstMaximumCompactionCount, 3, \
duke@0 1124 "The collection count for the first maximum compaction") \
duke@0 1125 \
duke@0 1126 product(bool, UseMaximumCompactionOnSystemGC, true, \
duke@0 1127 "In the Parallel Old garbage collector maximum compaction for " \
duke@0 1128 "a system GC") \
duke@0 1129 \
duke@0 1130 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
duke@0 1131 "The mean used by the par compact dead wood" \
duke@0 1132 "limiter (a number between 0-100).") \
duke@0 1133 \
duke@0 1134 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
duke@0 1135 "The standard deviation used by the par compact dead wood" \
duke@0 1136 "limiter (a number between 0-100).") \
duke@0 1137 \
duke@0 1138 product(bool, UseParallelOldGCDensePrefix, true, \
duke@0 1139 "Use a dense prefix with the Parallel Old garbage collector") \
duke@0 1140 \
duke@0 1141 product(uintx, ParallelGCThreads, 0, \
duke@0 1142 "Number of parallel threads parallel gc will use") \
duke@0 1143 \
duke@0 1144 product(uintx, ParallelCMSThreads, 0, \
duke@0 1145 "Max number of threads CMS will use for concurrent work") \
duke@0 1146 \
duke@0 1147 develop(bool, VerifyParallelOldWithMarkSweep, false, \
duke@0 1148 "Use the MarkSweep code to verify phases of Parallel Old") \
duke@0 1149 \
duke@0 1150 develop(uintx, VerifyParallelOldWithMarkSweepInterval, 1, \
duke@0 1151 "Interval at which the MarkSweep code is used to verify " \
duke@0 1152 "phases of Parallel Old") \
duke@0 1153 \
duke@0 1154 develop(bool, ParallelOldMTUnsafeMarkBitMap, false, \
duke@0 1155 "Use the Parallel Old MT unsafe in marking the bitmap") \
duke@0 1156 \
duke@0 1157 develop(bool, ParallelOldMTUnsafeUpdateLiveData, false, \
duke@0 1158 "Use the Parallel Old MT unsafe in update of live size") \
duke@0 1159 \
duke@0 1160 develop(bool, TraceChunkTasksQueuing, false, \
duke@0 1161 "Trace the queuing of the chunk tasks") \
duke@0 1162 \
duke@0 1163 product(uintx, YoungPLABSize, 4096, \
duke@0 1164 "Size of young gen promotion labs (in HeapWords)") \
duke@0 1165 \
duke@0 1166 product(uintx, OldPLABSize, 1024, \
duke@0 1167 "Size of old gen promotion labs (in HeapWords)") \
duke@0 1168 \
duke@0 1169 product(uintx, GCTaskTimeStampEntries, 200, \
duke@0 1170 "Number of time stamp entries per gc worker thread") \
duke@0 1171 \
duke@0 1172 product(bool, AlwaysTenure, false, \
duke@0 1173 "Always tenure objects in eden. (ParallelGC only)") \
duke@0 1174 \
duke@0 1175 product(bool, NeverTenure, false, \
duke@0 1176 "Never tenure objects in eden, May tenure on overflow" \
duke@0 1177 " (ParallelGC only)") \
duke@0 1178 \
duke@0 1179 product(bool, ScavengeBeforeFullGC, true, \
duke@0 1180 "Scavenge youngest generation before each full GC," \
duke@0 1181 " used with UseParallelGC") \
duke@0 1182 \
duke@0 1183 develop(bool, ScavengeWithObjectsInToSpace, false, \
duke@0 1184 "Allow scavenges to occur when to_space contains objects.") \
duke@0 1185 \
duke@0 1186 product(bool, UseConcMarkSweepGC, false, \
duke@0 1187 "Use Concurrent Mark-Sweep GC in the old generation") \
duke@0 1188 \
duke@0 1189 product(bool, ExplicitGCInvokesConcurrent, false, \
duke@0 1190 "A System.gc() request invokes a concurrent collection;" \
duke@0 1191 " (effective only when UseConcMarkSweepGC)") \
duke@0 1192 \
duke@0 1193 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
duke@0 1194 "A System.gc() request invokes a concurrent collection and" \
duke@0 1195 " also unloads classes during such a concurrent gc cycle " \
duke@0 1196 " (effective only when UseConcMarkSweepGC)") \
duke@0 1197 \
duke@0 1198 develop(bool, UseCMSAdaptiveFreeLists, true, \
duke@0 1199 "Use Adaptive Free Lists in the CMS generation") \
duke@0 1200 \
duke@0 1201 develop(bool, UseAsyncConcMarkSweepGC, true, \
duke@0 1202 "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
duke@0 1203 \
duke@0 1204 develop(bool, RotateCMSCollectionTypes, false, \
duke@0 1205 "Rotate the CMS collections among concurrent and STW") \
duke@0 1206 \
duke@0 1207 product(bool, UseCMSBestFit, true, \
duke@0 1208 "Use CMS best fit allocation strategy") \
duke@0 1209 \
duke@0 1210 product(bool, UseCMSCollectionPassing, true, \
duke@0 1211 "Use passing of collection from background to foreground") \
duke@0 1212 \
duke@0 1213 product(bool, UseParNewGC, false, \
duke@0 1214 "Use parallel threads in the new generation.") \
duke@0 1215 \
duke@0 1216 product(bool, ParallelGCVerbose, false, \
duke@0 1217 "Verbose output for parallel GC.") \
duke@0 1218 \
duke@0 1219 product(intx, ParallelGCBufferWastePct, 10, \
duke@0 1220 "wasted fraction of parallel allocation buffer.") \
duke@0 1221 \
duke@0 1222 product(bool, ParallelGCRetainPLAB, true, \
duke@0 1223 "Retain parallel allocation buffers across scavenges.") \
duke@0 1224 \
duke@0 1225 product(intx, TargetPLABWastePct, 10, \
duke@0 1226 "target wasted space in last buffer as pct of overall allocation")\
duke@0 1227 \
duke@0 1228 product(uintx, PLABWeight, 75, \
duke@0 1229 "Percentage (0-100) used to weight the current sample when" \
duke@0 1230 "computing exponentially decaying average for ResizePLAB.") \
duke@0 1231 \
duke@0 1232 product(bool, ResizePLAB, true, \
duke@0 1233 "Dynamically resize (survivor space) promotion labs") \
duke@0 1234 \
duke@0 1235 product(bool, PrintPLAB, false, \
duke@0 1236 "Print (survivor space) promotion labs sizing decisions") \
duke@0 1237 \
duke@0 1238 product(intx, ParGCArrayScanChunk, 50, \
duke@0 1239 "Scan a subset and push remainder, if array is bigger than this") \
duke@0 1240 \
duke@0 1241 product(intx, ParGCDesiredObjsFromOverflowList, 20, \
duke@0 1242 "The desired number of objects to claim from the overflow list") \
duke@0 1243 \
duke@0 1244 product(uintx, CMSParPromoteBlocksToClaim, 50, \
duke@0 1245 "Number of blocks to attempt to claim when refilling CMS LAB for "\
duke@0 1246 "parallel GC.") \
duke@0 1247 \
duke@0 1248 product(bool, AlwaysPreTouch, false, \
duke@0 1249 "It forces all freshly committed pages to be pre-touched.") \
duke@0 1250 \
duke@0 1251 product(bool, CMSUseOldDefaults, false, \
duke@0 1252 "A flag temporarily introduced to allow reverting to some older" \
duke@0 1253 "default settings; older as of 6.0 ") \
duke@0 1254 \
duke@0 1255 product(intx, CMSYoungGenPerWorker, 16*M, \
duke@0 1256 "The amount of young gen chosen by default per GC worker " \
duke@0 1257 "thread available ") \
duke@0 1258 \
duke@0 1259 product(bool, CMSIncrementalMode, false, \
duke@0 1260 "Whether CMS GC should operate in \"incremental\" mode") \
duke@0 1261 \
duke@0 1262 product(uintx, CMSIncrementalDutyCycle, 10, \
duke@0 1263 "CMS incremental mode duty cycle (a percentage, 0-100). If" \
duke@0 1264 "CMSIncrementalPacing is enabled, then this is just the initial" \
duke@0 1265 "value") \
duke@0 1266 \
duke@0 1267 product(bool, CMSIncrementalPacing, true, \
duke@0 1268 "Whether the CMS incremental mode duty cycle should be " \
duke@0 1269 "automatically adjusted") \
duke@0 1270 \
duke@0 1271 product(uintx, CMSIncrementalDutyCycleMin, 0, \
duke@0 1272 "Lower bound on the duty cycle when CMSIncrementalPacing is" \
duke@0 1273 "enabled (a percentage, 0-100).") \
duke@0 1274 \
duke@0 1275 product(uintx, CMSIncrementalSafetyFactor, 10, \
duke@0 1276 "Percentage (0-100) used to add conservatism when computing the" \
duke@0 1277 "duty cycle.") \
duke@0 1278 \
duke@0 1279 product(uintx, CMSIncrementalOffset, 0, \
duke@0 1280 "Percentage (0-100) by which the CMS incremental mode duty cycle" \
duke@0 1281 "is shifted to the right within the period between young GCs") \
duke@0 1282 \
duke@0 1283 product(uintx, CMSExpAvgFactor, 25, \
duke@0 1284 "Percentage (0-100) used to weight the current sample when" \
duke@0 1285 "computing exponential averages for CMS statistics.") \
duke@0 1286 \
duke@0 1287 product(uintx, CMS_FLSWeight, 50, \
duke@0 1288 "Percentage (0-100) used to weight the current sample when" \
duke@0 1289 "computing exponentially decating averages for CMS FLS statistics.") \
duke@0 1290 \
duke@0 1291 product(uintx, CMS_FLSPadding, 2, \
duke@0 1292 "The multiple of deviation from mean to use for buffering" \
duke@0 1293 "against volatility in free list demand.") \
duke@0 1294 \
duke@0 1295 product(uintx, FLSCoalescePolicy, 2, \
duke@0 1296 "CMS: Aggression level for coalescing, increasing from 0 to 4") \
duke@0 1297 \
duke@0 1298 product(uintx, CMS_SweepWeight, 50, \
duke@0 1299 "Percentage (0-100) used to weight the current sample when" \
duke@0 1300 "computing exponentially decaying average for inter-sweep duration.") \
duke@0 1301 \
duke@0 1302 product(uintx, CMS_SweepPadding, 2, \
duke@0 1303 "The multiple of deviation from mean to use for buffering" \
duke@0 1304 "against volatility in inter-sweep duration.") \
duke@0 1305 \
duke@0 1306 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
duke@0 1307 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
duke@0 1308 " duration exceeds this threhold in milliseconds") \
duke@0 1309 \
duke@0 1310 develop(bool, CMSTraceIncrementalMode, false, \
duke@0 1311 "Trace CMS incremental mode") \
duke@0 1312 \
duke@0 1313 develop(bool, CMSTraceIncrementalPacing, false, \
duke@0 1314 "Trace CMS incremental mode pacing computation") \
duke@0 1315 \
duke@0 1316 develop(bool, CMSTraceThreadState, false, \
duke@0 1317 "Trace the CMS thread state (enable the trace_state() method)") \
duke@0 1318 \
duke@0 1319 product(bool, CMSClassUnloadingEnabled, false, \
duke@0 1320 "Whether class unloading enabled when using CMS GC") \
duke@0 1321 \
ysr@94 1322 product(uintx, CMSClassUnloadingMaxInterval, 0, \
ysr@94 1323 "When CMS class unloading is enabled, the maximum CMS cycle count"\
ysr@94 1324 " for which classes may not be unloaded") \
ysr@94 1325 \
duke@0 1326 product(bool, CMSCompactWhenClearAllSoftRefs, true, \
duke@0 1327 "Compact when asked to collect CMS gen with clear_all_soft_refs") \
duke@0 1328 \
duke@0 1329 product(bool, UseCMSCompactAtFullCollection, true, \
duke@0 1330 "Use mark sweep compact at full collections") \
duke@0 1331 \
duke@0 1332 product(uintx, CMSFullGCsBeforeCompaction, 0, \
duke@0 1333 "Number of CMS full collection done before compaction if > 0") \
duke@0 1334 \
duke@0 1335 develop(intx, CMSDictionaryChoice, 0, \
duke@0 1336 "Use BinaryTreeDictionary as default in the CMS generation") \
duke@0 1337 \
duke@0 1338 product(uintx, CMSIndexedFreeListReplenish, 4, \
duke@0 1339 "Replenish and indexed free list with this number of chunks") \
duke@0 1340 \
duke@0 1341 product(bool, CMSLoopWarn, false, \
duke@0 1342 "Warn in case of excessive CMS looping") \
duke@0 1343 \
duke@0 1344 develop(bool, CMSOverflowEarlyRestoration, false, \
duke@0 1345 "Whether preserved marks should be restored early") \
duke@0 1346 \
duke@0 1347 product(uintx, CMSMarkStackSize, 32*K, \
duke@0 1348 "Size of CMS marking stack") \
duke@0 1349 \
duke@0 1350 product(uintx, CMSMarkStackSizeMax, 4*M, \
duke@0 1351 "Max size of CMS marking stack") \
duke@0 1352 \
duke@0 1353 notproduct(bool, CMSMarkStackOverflowALot, false, \
duke@0 1354 "Whether we should simulate frequent marking stack / work queue" \
duke@0 1355 " overflow") \
duke@0 1356 \
duke@0 1357 notproduct(intx, CMSMarkStackOverflowInterval, 1000, \
duke@0 1358 "A per-thread `interval' counter that determines how frequently" \
duke@0 1359 " we simulate overflow; a smaller number increases frequency") \
duke@0 1360 \
duke@0 1361 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
duke@0 1362 "(Temporary, subject to experimentation)" \
duke@0 1363 "Maximum number of abortable preclean iterations, if > 0") \
duke@0 1364 \
duke@0 1365 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
duke@0 1366 "(Temporary, subject to experimentation)" \
duke@0 1367 "Maximum time in abortable preclean in ms") \
duke@0 1368 \
duke@0 1369 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
duke@0 1370 "(Temporary, subject to experimentation)" \
duke@0 1371 "Nominal minimum work per abortable preclean iteration") \
duke@0 1372 \
duke@0 1373 product(intx, CMSAbortablePrecleanWaitMillis, 100, \
duke@0 1374 "(Temporary, subject to experimentation)" \
duke@0 1375 " Time that we sleep between iterations when not given" \
duke@0 1376 " enough work per iteration") \
duke@0 1377 \
duke@0 1378 product(uintx, CMSRescanMultiple, 32, \
duke@0 1379 "Size (in cards) of CMS parallel rescan task") \
duke@0 1380 \
duke@0 1381 product(uintx, CMSConcMarkMultiple, 32, \
duke@0 1382 "Size (in cards) of CMS concurrent MT marking task") \
duke@0 1383 \
duke@0 1384 product(uintx, CMSRevisitStackSize, 1*M, \
duke@0 1385 "Size of CMS KlassKlass revisit stack") \
duke@0 1386 \
duke@0 1387 product(bool, CMSAbortSemantics, false, \
duke@0 1388 "Whether abort-on-overflow semantics is implemented") \
duke@0 1389 \
duke@0 1390 product(bool, CMSParallelRemarkEnabled, true, \
duke@0 1391 "Whether parallel remark enabled (only if ParNewGC)") \
duke@0 1392 \
duke@0 1393 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
duke@0 1394 "Whether parallel remark of survivor space" \
duke@0 1395 " enabled (effective only if CMSParallelRemarkEnabled)") \
duke@0 1396 \
duke@0 1397 product(bool, CMSPLABRecordAlways, true, \
duke@0 1398 "Whether to always record survivor space PLAB bdries" \
duke@0 1399 " (effective only if CMSParallelSurvivorRemarkEnabled)") \
duke@0 1400 \
duke@0 1401 product(bool, CMSConcurrentMTEnabled, true, \
duke@0 1402 "Whether multi-threaded concurrent work enabled (if ParNewGC)") \
duke@0 1403 \
duke@0 1404 product(bool, CMSPermGenPrecleaningEnabled, true, \
duke@0 1405 "Whether concurrent precleaning enabled in perm gen" \
duke@0 1406 " (effective only when CMSPrecleaningEnabled is true)") \
duke@0 1407 \
duke@0 1408 product(bool, CMSPrecleaningEnabled, true, \
duke@0 1409 "Whether concurrent precleaning enabled") \
duke@0 1410 \
duke@0 1411 product(uintx, CMSPrecleanIter, 3, \
duke@0 1412 "Maximum number of precleaning iteration passes") \
duke@0 1413 \
duke@0 1414 product(uintx, CMSPrecleanNumerator, 2, \
duke@0 1415 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
duke@0 1416 " ratio") \
duke@0 1417 \
duke@0 1418 product(uintx, CMSPrecleanDenominator, 3, \
duke@0 1419 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
duke@0 1420 " ratio") \
duke@0 1421 \
duke@0 1422 product(bool, CMSPrecleanRefLists1, true, \
duke@0 1423 "Preclean ref lists during (initial) preclean phase") \
duke@0 1424 \
duke@0 1425 product(bool, CMSPrecleanRefLists2, false, \
duke@0 1426 "Preclean ref lists during abortable preclean phase") \
duke@0 1427 \
duke@0 1428 product(bool, CMSPrecleanSurvivors1, false, \
duke@0 1429 "Preclean survivors during (initial) preclean phase") \
duke@0 1430 \
duke@0 1431 product(bool, CMSPrecleanSurvivors2, true, \
duke@0 1432 "Preclean survivors during abortable preclean phase") \
duke@0 1433 \
duke@0 1434 product(uintx, CMSPrecleanThreshold, 1000, \
duke@0 1435 "Don't re-iterate if #dirty cards less than this") \
duke@0 1436 \
duke@0 1437 product(bool, CMSCleanOnEnter, true, \
duke@0 1438 "Clean-on-enter optimization for reducing number of dirty cards") \
duke@0 1439 \
duke@0 1440 product(uintx, CMSRemarkVerifyVariant, 1, \
duke@0 1441 "Choose variant (1,2) of verification following remark") \
duke@0 1442 \
duke@0 1443 product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
duke@0 1444 "If Eden used is below this value, don't try to schedule remark") \
duke@0 1445 \
duke@0 1446 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
duke@0 1447 "The Eden occupancy % at which to try and schedule remark pause") \
duke@0 1448 \
duke@0 1449 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
duke@0 1450 "Start sampling Eden top at least before yg occupancy reaches" \
duke@0 1451 " 1/<ratio> of the size at which we plan to schedule remark") \
duke@0 1452 \
duke@0 1453 product(uintx, CMSSamplingGrain, 16*K, \
duke@0 1454 "The minimum distance between eden samples for CMS (see above)") \
duke@0 1455 \
duke@0 1456 product(bool, CMSScavengeBeforeRemark, false, \
duke@0 1457 "Attempt scavenge before the CMS remark step") \
duke@0 1458 \
duke@0 1459 develop(bool, CMSTraceSweeper, false, \
duke@0 1460 "Trace some actions of the CMS sweeper") \
duke@0 1461 \
duke@0 1462 product(uintx, CMSWorkQueueDrainThreshold, 10, \
duke@0 1463 "Don't drain below this size per parallel worker/thief") \
duke@0 1464 \
duke@0 1465 product(intx, CMSWaitDuration, 2000, \
duke@0 1466 "Time in milliseconds that CMS thread waits for young GC") \
duke@0 1467 \
duke@0 1468 product(bool, CMSYield, true, \
duke@0 1469 "Yield between steps of concurrent mark & sweep") \
duke@0 1470 \
duke@0 1471 product(uintx, CMSBitMapYieldQuantum, 10*M, \
duke@0 1472 "Bitmap operations should process at most this many bits" \
duke@0 1473 "between yields") \
duke@0 1474 \
duke@0 1475 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
duke@0 1476 "Verify that all refs across the FLS boundary " \
duke@0 1477 " are to valid objects") \
duke@0 1478 \
duke@0 1479 diagnostic(bool, FLSVerifyLists, false, \
duke@0 1480 "Do lots of (expensive) FreeListSpace verification") \
duke@0 1481 \
duke@0 1482 diagnostic(bool, FLSVerifyIndexTable, false, \
duke@0 1483 "Do lots of (expensive) FLS index table verification") \
duke@0 1484 \
duke@0 1485 develop(bool, FLSVerifyDictionary, false, \
duke@0 1486 "Do lots of (expensive) FLS dictionary verification") \
duke@0 1487 \
duke@0 1488 develop(bool, VerifyBlockOffsetArray, false, \
duke@0 1489 "Do (expensive!) block offset array verification") \
duke@0 1490 \
duke@0 1491 product(bool, BlockOffsetArrayUseUnallocatedBlock, trueInDebug, \
duke@0 1492 "Maintain _unallocated_block in BlockOffsetArray" \
duke@0 1493 " (currently applicable only to CMS collector)") \
duke@0 1494 \
duke@0 1495 develop(bool, TraceCMSState, false, \
duke@0 1496 "Trace the state of the CMS collection") \
duke@0 1497 \
duke@0 1498 product(intx, RefDiscoveryPolicy, 0, \
duke@0 1499 "Whether reference-based(0) or referent-based(1)") \
duke@0 1500 \
duke@0 1501 product(bool, ParallelRefProcEnabled, false, \
duke@0 1502 "Enable parallel reference processing whenever possible") \
duke@0 1503 \
duke@0 1504 product(bool, ParallelRefProcBalancingEnabled, true, \
duke@0 1505 "Enable balancing of reference processing queues") \
duke@0 1506 \
duke@0 1507 product(intx, CMSTriggerRatio, 80, \
duke@0 1508 "Percentage of MinHeapFreeRatio in CMS generation that is " \
duke@0 1509 " allocated before a CMS collection cycle commences") \
duke@0 1510 \
ysr@94 1511 product(intx, CMSTriggerPermRatio, 80, \
ysr@94 1512 "Percentage of MinHeapFreeRatio in the CMS perm generation that" \
ysr@94 1513 " is allocated before a CMS collection cycle commences, that " \
ysr@94 1514 " also collects the perm generation") \
ysr@94 1515 \
ysr@94 1516 product(uintx, CMSBootstrapOccupancy, 50, \
duke@0 1517 "Percentage CMS generation occupancy at which to " \
duke@0 1518 " initiate CMS collection for bootstrapping collection stats") \
duke@0 1519 \
duke@0 1520 product(intx, CMSInitiatingOccupancyFraction, -1, \
duke@0 1521 "Percentage CMS generation occupancy to start a CMS collection " \
ysr@94 1522 " cycle (A negative value means that CMSTriggerRatio is used)") \
ysr@94 1523 \
ysr@94 1524 product(intx, CMSInitiatingPermOccupancyFraction, -1, \
ysr@94 1525 "Percentage CMS perm generation occupancy to start a CMScollection"\
ysr@94 1526 " cycle (A negative value means that CMSTriggerPermRatio is used)")\
duke@0 1527 \
duke@0 1528 product(bool, UseCMSInitiatingOccupancyOnly, false, \
duke@0 1529 "Only use occupancy as a crierion for starting a CMS collection") \
duke@0 1530 \
ysr@94 1531 product(intx, CMSIsTooFullPercentage, 98, \
ysr@94 1532 "An absolute ceiling above which CMS will always consider the" \
ysr@94 1533 " perm gen ripe for collection") \
ysr@94 1534 \
duke@0 1535 develop(bool, CMSTestInFreeList, false, \
duke@0 1536 "Check if the coalesced range is already in the " \
duke@0 1537 "free lists as claimed.") \
duke@0 1538 \
duke@0 1539 notproduct(bool, CMSVerifyReturnedBytes, false, \
duke@0 1540 "Check that all the garbage collected was returned to the " \
duke@0 1541 "free lists.") \
duke@0 1542 \
duke@0 1543 notproduct(bool, ScavengeALot, false, \
duke@0 1544 "Force scavenge at every Nth exit from the runtime system " \
duke@0 1545 "(N=ScavengeALotInterval)") \
duke@0 1546 \
duke@0 1547 develop(bool, FullGCALot, false, \
duke@0 1548 "Force full gc at every Nth exit from the runtime system " \
duke@0 1549 "(N=FullGCALotInterval)") \
duke@0 1550 \
duke@0 1551 notproduct(bool, GCALotAtAllSafepoints, false, \
duke@0 1552 "Enforce ScavengeALot/GCALot at all potential safepoints") \
duke@0 1553 \
duke@0 1554 product(bool, HandlePromotionFailure, true, \
duke@0 1555 "The youngest generation collection does not require" \
duke@0 1556 " a guarantee of full promotion of all live objects.") \
duke@0 1557 \
duke@0 1558 notproduct(bool, PromotionFailureALot, false, \
duke@0 1559 "Use promotion failure handling on every youngest generation " \
duke@0 1560 "collection") \
duke@0 1561 \
duke@0 1562 develop(uintx, PromotionFailureALotCount, 1000, \
duke@0 1563 "Number of promotion failures occurring at ParGCAllocBuffer" \
duke@0 1564 "refill attempts (ParNew) or promotion attempts " \
duke@0 1565 "(other young collectors) ") \
duke@0 1566 \
duke@0 1567 develop(uintx, PromotionFailureALotInterval, 5, \
duke@0 1568 "Total collections between promotion failures alot") \
duke@0 1569 \
duke@0 1570 develop(intx, WorkStealingSleepMillis, 1, \
duke@0 1571 "Sleep time when sleep is used for yields") \
duke@0 1572 \
duke@0 1573 develop(uintx, WorkStealingYieldsBeforeSleep, 1000, \
duke@0 1574 "Number of yields before a sleep is done during workstealing") \
duke@0 1575 \
duke@0 1576 product(uintx, PreserveMarkStackSize, 40, \
duke@0 1577 "Size for stack used in promotion failure handling") \
duke@0 1578 \
duke@0 1579 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
duke@0 1580 \
duke@0 1581 product_pd(bool, ResizeTLAB, \
duke@0 1582 "Dynamically resize tlab size for threads") \
duke@0 1583 \
duke@0 1584 product(bool, ZeroTLAB, false, \
duke@0 1585 "Zero out the newly created TLAB") \
duke@0 1586 \
duke@0 1587 product(bool, PrintTLAB, false, \
duke@0 1588 "Print various TLAB related information") \
duke@0 1589 \
duke@0 1590 product(bool, TLABStats, true, \
duke@0 1591 "Print various TLAB related information") \
duke@0 1592 \
duke@0 1593 product_pd(bool, NeverActAsServerClassMachine, \
duke@0 1594 "Never act like a server-class machine") \
duke@0 1595 \
duke@0 1596 product(bool, AlwaysActAsServerClassMachine, false, \
duke@0 1597 "Always act like a server-class machine") \
duke@0 1598 \
duke@0 1599 product_pd(uintx, DefaultMaxRAM, \
duke@0 1600 "Maximum real memory size for setting server class heap size") \
duke@0 1601 \
duke@0 1602 product(uintx, DefaultMaxRAMFraction, 4, \
duke@0 1603 "Fraction (1/n) of real memory used for server class max heap") \
duke@0 1604 \
duke@0 1605 product(uintx, DefaultInitialRAMFraction, 64, \
duke@0 1606 "Fraction (1/n) of real memory used for server class initial heap") \
duke@0 1607 \
duke@0 1608 product(bool, UseAutoGCSelectPolicy, false, \
duke@0 1609 "Use automatic collection selection policy") \
duke@0 1610 \
duke@0 1611 product(uintx, AutoGCSelectPauseMillis, 5000, \
duke@0 1612 "Automatic GC selection pause threshhold in ms") \
duke@0 1613 \
duke@0 1614 product(bool, UseAdaptiveSizePolicy, true, \
duke@0 1615 "Use adaptive generation sizing policies") \
duke@0 1616 \
duke@0 1617 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
duke@0 1618 "Use adaptive survivor sizing policies") \
duke@0 1619 \
duke@0 1620 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
duke@0 1621 "Use adaptive young-old sizing policies at minor collections") \
duke@0 1622 \
duke@0 1623 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
duke@0 1624 "Use adaptive young-old sizing policies at major collections") \
duke@0 1625 \
duke@0 1626 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
duke@0 1627 "Use statistics from System.GC for adaptive size policy") \
duke@0 1628 \
duke@0 1629 product(bool, UseAdaptiveGCBoundary, false, \
duke@0 1630 "Allow young-old boundary to move") \
duke@0 1631 \
duke@0 1632 develop(bool, TraceAdaptiveGCBoundary, false, \
duke@0 1633 "Trace young-old boundary moves") \
duke@0 1634 \
duke@0 1635 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
duke@0 1636 "Resize the virtual spaces of the young or old generations") \
duke@0 1637 \
duke@0 1638 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
duke@0 1639 "Policy for changeing generation size for throughput goals") \
duke@0 1640 \
duke@0 1641 product(uintx, AdaptiveSizePausePolicy, 0, \
duke@0 1642 "Policy for changing generation size for pause goals") \
duke@0 1643 \
duke@0 1644 develop(bool, PSAdjustTenuredGenForMinorPause, false, \
duke@0 1645 "Adjust tenured generation to achive a minor pause goal") \
duke@0 1646 \
duke@0 1647 develop(bool, PSAdjustYoungGenForMajorPause, false, \
duke@0 1648 "Adjust young generation to achive a major pause goal") \
duke@0 1649 \
duke@0 1650 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
duke@0 1651 "Number of steps where heuristics is used before data is used") \
duke@0 1652 \
duke@0 1653 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
duke@0 1654 "Number of collections before the adaptive sizing is started") \
duke@0 1655 \
duke@0 1656 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
duke@0 1657 "Collecton interval for printing information, zero => never") \
duke@0 1658 \
duke@0 1659 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
duke@0 1660 "Use adaptive minimum footprint as a goal") \
duke@0 1661 \
duke@0 1662 product(uintx, AdaptiveSizePolicyWeight, 10, \
duke@0 1663 "Weight given to exponential resizing, between 0 and 100") \
duke@0 1664 \
duke@0 1665 product(uintx, AdaptiveTimeWeight, 25, \
duke@0 1666 "Weight given to time in adaptive policy, between 0 and 100") \
duke@0 1667 \
duke@0 1668 product(uintx, PausePadding, 1, \
duke@0 1669 "How much buffer to keep for pause time") \
duke@0 1670 \
duke@0 1671 product(uintx, PromotedPadding, 3, \
duke@0 1672 "How much buffer to keep for promotion failure") \
duke@0 1673 \
duke@0 1674 product(uintx, SurvivorPadding, 3, \
duke@0 1675 "How much buffer to keep for survivor overflow") \
duke@0 1676 \
duke@0 1677 product(uintx, AdaptivePermSizeWeight, 20, \
duke@0 1678 "Weight for perm gen exponential resizing, between 0 and 100") \
duke@0 1679 \
duke@0 1680 product(uintx, PermGenPadding, 3, \
duke@0 1681 "How much buffer to keep for perm gen sizing") \
duke@0 1682 \
duke@0 1683 product(uintx, ThresholdTolerance, 10, \
duke@0 1684 "Allowed collection cost difference between generations") \
duke@0 1685 \
duke@0 1686 product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
duke@0 1687 "If collection costs are within margin, reduce both by full delta") \
duke@0 1688 \
duke@0 1689 product(uintx, YoungGenerationSizeIncrement, 20, \
duke@0 1690 "Adaptive size percentage change in young generation") \
duke@0 1691 \
duke@0 1692 product(uintx, YoungGenerationSizeSupplement, 80, \
duke@0 1693 "Supplement to YoungedGenerationSizeIncrement used at startup") \
duke@0 1694 \
duke@0 1695 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
duke@0 1696 "Decay factor to YoungedGenerationSizeSupplement") \
duke@0 1697 \
duke@0 1698 product(uintx, TenuredGenerationSizeIncrement, 20, \
duke@0 1699 "Adaptive size percentage change in tenured generation") \
duke@0 1700 \
duke@0 1701 product(uintx, TenuredGenerationSizeSupplement, 80, \
duke@0 1702 "Supplement to TenuredGenerationSizeIncrement used at startup") \
duke@0 1703 \
duke@0 1704 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
duke@0 1705 "Decay factor to TenuredGenerationSizeIncrement") \
duke@0 1706 \
duke@0 1707 product(uintx, MaxGCPauseMillis, max_uintx, \
duke@0 1708 "Adaptive size policy maximum GC pause time goal in msec") \
duke@0 1709 \
duke@0 1710 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
duke@0 1711 "Adaptive size policy maximum GC minor pause time goal in msec") \
duke@0 1712 \
duke@0 1713 product(uintx, GCTimeRatio, 99, \
duke@0 1714 "Adaptive size policy application time to GC time ratio") \
duke@0 1715 \
duke@0 1716 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
duke@0 1717 "Adaptive size scale down factor for shrinking") \
duke@0 1718 \
duke@0 1719 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
duke@0 1720 "Adaptive size decays the major cost for long major intervals") \
duke@0 1721 \
duke@0 1722 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
duke@0 1723 "Time scale over which major costs decay") \
duke@0 1724 \
duke@0 1725 product(uintx, MinSurvivorRatio, 3, \
duke@0 1726 "Minimum ratio of young generation/survivor space size") \
duke@0 1727 \
duke@0 1728 product(uintx, InitialSurvivorRatio, 8, \
duke@0 1729 "Initial ratio of eden/survivor space size") \
duke@0 1730 \
duke@0 1731 product(uintx, BaseFootPrintEstimate, 256*M, \
duke@0 1732 "Estimate of footprint other than Java Heap") \
duke@0 1733 \
duke@0 1734 product(bool, UseGCOverheadLimit, true, \
duke@0 1735 "Use policy to limit of proportion of time spent in GC " \
duke@0 1736 "before an OutOfMemory error is thrown") \
duke@0 1737 \
duke@0 1738 product(uintx, GCTimeLimit, 98, \
duke@0 1739 "Limit of proportion of time spent in GC before an OutOfMemory" \
duke@0 1740 "error is thrown (used with GCHeapFreeLimit)") \
duke@0 1741 \
duke@0 1742 product(uintx, GCHeapFreeLimit, 2, \
duke@0 1743 "Minimum percentage of free space after a full GC before an " \
duke@0 1744 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
duke@0 1745 \
duke@0 1746 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
duke@0 1747 "Number of consecutive collections before gc time limit fires") \
duke@0 1748 \
duke@0 1749 product(bool, PrintAdaptiveSizePolicy, false, \
duke@0 1750 "Print information about AdaptiveSizePolicy") \
duke@0 1751 \
duke@0 1752 product(intx, PrefetchCopyIntervalInBytes, -1, \
duke@0 1753 "How far ahead to prefetch destination area (<= 0 means off)") \
duke@0 1754 \
duke@0 1755 product(intx, PrefetchScanIntervalInBytes, -1, \
duke@0 1756 "How far ahead to prefetch scan area (<= 0 means off)") \
duke@0 1757 \
duke@0 1758 product(intx, PrefetchFieldsAhead, -1, \
duke@0 1759 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
duke@0 1760 \
duke@0 1761 develop(bool, UsePrefetchQueue, true, \
duke@0 1762 "Use the prefetch queue during PS promotion") \
duke@0 1763 \
duke@0 1764 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
duke@0 1765 "Verify system before exiting") \
duke@0 1766 \
duke@0 1767 diagnostic(bool, VerifyBeforeGC, false, \
duke@0 1768 "Verify memory system before GC") \
duke@0 1769 \
duke@0 1770 diagnostic(bool, VerifyAfterGC, false, \
duke@0 1771 "Verify memory system after GC") \
duke@0 1772 \
duke@0 1773 diagnostic(bool, VerifyDuringGC, false, \
duke@0 1774 "Verify memory system during GC (between phases)") \
duke@0 1775 \
duke@0 1776 diagnostic(bool, VerifyRememberedSets, false, \
duke@0 1777 "Verify GC remembered sets") \
duke@0 1778 \
duke@0 1779 diagnostic(bool, VerifyObjectStartArray, true, \
duke@0 1780 "Verify GC object start array if verify before/after") \
duke@0 1781 \
duke@0 1782 product(bool, DisableExplicitGC, false, \
duke@0 1783 "Tells whether calling System.gc() does a full GC") \
duke@0 1784 \
duke@0 1785 notproduct(bool, CheckMemoryInitialization, false, \
duke@0 1786 "Checks memory initialization") \
duke@0 1787 \
duke@0 1788 product(bool, CollectGen0First, false, \
duke@0 1789 "Collect youngest generation before each full GC") \
duke@0 1790 \
duke@0 1791 diagnostic(bool, BindCMSThreadToCPU, false, \
duke@0 1792 "Bind CMS Thread to CPU if possible") \
duke@0 1793 \
duke@0 1794 diagnostic(uintx, CPUForCMSThread, 0, \
duke@0 1795 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
duke@0 1796 \
duke@0 1797 product(bool, BindGCTaskThreadsToCPUs, false, \
duke@0 1798 "Bind GCTaskThreads to CPUs if possible") \
duke@0 1799 \
duke@0 1800 product(bool, UseGCTaskAffinity, false, \
duke@0 1801 "Use worker affinity when asking for GCTasks") \
duke@0 1802 \
duke@0 1803 product(uintx, ProcessDistributionStride, 4, \
duke@0 1804 "Stride through processors when distributing processes") \
duke@0 1805 \
duke@0 1806 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
duke@0 1807 "number of times the coordinator GC thread will sleep while " \
duke@0 1808 "yielding before giving up and resuming GC") \
duke@0 1809 \
duke@0 1810 product(uintx, CMSYieldSleepCount, 0, \
duke@0 1811 "number of times a GC thread (minus the coordinator) " \
duke@0 1812 "will sleep while yielding before giving up and resuming GC") \
duke@0 1813 \
jmasa@10 1814 notproduct(bool, PrintFlagsFinal, false, \
jmasa@10 1815 "Print all command line flags after argument processing") \
jmasa@10 1816 \
duke@0 1817 /* gc tracing */ \
duke@0 1818 manageable(bool, PrintGC, false, \
duke@0 1819 "Print message at garbage collect") \
duke@0 1820 \
duke@0 1821 manageable(bool, PrintGCDetails, false, \
duke@0 1822 "Print more details at garbage collect") \
duke@0 1823 \
duke@0 1824 manageable(bool, PrintGCDateStamps, false, \
duke@0 1825 "Print date stamps at garbage collect") \
duke@0 1826 \
duke@0 1827 manageable(bool, PrintGCTimeStamps, false, \
duke@0 1828 "Print timestamps at garbage collect") \
duke@0 1829 \
duke@0 1830 product(bool, PrintGCTaskTimeStamps, false, \
duke@0 1831 "Print timestamps for individual gc worker thread tasks") \
duke@0 1832 \
duke@0 1833 develop(intx, ConcGCYieldTimeout, 0, \
duke@0 1834 "If non-zero, assert that GC threads yield within this # of ms.") \
duke@0 1835 \
duke@0 1836 notproduct(bool, TraceMarkSweep, false, \
duke@0 1837 "Trace mark sweep") \
duke@0 1838 \
duke@0 1839 product(bool, PrintReferenceGC, false, \
duke@0 1840 "Print times spent handling reference objects during GC " \
duke@0 1841 " (enabled only when PrintGCDetails)") \
duke@0 1842 \
duke@0 1843 develop(bool, TraceReferenceGC, false, \
duke@0 1844 "Trace handling of soft/weak/final/phantom references") \
duke@0 1845 \
duke@0 1846 develop(bool, TraceFinalizerRegistration, false, \
duke@0 1847 "Trace registration of final references") \
duke@0 1848 \
duke@0 1849 notproduct(bool, TraceScavenge, false, \
duke@0 1850 "Trace scavenge") \
duke@0 1851 \
duke@0 1852 product_rw(bool, TraceClassLoading, false, \
duke@0 1853 "Trace all classes loaded") \
duke@0 1854 \
duke@0 1855 product(bool, TraceClassLoadingPreorder, false, \
duke@0 1856 "Trace all classes loaded in order referenced (not loaded)") \
duke@0 1857 \
duke@0 1858 product_rw(bool, TraceClassUnloading, false, \
duke@0 1859 "Trace unloading of classes") \
duke@0 1860 \
duke@0 1861 product_rw(bool, TraceLoaderConstraints, false, \
duke@0 1862 "Trace loader constraints") \
duke@0 1863 \
duke@0 1864 product(bool, TraceGen0Time, false, \
duke@0 1865 "Trace accumulated time for Gen 0 collection") \
duke@0 1866 \
duke@0 1867 product(bool, TraceGen1Time, false, \
duke@0 1868 "Trace accumulated time for Gen 1 collection") \
duke@0 1869 \
duke@0 1870 product(bool, PrintTenuringDistribution, false, \
duke@0 1871 "Print tenuring age information") \
duke@0 1872 \
duke@0 1873 product_rw(bool, PrintHeapAtGC, false, \
duke@0 1874 "Print heap layout before and after each GC") \
duke@0 1875 \
duke@0 1876 product(bool, PrintHeapAtSIGBREAK, true, \
duke@0 1877 "Print heap layout in response to SIGBREAK") \
duke@0 1878 \
duke@0 1879 manageable(bool, PrintClassHistogram, false, \
duke@0 1880 "Print a histogram of class instances") \
duke@0 1881 \
duke@0 1882 develop(bool, TraceWorkGang, false, \
duke@0 1883 "Trace activities of work gangs") \
duke@0 1884 \
duke@0 1885 product(bool, TraceParallelOldGCTasks, false, \
duke@0 1886 "Trace multithreaded GC activity") \
duke@0 1887 \
duke@0 1888 develop(bool, TraceBlockOffsetTable, false, \
duke@0 1889 "Print BlockOffsetTable maps") \
duke@0 1890 \
duke@0 1891 develop(bool, TraceCardTableModRefBS, false, \
duke@0 1892 "Print CardTableModRefBS maps") \
duke@0 1893 \
duke@0 1894 develop(bool, TraceGCTaskManager, false, \
duke@0 1895 "Trace actions of the GC task manager") \
duke@0 1896 \
duke@0 1897 develop(bool, TraceGCTaskQueue, false, \
duke@0 1898 "Trace actions of the GC task queues") \
duke@0 1899 \
duke@0 1900 develop(bool, TraceGCTaskThread, false, \
duke@0 1901 "Trace actions of the GC task threads") \
duke@0 1902 \
duke@0 1903 product(bool, PrintParallelOldGCPhaseTimes, false, \
duke@0 1904 "Print the time taken by each parallel old gc phase." \
duke@0 1905 "PrintGCDetails must also be enabled.") \
duke@0 1906 \
duke@0 1907 develop(bool, TraceParallelOldGCMarkingPhase, false, \
duke@0 1908 "Trace parallel old gc marking phase") \
duke@0 1909 \
duke@0 1910 develop(bool, TraceParallelOldGCSummaryPhase, false, \
duke@0 1911 "Trace parallel old gc summary phase") \
duke@0 1912 \
duke@0 1913 develop(bool, TraceParallelOldGCCompactionPhase, false, \
duke@0 1914 "Trace parallel old gc compaction phase") \
duke@0 1915 \
duke@0 1916 develop(bool, TraceParallelOldGCDensePrefix, false, \
duke@0 1917 "Trace parallel old gc dense prefix computation") \
duke@0 1918 \
duke@0 1919 develop(bool, IgnoreLibthreadGPFault, false, \
duke@0 1920 "Suppress workaround for libthread GP fault") \
duke@0 1921 \
duke@0 1922 /* JVMTI heap profiling */ \
duke@0 1923 \
duke@0 1924 diagnostic(bool, TraceJVMTIObjectTagging, false, \
duke@0 1925 "Trace JVMTI object tagging calls") \
duke@0 1926 \
duke@0 1927 diagnostic(bool, VerifyBeforeIteration, false, \
duke@0 1928 "Verify memory system before JVMTI iteration") \
duke@0 1929 \
duke@0 1930 /* compiler interface */ \
duke@0 1931 \
duke@0 1932 develop(bool, CIPrintCompilerName, false, \
duke@0 1933 "when CIPrint is active, print the name of the active compiler") \
duke@0 1934 \
duke@0 1935 develop(bool, CIPrintCompileQueue, false, \
duke@0 1936 "display the contents of the compile queue whenever a " \
duke@0 1937 "compilation is enqueued") \
duke@0 1938 \
duke@0 1939 develop(bool, CIPrintRequests, false, \
duke@0 1940 "display every request for compilation") \
duke@0 1941 \
duke@0 1942 product(bool, CITime, false, \
duke@0 1943 "collect timing information for compilation") \
duke@0 1944 \
duke@0 1945 develop(bool, CITimeEach, false, \
duke@0 1946 "display timing information after each successful compilation") \
duke@0 1947 \
duke@0 1948 develop(bool, CICountOSR, true, \
duke@0 1949 "use a separate counter when assigning ids to osr compilations") \
duke@0 1950 \
duke@0 1951 develop(bool, CICompileNatives, true, \
duke@0 1952 "compile native methods if supported by the compiler") \
duke@0 1953 \
duke@0 1954 develop_pd(bool, CICompileOSR, \
duke@0 1955 "compile on stack replacement methods if supported by the " \
duke@0 1956 "compiler") \
duke@0 1957 \
duke@0 1958 develop(bool, CIPrintMethodCodes, false, \
duke@0 1959 "print method bytecodes of the compiled code") \
duke@0 1960 \
duke@0 1961 develop(bool, CIPrintTypeFlow, false, \
duke@0 1962 "print the results of ciTypeFlow analysis") \
duke@0 1963 \
duke@0 1964 develop(bool, CITraceTypeFlow, false, \
duke@0 1965 "detailed per-bytecode tracing of ciTypeFlow analysis") \
duke@0 1966 \
duke@0 1967 develop(intx, CICloneLoopTestLimit, 100, \
duke@0 1968 "size limit for blocks heuristically cloned in ciTypeFlow") \
duke@0 1969 \
duke@0 1970 /* temp diagnostics */ \
duke@0 1971 \
duke@0 1972 diagnostic(bool, TraceRedundantCompiles, false, \
duke@0 1973 "Have compile broker print when a request already in the queue is"\
duke@0 1974 " requested again") \
duke@0 1975 \
duke@0 1976 diagnostic(bool, InitialCompileFast, false, \
duke@0 1977 "Initial compile at CompLevel_fast_compile") \
duke@0 1978 \
duke@0 1979 diagnostic(bool, InitialCompileReallyFast, false, \
duke@0 1980 "Initial compile at CompLevel_really_fast_compile (no profile)") \
duke@0 1981 \
duke@0 1982 diagnostic(bool, FullProfileOnReInterpret, true, \
duke@0 1983 "On re-interpret unc-trap compile next at CompLevel_fast_compile")\
duke@0 1984 \
duke@0 1985 /* compiler */ \
duke@0 1986 \
duke@0 1987 product(intx, CICompilerCount, CI_COMPILER_COUNT, \
duke@0 1988 "Number of compiler threads to run") \
duke@0 1989 \
duke@0 1990 product(intx, CompilationPolicyChoice, 0, \
duke@0 1991 "which compilation policy (0/1)") \
duke@0 1992 \
duke@0 1993 develop(bool, UseStackBanging, true, \
duke@0 1994 "use stack banging for stack overflow checks (required for " \
duke@0 1995 "proper StackOverflow handling; disable only to measure cost " \
duke@0 1996 "of stackbanging)") \
duke@0 1997 \
duke@0 1998 develop(bool, Use24BitFPMode, true, \
duke@0 1999 "Set 24-bit FPU mode on a per-compile basis ") \
duke@0 2000 \
duke@0 2001 develop(bool, Use24BitFP, true, \
duke@0 2002 "use FP instructions that produce 24-bit precise results") \
duke@0 2003 \
duke@0 2004 develop(bool, UseStrictFP, true, \
duke@0 2005 "use strict fp if modifier strictfp is set") \
duke@0 2006 \
duke@0 2007 develop(bool, GenerateSynchronizationCode, true, \
duke@0 2008 "generate locking/unlocking code for synchronized methods and " \
duke@0 2009 "monitors") \
duke@0 2010 \
duke@0 2011 develop(bool, GenerateCompilerNullChecks, true, \
duke@0 2012 "Generate explicit null checks for loads/stores/calls") \
duke@0 2013 \
duke@0 2014 develop(bool, GenerateRangeChecks, true, \
duke@0 2015 "Generate range checks for array accesses") \
duke@0 2016 \
duke@0 2017 develop_pd(bool, ImplicitNullChecks, \
duke@0 2018 "generate code for implicit null checks") \
duke@0 2019 \
duke@0 2020 product(bool, PrintSafepointStatistics, false, \
duke@0 2021 "print statistics about safepoint synchronization") \
duke@0 2022 \
duke@0 2023 product(intx, PrintSafepointStatisticsCount, 300, \
duke@0 2024 "total number of safepoint statistics collected " \
duke@0 2025 "before printing them out") \
duke@0 2026 \
duke@0 2027 product(intx, PrintSafepointStatisticsTimeout, -1, \
duke@0 2028 "print safepoint statistics only when safepoint takes" \
duke@0 2029 " more than PrintSafepointSatisticsTimeout in millis") \
duke@0 2030 \
duke@0 2031 develop(bool, InlineAccessors, true, \
duke@0 2032 "inline accessor methods (get/set)") \
duke@0 2033 \
duke@0 2034 product(bool, Inline, true, \
duke@0 2035 "enable inlining") \
duke@0 2036 \
duke@0 2037 product(bool, ClipInlining, true, \
duke@0 2038 "clip inlining if aggregate method exceeds DesiredMethodLimit") \
duke@0 2039 \
duke@0 2040 develop(bool, UseCHA, true, \
duke@0 2041 "enable CHA") \
duke@0 2042 \
duke@0 2043 product(bool, UseTypeProfile, true, \
duke@0 2044 "Check interpreter profile for historically monomorphic calls") \
duke@0 2045 \
duke@0 2046 product(intx, TypeProfileMajorReceiverPercent, 90, \
duke@0 2047 "% of major receiver type to all profiled receivers") \
duke@0 2048 \
duke@0 2049 notproduct(bool, TimeCompiler, false, \
duke@0 2050 "time the compiler") \
duke@0 2051 \
duke@0 2052 notproduct(bool, TimeCompiler2, false, \
duke@0 2053 "detailed time the compiler (requires +TimeCompiler)") \
duke@0 2054 \
duke@0 2055 diagnostic(bool, PrintInlining, false, \
duke@0 2056 "prints inlining optimizations") \
duke@0 2057 \
duke@0 2058 diagnostic(bool, PrintIntrinsics, false, \
duke@0 2059 "prints attempted and successful inlining of intrinsics") \
duke@0 2060 \
duke@0 2061 diagnostic(ccstrlist, DisableIntrinsic, "", \
duke@0 2062 "do not expand intrinsics whose (internal) names appear here") \
duke@0 2063 \
duke@0 2064 develop(bool, StressReflectiveCode, false, \
duke@0 2065 "Use inexact types at allocations, etc., to test reflection") \
duke@0 2066 \
duke@0 2067 develop(bool, EagerInitialization, false, \
duke@0 2068 "Eagerly initialize classes if possible") \
duke@0 2069 \
duke@0 2070 product(bool, Tier1UpdateMethodData, trueInTiered, \
duke@0 2071 "Update methodDataOops in Tier1-generated code") \
duke@0 2072 \
duke@0 2073 develop(bool, TraceMethodReplacement, false, \
duke@0 2074 "Print when methods are replaced do to recompilation") \
duke@0 2075 \
duke@0 2076 develop(bool, PrintMethodFlushing, false, \
duke@0 2077 "print the nmethods being flushed") \
duke@0 2078 \
duke@0 2079 notproduct(bool, LogMultipleMutexLocking, false, \
duke@0 2080 "log locking and unlocking of mutexes (only if multiple locks " \
duke@0 2081 "are held)") \
duke@0 2082 \
duke@0 2083 develop(bool, UseRelocIndex, false, \
duke@0 2084 "use an index to speed random access to relocations") \
duke@0 2085 \
duke@0 2086 develop(bool, StressCodeBuffers, false, \
duke@0 2087 "Exercise code buffer expansion and other rare state changes") \
duke@0 2088 \
duke@0 2089 diagnostic(bool, DebugNonSafepoints, trueInDebug, \
duke@0 2090 "Generate extra debugging info for non-safepoints in nmethods") \
duke@0 2091 \
duke@0 2092 diagnostic(bool, DebugInlinedCalls, true, \
duke@0 2093 "If false, restricts profiled locations to the root method only") \
duke@0 2094 \
duke@0 2095 product(bool, PrintVMOptions, trueInDebug, \
duke@0 2096 "print VM flag settings") \
duke@0 2097 \
duke@0 2098 diagnostic(bool, SerializeVMOutput, true, \
duke@0 2099 "Use a mutex to serialize output to tty and hotspot.log") \
duke@0 2100 \
duke@0 2101 diagnostic(bool, DisplayVMOutput, true, \
duke@0 2102 "Display all VM output on the tty, independently of LogVMOutput") \
duke@0 2103 \
duke@0 2104 diagnostic(bool, LogVMOutput, trueInDebug, \
duke@0 2105 "Save VM output to hotspot.log, or to LogFile") \
duke@0 2106 \
duke@0 2107 diagnostic(ccstr, LogFile, NULL, \
duke@0 2108 "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
duke@0 2109 \
duke@0 2110 product(ccstr, ErrorFile, NULL, \
duke@0 2111 "If an error occurs, save the error data to this file " \
duke@0 2112 "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
duke@0 2113 \
duke@0 2114 product(bool, DisplayVMOutputToStderr, false, \
duke@0 2115 "If DisplayVMOutput is true, display all VM output to stderr") \
duke@0 2116 \
duke@0 2117 product(bool, DisplayVMOutputToStdout, false, \
duke@0 2118 "If DisplayVMOutput is true, display all VM output to stdout") \
duke@0 2119 \
duke@0 2120 product(bool, UseHeavyMonitors, false, \
duke@0 2121 "use heavyweight instead of lightweight Java monitors") \
duke@0 2122 \
duke@0 2123 notproduct(bool, PrintSymbolTableSizeHistogram, false, \
duke@0 2124 "print histogram of the symbol table") \
duke@0 2125 \
duke@0 2126 notproduct(bool, ExitVMOnVerifyError, false, \
duke@0 2127 "standard exit from VM if bytecode verify error " \
duke@0 2128 "(only in debug mode)") \
duke@0 2129 \
duke@0 2130 notproduct(ccstr, AbortVMOnException, NULL, \
duke@0 2131 "Call fatal if this exception is thrown. Example: " \
duke@0 2132 "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
duke@0 2133 \
duke@0 2134 develop(bool, DebugVtables, false, \
duke@0 2135 "add debugging code to vtable dispatch") \
duke@0 2136 \
duke@0 2137 develop(bool, PrintVtables, false, \
duke@0 2138 "print vtables when printing klass") \
duke@0 2139 \
duke@0 2140 notproduct(bool, PrintVtableStats, false, \
duke@0 2141 "print vtables stats at end of run") \
duke@0 2142 \
duke@0 2143 develop(bool, TraceCreateZombies, false, \
duke@0 2144 "trace creation of zombie nmethods") \
duke@0 2145 \
duke@0 2146 notproduct(bool, IgnoreLockingAssertions, false, \
duke@0 2147 "disable locking assertions (for speed)") \
duke@0 2148 \
duke@0 2149 notproduct(bool, VerifyLoopOptimizations, false, \
duke@0 2150 "verify major loop optimizations") \
duke@0 2151 \
duke@0 2152 product(bool, RangeCheckElimination, true, \
duke@0 2153 "Split loop iterations to eliminate range checks") \
duke@0 2154 \
duke@0 2155 develop_pd(bool, UncommonNullCast, \
duke@0 2156 "track occurrences of null in casts; adjust compiler tactics") \
duke@0 2157 \
duke@0 2158 develop(bool, TypeProfileCasts, true, \
duke@0 2159 "treat casts like calls for purposes of type profiling") \
duke@0 2160 \
duke@0 2161 develop(bool, MonomorphicArrayCheck, true, \
duke@0 2162 "Uncommon-trap array store checks that require full type check") \
duke@0 2163 \
duke@0 2164 develop(bool, DelayCompilationDuringStartup, true, \
duke@0 2165 "Delay invoking the compiler until main application class is " \
duke@0 2166 "loaded") \
duke@0 2167 \
duke@0 2168 develop(bool, CompileTheWorld, false, \
duke@0 2169 "Compile all methods in all classes in bootstrap class path " \
duke@0 2170 "(stress test)") \
duke@0 2171 \
duke@0 2172 develop(bool, CompileTheWorldPreloadClasses, true, \
duke@0 2173 "Preload all classes used by a class before start loading") \
duke@0 2174 \
duke@0 2175 notproduct(bool, CompileTheWorldIgnoreInitErrors, false, \
duke@0 2176 "Compile all methods although class initializer failed") \
duke@0 2177 \
duke@0 2178 develop(bool, TraceIterativeGVN, false, \
duke@0 2179 "Print progress during Iterative Global Value Numbering") \
duke@0 2180 \
duke@0 2181 develop(bool, FillDelaySlots, true, \
duke@0 2182 "Fill delay slots (on SPARC only)") \
duke@0 2183 \
duke@0 2184 develop(bool, VerifyIterativeGVN, false, \
duke@0 2185 "Verify Def-Use modifications during sparse Iterative Global " \
duke@0 2186 "Value Numbering") \
duke@0 2187 \
duke@0 2188 notproduct(bool, TracePhaseCCP, false, \
duke@0 2189 "Print progress during Conditional Constant Propagation") \
duke@0 2190 \
duke@0 2191 develop(bool, TimeLivenessAnalysis, false, \
duke@0 2192 "Time computation of bytecode liveness analysis") \
duke@0 2193 \
duke@0 2194 develop(bool, TraceLivenessGen, false, \
duke@0 2195 "Trace the generation of liveness analysis information") \
duke@0 2196 \
duke@0 2197 notproduct(bool, TraceLivenessQuery, false, \
duke@0 2198 "Trace queries of liveness analysis information") \
duke@0 2199 \
duke@0 2200 notproduct(bool, CollectIndexSetStatistics, false, \
duke@0 2201 "Collect information about IndexSets") \
duke@0 2202 \
duke@0 2203 develop(bool, PrintDominators, false, \
duke@0 2204 "Print out dominator trees for GVN") \
duke@0 2205 \
duke@0 2206 develop(bool, UseLoopSafepoints, true, \
duke@0 2207 "Generate Safepoint nodes in every loop") \
duke@0 2208 \
duke@0 2209 notproduct(bool, TraceCISCSpill, false, \
duke@0 2210 "Trace allocators use of cisc spillable instructions") \
duke@0 2211 \
duke@0 2212 notproduct(bool, TraceSpilling, false, \
duke@0 2213 "Trace spilling") \
duke@0 2214 \
duke@0 2215 develop(bool, DeutschShiffmanExceptions, true, \
duke@0 2216 "Fast check to find exception handler for precisely typed " \
duke@0 2217 "exceptions") \
duke@0 2218 \
duke@0 2219 product(bool, SplitIfBlocks, true, \
duke@0 2220 "Clone compares and control flow through merge points to fold " \
duke@0 2221 "some branches") \
duke@0 2222 \
duke@0 2223 develop(intx, FastAllocateSizeLimit, 128*K, \
duke@0 2224 /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ \
duke@0 2225 "Inline allocations larger than this in doublewords must go slow")\
duke@0 2226 \
duke@0 2227 product(bool, AggressiveOpts, false, \
duke@0 2228 "Enable aggressive optimizations - see arguments.cpp") \
duke@0 2229 \
duke@0 2230 /* statistics */ \
duke@0 2231 develop(bool, UseVTune, false, \
duke@0 2232 "enable support for Intel's VTune profiler") \
duke@0 2233 \
duke@0 2234 develop(bool, CountCompiledCalls, false, \
duke@0 2235 "counts method invocations") \
duke@0 2236 \
duke@0 2237 notproduct(bool, CountRuntimeCalls, false, \
duke@0 2238 "counts VM runtime calls") \
duke@0 2239 \
duke@0 2240 develop(bool, CountJNICalls, false, \
duke@0 2241 "counts jni method invocations") \
duke@0 2242 \
duke@0 2243 notproduct(bool, CountJVMCalls, false, \
duke@0 2244 "counts jvm method invocations") \
duke@0 2245 \
duke@0 2246 notproduct(bool, CountRemovableExceptions, false, \
duke@0 2247 "count exceptions that could be replaced by branches due to " \
duke@0 2248 "inlining") \
duke@0 2249 \
duke@0 2250 notproduct(bool, ICMissHistogram, false, \
duke@0 2251 "produce histogram of IC misses") \
duke@0 2252 \
duke@0 2253 notproduct(bool, PrintClassStatistics, false, \
duke@0 2254 "prints class statistics at end of run") \
duke@0 2255 \
duke@0 2256 notproduct(bool, PrintMethodStatistics, false, \
duke@0 2257 "prints method statistics at end of run") \
duke@0 2258 \
duke@0 2259 /* interpreter */ \
duke@0 2260 develop(bool, ClearInterpreterLocals, false, \
duke@0 2261 "Always clear local variables of interpreter activations upon " \
duke@0 2262 "entry") \
duke@0 2263 \
duke@0 2264 product_pd(bool, RewriteBytecodes, \
duke@0 2265 "Allow rewriting of bytecodes (bytecodes are not immutable)") \
duke@0 2266 \
duke@0 2267 product_pd(bool, RewriteFrequentPairs, \
duke@0 2268 "Rewrite frequently used bytecode pairs into a single bytecode") \
duke@0 2269 \
duke@0 2270 product(bool, PrintInterpreter, false, \
duke@0 2271 "Prints the generated interpreter code") \
duke@0 2272 \
duke@0 2273 product(bool, UseInterpreter, true, \
duke@0 2274 "Use interpreter for non-compiled methods") \
duke@0 2275 \
duke@0 2276 develop(bool, UseFastSignatureHandlers, true, \
duke@0 2277 "Use fast signature handlers for native calls") \
duke@0 2278 \
duke@0 2279 develop(bool, UseV8InstrsOnly, false, \
duke@0 2280 "Use SPARC-V8 Compliant instruction subset") \
duke@0 2281 \
duke@0 2282 product(bool, UseNiagaraInstrs, false, \
duke@0 2283 "Use Niagara-efficient instruction subset") \
duke@0 2284 \
duke@0 2285 develop(bool, UseCASForSwap, false, \
duke@0 2286 "Do not use swap instructions, but only CAS (in a loop) on SPARC")\
duke@0 2287 \
duke@0 2288 product(bool, UseLoopCounter, true, \
duke@0 2289 "Increment invocation counter on backward branch") \
duke@0 2290 \
duke@0 2291 product(bool, UseFastEmptyMethods, true, \
duke@0 2292 "Use fast method entry code for empty methods") \
duke@0 2293 \
duke@0 2294 product(bool, UseFastAccessorMethods, true, \
duke@0 2295 "Use fast method entry code for accessor methods") \
duke@0 2296 \
duke@0 2297 product_pd(bool, UseOnStackReplacement, \
duke@0 2298 "Use on stack replacement, calls runtime if invoc. counter " \
duke@0 2299 "overflows in loop") \
duke@0 2300 \
duke@0 2301 notproduct(bool, TraceOnStackReplacement, false, \
duke@0 2302 "Trace on stack replacement") \
duke@0 2303 \
duke@0 2304 develop(bool, PoisonOSREntry, true, \
duke@0 2305 "Detect abnormal calls to OSR code") \
duke@0 2306 \
duke@0 2307 product_pd(bool, PreferInterpreterNativeStubs, \
duke@0 2308 "Use always interpreter stubs for native methods invoked via " \
duke@0 2309 "interpreter") \
duke@0 2310 \
duke@0 2311 develop(bool, CountBytecodes, false, \
duke@0 2312 "Count number of bytecodes executed") \
duke@0 2313 \
duke@0 2314 develop(bool, PrintBytecodeHistogram, false, \
duke@0 2315 "Print histogram of the executed bytecodes") \
duke@0 2316 \
duke@0 2317 develop(bool, PrintBytecodePairHistogram, false, \
duke@0 2318 "Print histogram of the executed bytecode pairs") \
duke@0 2319 \
duke@0 2320 develop(bool, PrintSignatureHandlers, false, \
duke@0 2321 "Print code generated for native method signature handlers") \
duke@0 2322 \
duke@0 2323 develop(bool, VerifyOops, false, \
duke@0 2324 "Do plausibility checks for oops") \
duke@0 2325 \
duke@0 2326 develop(bool, CheckUnhandledOops, false, \
duke@0 2327 "Check for unhandled oops in VM code") \
duke@0 2328 \
duke@0 2329 develop(bool, VerifyJNIFields, trueInDebug, \
duke@0 2330 "Verify jfieldIDs for instance fields") \
duke@0 2331 \
duke@0 2332 notproduct(bool, VerifyJNIEnvThread, false, \
duke@0 2333 "Verify JNIEnv.thread == Thread::current() when entering VM " \
duke@0 2334 "from JNI") \
duke@0 2335 \
duke@0 2336 develop(bool, VerifyFPU, false, \
duke@0 2337 "Verify FPU state (check for NaN's, etc.)") \
duke@0 2338 \
duke@0 2339 develop(bool, VerifyThread, false, \
duke@0 2340 "Watch the thread register for corruption (SPARC only)") \
duke@0 2341 \
duke@0 2342 develop(bool, VerifyActivationFrameSize, false, \
duke@0 2343 "Verify that activation frame didn't become smaller than its " \
duke@0 2344 "minimal size") \
duke@0 2345 \
duke@0 2346 develop(bool, TraceFrequencyInlining, false, \
duke@0 2347 "Trace frequency based inlining") \
duke@0 2348 \
duke@0 2349 notproduct(bool, TraceTypeProfile, false, \
duke@0 2350 "Trace type profile") \
duke@0 2351 \
duke@0 2352 develop_pd(bool, InlineIntrinsics, \
duke@0 2353 "Inline intrinsics that can be statically resolved") \
duke@0 2354 \
duke@0 2355 product_pd(bool, ProfileInterpreter, \
duke@0 2356 "Profile at the bytecode level during interpretation") \
duke@0 2357 \
duke@0 2358 develop_pd(bool, ProfileTraps, \
duke@0 2359 "Profile deoptimization traps at the bytecode level") \
duke@0 2360 \
duke@0 2361 product(intx, ProfileMaturityPercentage, 20, \
duke@0 2362 "number of method invocations/branches (expressed as % of " \
duke@0 2363 "CompileThreshold) before using the method's profile") \
duke@0 2364 \
duke@0 2365 develop(bool, PrintMethodData, false, \
duke@0 2366 "Print the results of +ProfileInterpreter at end of run") \
duke@0 2367 \
duke@0 2368 develop(bool, VerifyDataPointer, trueInDebug, \
duke@0 2369 "Verify the method data pointer during interpreter profiling") \
duke@0 2370 \
duke@0 2371 develop(bool, VerifyCompiledCode, false, \
duke@0 2372 "Include miscellaneous runtime verifications in nmethod code; " \
duke@0 2373 "off by default because it disturbs nmethod size heuristics.") \
duke@0 2374 \
duke@0 2375 \
duke@0 2376 /* compilation */ \
duke@0 2377 product(bool, UseCompiler, true, \
duke@0 2378 "use compilation") \
duke@0 2379 \
duke@0 2380 develop(bool, TraceCompilationPolicy, false, \
duke@0 2381 "Trace compilation policy") \
duke@0 2382 \
duke@0 2383 develop(bool, TimeCompilationPolicy, false, \
duke@0 2384 "Time the compilation policy") \
duke@0 2385 \
duke@0 2386 product(bool, UseCounterDecay, true, \
duke@0 2387 "adjust recompilation counters") \
duke@0 2388 \
duke@0 2389 develop(intx, CounterHalfLifeTime, 30, \
duke@0 2390 "half-life time of invocation counters (in secs)") \
duke@0 2391 \
duke@0 2392 develop(intx, CounterDecayMinIntervalLength, 500, \
duke@0 2393 "Min. ms. between invocation of CounterDecay") \
duke@0 2394 \
duke@0 2395 product(bool, AlwaysCompileLoopMethods, false, \
duke@0 2396 "when using recompilation, never interpret methods " \
duke@0 2397 "containing loops") \
duke@0 2398 \
duke@0 2399 product(bool, DontCompileHugeMethods, true, \
duke@0 2400 "don't compile methods > HugeMethodLimit") \
duke@0 2401 \
duke@0 2402 /* Bytecode escape analysis estimation. */ \
duke@0 2403 product(bool, EstimateArgEscape, true, \
duke@0 2404 "Analyze bytecodes to estimate escape state of arguments") \
duke@0 2405 \
duke@0 2406 product(intx, BCEATraceLevel, 0, \
duke@0 2407 "How much tracing to do of bytecode escape analysis estimates") \
duke@0 2408 \
duke@0 2409 product(intx, MaxBCEAEstimateLevel, 5, \
duke@0 2410 "Maximum number of nested calls that are analyzed by BC EA.") \
duke@0 2411 \
duke@0 2412 product(intx, MaxBCEAEstimateSize, 150, \
duke@0 2413 "Maximum bytecode size of a method to be analyzed by BC EA.") \
duke@0 2414 \
duke@0 2415 product(intx, AllocatePrefetchStyle, 1, \
duke@0 2416 "0 = no prefetch, " \
duke@0 2417 "1 = prefetch instructions for each allocation, " \
duke@0 2418 "2 = use TLAB watermark to gate allocation prefetch") \
duke@0 2419 \
duke@0 2420 product(intx, AllocatePrefetchDistance, -1, \
duke@0 2421 "Distance to prefetch ahead of allocation pointer") \
duke@0 2422 \
duke@0 2423 product(intx, AllocatePrefetchLines, 1, \
duke@0 2424 "Number of lines to prefetch ahead of allocation pointer") \
duke@0 2425 \
duke@0 2426 product(intx, AllocatePrefetchStepSize, 16, \
duke@0 2427 "Step size in bytes of sequential prefetch instructions") \
duke@0 2428 \
duke@0 2429 product(intx, AllocatePrefetchInstr, 0, \
duke@0 2430 "Prefetch instruction to prefetch ahead of allocation pointer") \
duke@0 2431 \
duke@0 2432 product(intx, ReadPrefetchInstr, 0, \
duke@0 2433 "Prefetch instruction to prefetch ahead") \
duke@0 2434 \
duke@0 2435 /* deoptimization */ \
duke@0 2436 develop(bool, TraceDeoptimization, false, \
duke@0 2437 "Trace deoptimization") \
duke@0 2438 \
duke@0 2439 develop(bool, DebugDeoptimization, false, \
duke@0 2440 "Tracing various information while debugging deoptimization") \
duke@0 2441 \
duke@0 2442 product(intx, SelfDestructTimer, 0, \
duke@0 2443 "Will cause VM to terminate after a given time (in minutes) " \
duke@0 2444 "(0 means off)") \
duke@0 2445 \
duke@0 2446 product(intx, MaxJavaStackTraceDepth, 1024, \
duke@0 2447 "Max. no. of lines in the stack trace for Java exceptions " \
duke@0 2448 "(0 means all)") \
duke@0 2449 \
duke@0 2450 develop(intx, GuaranteedSafepointInterval, 1000, \
duke@0 2451 "Guarantee a safepoint (at least) every so many milliseconds " \
duke@0 2452 "(0 means none)") \
duke@0 2453 \
duke@0 2454 product(intx, SafepointTimeoutDelay, 10000, \
duke@0 2455 "Delay in milliseconds for option SafepointTimeout") \
duke@0 2456 \
duke@0 2457 product(intx, NmethodSweepFraction, 4, \
duke@0 2458 "Number of invocations of sweeper to cover all nmethods") \
duke@0 2459 \
duke@0 2460 notproduct(intx, MemProfilingInterval, 500, \
duke@0 2461 "Time between each invocation of the MemProfiler") \
duke@0 2462 \
duke@0 2463 develop(intx, MallocCatchPtr, -1, \
duke@0 2464 "Hit breakpoint when mallocing/freeing this pointer") \
duke@0 2465 \
duke@0 2466 notproduct(intx, AssertRepeat, 1, \
duke@0 2467 "number of times to evaluate expression in assert " \
duke@0 2468 "(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS") \
duke@0 2469 \
duke@0 2470 notproduct(ccstrlist, SuppressErrorAt, "", \
duke@0 2471 "List of assertions (file:line) to muzzle") \
duke@0 2472 \
duke@0 2473 notproduct(uintx, HandleAllocationLimit, 1024, \
duke@0 2474 "Threshold for HandleMark allocation when +TraceHandleAllocation "\
duke@0 2475 "is used") \
duke@0 2476 \
duke@0 2477 develop(uintx, TotalHandleAllocationLimit, 1024, \
duke@0 2478 "Threshold for total handle allocation when " \
duke@0 2479 "+TraceHandleAllocation is used") \
duke@0 2480 \
duke@0 2481 develop(intx, StackPrintLimit, 100, \
duke@0 2482 "number of stack frames to print in VM-level stack dump") \
duke@0 2483 \
duke@0 2484 notproduct(intx, MaxElementPrintSize, 256, \
duke@0 2485 "maximum number of elements to print") \
duke@0 2486 \
duke@0 2487 notproduct(intx, MaxSubklassPrintSize, 4, \
duke@0 2488 "maximum number of subklasses to print when printing klass") \
duke@0 2489 \
duke@0 2490 develop(intx, MaxInlineLevel, 9, \
duke@0 2491 "maximum number of nested calls that are inlined") \
duke@0 2492 \
duke@0 2493 develop(intx, MaxRecursiveInlineLevel, 1, \
duke@0 2494 "maximum number of nested recursive calls that are inlined") \
duke@0 2495 \
duke@0 2496 develop(intx, InlineSmallCode, 1000, \
duke@0 2497 "Only inline already compiled methods if their code size is " \
duke@0 2498 "less than this") \
duke@0 2499 \
duke@0 2500 product(intx, MaxInlineSize, 35, \
duke@0 2501 "maximum bytecode size of a method to be inlined") \
duke@0 2502 \
duke@0 2503 product_pd(intx, FreqInlineSize, \
duke@0 2504 "maximum bytecode size of a frequent method to be inlined") \
duke@0 2505 \
duke@0 2506 develop(intx, MaxTrivialSize, 6, \
duke@0 2507 "maximum bytecode size of a trivial method to be inlined") \
duke@0 2508 \
duke@0 2509 develop(intx, MinInliningThreshold, 250, \
duke@0 2510 "min. invocation count a method needs to have to be inlined") \
duke@0 2511 \
duke@0 2512 develop(intx, AlignEntryCode, 4, \
duke@0 2513 "aligns entry code to specified value (in bytes)") \
duke@0 2514 \
duke@0 2515 develop(intx, MethodHistogramCutoff, 100, \
duke@0 2516 "cutoff value for method invoc. histogram (+CountCalls)") \
duke@0 2517 \
duke@0 2518 develop(intx, ProfilerNumberOfInterpretedMethods, 25, \
duke@0 2519 "# of interpreted methods to show in profile") \
duke@0 2520 \
duke@0 2521 develop(intx, ProfilerNumberOfCompiledMethods, 25, \
duke@0 2522 "# of compiled methods to show in profile") \
duke@0 2523 \
duke@0 2524 develop(intx, ProfilerNumberOfStubMethods, 25, \
duke@0 2525 "# of stub methods to show in profile") \
duke@0 2526 \
duke@0 2527 develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \
duke@0 2528 "# of runtime stub nodes to show in profile") \
duke@0 2529 \
duke@0 2530 product(intx, ProfileIntervalsTicks, 100, \
duke@0 2531 "# of ticks between printing of interval profile " \
duke@0 2532 "(+ProfileIntervals)") \
duke@0 2533 \
duke@0 2534 notproduct(intx, ScavengeALotInterval, 1, \
duke@0 2535 "Interval between which scavenge will occur with +ScavengeALot") \
duke@0 2536 \
duke@0 2537 notproduct(intx, FullGCALotInterval, 1, \
duke@0 2538 "Interval between which full gc will occur with +FullGCALot") \
duke@0 2539 \
duke@0 2540 notproduct(intx, FullGCALotStart, 0, \
duke@0 2541 "For which invocation to start FullGCAlot") \
duke@0 2542 \
duke@0 2543 notproduct(intx, FullGCALotDummies, 32*K, \
duke@0 2544 "Dummy object allocated with +FullGCALot, forcing all objects " \
duke@0 2545 "to move") \
duke@0 2546 \
duke@0 2547 develop(intx, DontYieldALotInterval, 10, \
duke@0 2548 "Interval between which yields will be dropped (milliseconds)") \
duke@0 2549 \
duke@0 2550 develop(intx, MinSleepInterval, 1, \
duke@0 2551 "Minimum sleep() interval (milliseconds) when " \
duke@0 2552 "ConvertSleepToYield is off (used for SOLARIS)") \
duke@0 2553 \
duke@0 2554 product(intx, EventLogLength, 2000, \
duke@0 2555 "maximum nof events in event log") \
duke@0 2556 \
duke@0 2557 develop(intx, ProfilerPCTickThreshold, 15, \
duke@0 2558 "Number of ticks in a PC buckets to be a hotspot") \
duke@0 2559 \
duke@0 2560 notproduct(intx, DeoptimizeALotInterval, 5, \
duke@0 2561 "Number of exits until DeoptimizeALot kicks in") \
duke@0 2562 \
duke@0 2563 notproduct(intx, ZombieALotInterval, 5, \
duke@0 2564 "Number of exits until ZombieALot kicks in") \
duke@0 2565 \
duke@0 2566 develop(bool, StressNonEntrant, false, \
duke@0 2567 "Mark nmethods non-entrant at registration") \
duke@0 2568 \
duke@0 2569 diagnostic(intx, MallocVerifyInterval, 0, \
duke@0 2570 "if non-zero, verify C heap after every N calls to " \
duke@0 2571 "malloc/realloc/free") \
duke@0 2572 \
duke@0 2573 diagnostic(intx, MallocVerifyStart, 0, \
duke@0 2574 "if non-zero, start verifying C heap after Nth call to " \
duke@0 2575 "malloc/realloc/free") \
duke@0 2576 \
duke@0 2577 product(intx, TypeProfileWidth, 2, \
duke@0 2578 "number of receiver types to record in call/cast profile") \
duke@0 2579 \
duke@0 2580 develop(intx, BciProfileWidth, 2, \
duke@0 2581 "number of return bci's to record in ret profile") \
duke@0 2582 \
duke@0 2583 product(intx, PerMethodRecompilationCutoff, 400, \
duke@0 2584 "After recompiling N times, stay in the interpreter (-1=>'Inf')") \
duke@0 2585 \
duke@0 2586 product(intx, PerBytecodeRecompilationCutoff, 100, \
duke@0 2587 "Per-BCI limit on repeated recompilation (-1=>'Inf')") \
duke@0 2588 \
duke@0 2589 product(intx, PerMethodTrapLimit, 100, \
duke@0 2590 "Limit on traps (of one kind) in a method (includes inlines)") \
duke@0 2591 \
duke@0 2592 product(intx, PerBytecodeTrapLimit, 4, \
duke@0 2593 "Limit on traps (of one kind) at a particular BCI") \
duke@0 2594 \
duke@0 2595 develop(intx, FreqCountInvocations, 1, \
duke@0 2596 "Scaling factor for branch frequencies (deprecated)") \
duke@0 2597 \
duke@0 2598 develop(intx, InlineFrequencyRatio, 20, \
duke@0 2599 "Ratio of call site execution to caller method invocation") \
duke@0 2600 \
duke@0 2601 develop_pd(intx, InlineFrequencyCount, \
duke@0 2602 "Count of call site execution necessary to trigger frequent " \
duke@0 2603 "inlining") \
duke@0 2604 \
duke@0 2605 develop(intx, InlineThrowCount, 50, \
duke@0 2606 "Force inlining of interpreted methods that throw this often") \
duke@0 2607 \
duke@0 2608 develop(intx, InlineThrowMaxSize, 200, \
duke@0 2609 "Force inlining of throwing methods smaller than this") \
duke@0 2610 \
duke@0 2611 product(intx, AliasLevel, 3, \
duke@0 2612 "0 for no aliasing, 1 for oop/field/static/array split, " \
duke@0 2613 "2 for class split, 3 for unique instances") \
duke@0 2614 \
duke@0 2615 develop(bool, VerifyAliases, false, \
duke@0 2616 "perform extra checks on the results of alias analysis") \
duke@0 2617 \
duke@0 2618 develop(intx, ProfilerNodeSize, 1024, \
duke@0 2619 "Size in K to allocate for the Profile Nodes of each thread") \
duke@0 2620 \
duke@0 2621 develop(intx, V8AtomicOperationUnderLockSpinCount, 50, \
duke@0 2622 "Number of times to spin wait on a v8 atomic operation lock") \
duke@0 2623 \
duke@0 2624 product(intx, ReadSpinIterations, 100, \
duke@0 2625 "Number of read attempts before a yield (spin inner loop)") \
duke@0 2626 \
duke@0 2627 product_pd(intx, PreInflateSpin, \
duke@0 2628 "Number of times to spin wait before inflation") \
duke@0 2629 \
duke@0 2630 product(intx, PreBlockSpin, 10, \
duke@0 2631 "Number of times to spin in an inflated lock before going to " \
duke@0 2632 "an OS lock") \
duke@0 2633 \
duke@0 2634 /* gc parameters */ \
duke@0 2635 product(uintx, MaxHeapSize, ScaleForWordSize(64*M), \
duke@0 2636 "Default maximum size for object heap (in bytes)") \
duke@0 2637 \
duke@0 2638 product_pd(uintx, NewSize, \
duke@0 2639 "Default size of new generation (in bytes)") \
duke@0 2640 \
duke@0 2641 product(uintx, MaxNewSize, max_uintx, \
duke@0 2642 "Maximum size of new generation (in bytes)") \
duke@0 2643 \
duke@0 2644 product(uintx, PretenureSizeThreshold, 0, \
duke@0 2645 "Max size in bytes of objects allocated in DefNew generation") \
duke@0 2646 \
duke@0 2647 product_pd(uintx, TLABSize, \
duke@0 2648 "Default (or starting) size of TLAB (in bytes)") \
duke@0 2649 \
duke@0 2650 product(uintx, MinTLABSize, 2*K, \
duke@0 2651 "Minimum allowed TLAB size (in bytes)") \
duke@0 2652 \
duke@0 2653 product(uintx, TLABAllocationWeight, 35, \
duke@0 2654 "Allocation averaging weight") \
duke@0 2655 \
duke@0 2656 product(uintx, TLABWasteTargetPercent, 1, \
duke@0 2657 "Percentage of Eden that can be wasted") \
duke@0 2658 \
duke@0 2659 product(uintx, TLABRefillWasteFraction, 64, \
duke@0 2660 "Max TLAB waste at a refill (internal fragmentation)") \
duke@0 2661 \
duke@0 2662 product(uintx, TLABWasteIncrement, 4, \
duke@0 2663 "Increment allowed waste at slow allocation") \
duke@0 2664 \
duke@0 2665 product_pd(intx, SurvivorRatio, \
duke@0 2666 "Ratio of eden/survivor space size") \
duke@0 2667 \
duke@0 2668 product_pd(intx, NewRatio, \
duke@0 2669 "Ratio of new/old generation sizes") \
duke@0 2670 \
duke@0 2671 product(uintx, MaxLiveObjectEvacuationRatio, 100, \
duke@0 2672 "Max percent of eden objects that will be live at scavenge") \
duke@0 2673 \
duke@0 2674 product_pd(uintx, NewSizeThreadIncrease, \
duke@0 2675 "Additional size added to desired new generation size per " \
duke@0 2676 "non-daemon thread (in bytes)") \
duke@0 2677 \
duke@0 2678 product(uintx, OldSize, ScaleForWordSize(4096*K), \
duke@0 2679 "Default size of tenured generation (in bytes)") \
duke@0 2680 \
duke@0 2681 product_pd(uintx, PermSize, \
duke@0 2682 "Default size of permanent generation (in bytes)") \
duke@0 2683 \
duke@0 2684 product_pd(uintx, MaxPermSize, \
duke@0 2685 "Maximum size of permanent generation (in bytes)") \
duke@0 2686 \
duke@0 2687 product(uintx, MinHeapFreeRatio, 40, \
duke@0 2688 "Min percentage of heap free after GC to avoid expansion") \
duke@0 2689 \
duke@0 2690 product(uintx, MaxHeapFreeRatio, 70, \
duke@0 2691 "Max percentage of heap free after GC to avoid shrinking") \
duke@0 2692 \
duke@0 2693 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
duke@0 2694 "Number of milliseconds per MB of free space in the heap") \
duke@0 2695 \
duke@0 2696 product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
duke@0 2697 "Min change in heap space due to GC (in bytes)") \
duke@0 2698 \
duke@0 2699 product(uintx, MinPermHeapExpansion, ScaleForWordSize(256*K), \
duke@0 2700 "Min expansion of permanent heap (in bytes)") \
duke@0 2701 \
duke@0 2702 product(uintx, MaxPermHeapExpansion, ScaleForWordSize(4*M), \
duke@0 2703 "Max expansion of permanent heap without full GC (in bytes)") \
duke@0 2704 \
duke@0 2705 product(intx, QueuedAllocationWarningCount, 0, \
duke@0 2706 "Number of times an allocation that queues behind a GC " \
duke@0 2707 "will retry before printing a warning") \
duke@0 2708 \
duke@0 2709 diagnostic(uintx, VerifyGCStartAt, 0, \
duke@0 2710 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
duke@0 2711 \
duke@0 2712 diagnostic(intx, VerifyGCLevel, 0, \
duke@0 2713 "Generation level at which to start +VerifyBefore/AfterGC") \
duke@0 2714 \
duke@0 2715 develop(uintx, ExitAfterGCNum, 0, \
duke@0 2716 "If non-zero, exit after this GC.") \
duke@0 2717 \
duke@0 2718 product(intx, MaxTenuringThreshold, 15, \
duke@0 2719 "Maximum value for tenuring threshold") \
duke@0 2720 \
duke@0 2721 product(intx, InitialTenuringThreshold, 7, \
duke@0 2722 "Initial value for tenuring threshold") \
duke@0 2723 \
duke@0 2724 product(intx, TargetSurvivorRatio, 50, \
duke@0 2725 "Desired percentage of survivor space used after scavenge") \
duke@0 2726 \
duke@0 2727 product(intx, MarkSweepDeadRatio, 5, \
duke@0 2728 "Percentage (0-100) of the old gen allowed as dead wood." \
duke@0 2729 "Serial mark sweep treats this as both the min and max value." \
duke@0 2730 "CMS uses this value only if it falls back to mark sweep." \
duke@0 2731 "Par compact uses a variable scale based on the density of the" \
duke@0 2732 "generation and treats this as the max value when the heap is" \
duke@0 2733 "either completely full or completely empty. Par compact also" \
duke@0 2734 "has a smaller default value; see arguments.cpp.") \
duke@0 2735 \
duke@0 2736 product(intx, PermMarkSweepDeadRatio, 20, \
duke@0 2737 "Percentage (0-100) of the perm gen allowed as dead wood." \
duke@0 2738 "See MarkSweepDeadRatio for collector-specific comments.") \
duke@0 2739 \
duke@0 2740 product(intx, MarkSweepAlwaysCompactCount, 4, \
duke@0 2741 "How often should we fully compact the heap (ignoring the dead " \
duke@0 2742 "space parameters)") \
duke@0 2743 \
duke@0 2744 product(intx, PrintCMSStatistics, 0, \
duke@0 2745 "Statistics for CMS") \
duke@0 2746 \
duke@0 2747 product(bool, PrintCMSInitiationStatistics, false, \
duke@0 2748 "Statistics for initiating a CMS collection") \
duke@0 2749 \
duke@0 2750 product(intx, PrintFLSStatistics, 0, \
duke@0 2751 "Statistics for CMS' FreeListSpace") \
duke@0 2752 \
duke@0 2753 product(intx, PrintFLSCensus, 0, \
duke@0 2754 "Census for CMS' FreeListSpace") \
duke@0 2755 \
duke@0 2756 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
duke@0 2757 "Delay in ms between expansion and allocation") \
duke@0 2758 \
duke@0 2759 product(intx, DeferThrSuspendLoopCount, 4000, \
duke@0 2760 "(Unstable) Number of times to iterate in safepoint loop " \
duke@0 2761 " before blocking VM threads ") \
duke@0 2762 \
duke@0 2763 product(intx, DeferPollingPageLoopCount, -1, \
duke@0 2764 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
duke@0 2765 "before changing safepoint polling page to RO ") \
duke@0 2766 \
duke@0 2767 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
duke@0 2768 \
duke@0 2769 product(bool, UseDepthFirstScavengeOrder, true, \
duke@0 2770 "true: the scavenge order will be depth-first, " \
duke@0 2771 "false: the scavenge order will be breadth-first") \
duke@0 2772 \
duke@0 2773 product(bool, PSChunkLargeArrays, true, \
duke@0 2774 "true: process large arrays in chunks") \
duke@0 2775 \
duke@0 2776 product(uintx, GCDrainStackTargetSize, 64, \
duke@0 2777 "how many entries we'll try to leave on the stack during " \
duke@0 2778 "parallel GC") \
duke@0 2779 \
duke@0 2780 /* stack parameters */ \
duke@0 2781 product_pd(intx, StackYellowPages, \
duke@0 2782 "Number of yellow zone (recoverable overflows) pages") \
duke@0 2783 \
duke@0 2784 product_pd(intx, StackRedPages, \
duke@0 2785 "Number of red zone (unrecoverable overflows) pages") \
duke@0 2786 \
duke@0 2787 product_pd(intx, StackShadowPages, \
duke@0 2788 "Number of shadow zone (for overflow checking) pages" \
duke@0 2789 " this should exceed the depth of the VM and native call stack") \
duke@0 2790 \
duke@0 2791 product_pd(intx, ThreadStackSize, \
duke@0 2792 "Thread Stack Size (in Kbytes)") \
duke@0 2793 \
duke@0 2794 product_pd(intx, VMThreadStackSize, \
duke@0 2795 "Non-Java Thread Stack Size (in Kbytes)") \
duke@0 2796 \
duke@0 2797 product_pd(intx, CompilerThreadStackSize, \
duke@0 2798 "Compiler Thread Stack Size (in Kbytes)") \
duke@0 2799 \
duke@0 2800 develop_pd(uintx, JVMInvokeMethodSlack, \
duke@0 2801 "Stack space (bytes) required for JVM_InvokeMethod to complete") \
duke@0 2802 \
duke@0 2803 product(uintx, ThreadSafetyMargin, 50*M, \
duke@0 2804 "Thread safety margin is used on fixed-stack LinuxThreads (on " \
duke@0 2805 "Linux/x86 only) to prevent heap-stack collision. Set to 0 to " \
duke@0 2806 "disable this feature") \
duke@0 2807 \
duke@0 2808 /* code cache parameters */ \
duke@0 2809 develop(uintx, CodeCacheSegmentSize, 64, \
duke@0 2810 "Code cache segment size (in bytes) - smallest unit of " \
duke@0 2811 "allocation") \
duke@0 2812 \
duke@0 2813 develop_pd(intx, CodeEntryAlignment, \
duke@0 2814 "Code entry alignment for generated code (in bytes)") \
duke@0 2815 \
duke@0 2816 product_pd(uintx, InitialCodeCacheSize, \
duke@0 2817 "Initial code cache size (in bytes)") \
duke@0 2818 \
duke@0 2819 product_pd(uintx, ReservedCodeCacheSize, \
duke@0 2820 "Reserved code cache size (in bytes) - maximum code cache size") \
duke@0 2821 \
duke@0 2822 product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
duke@0 2823 "When less than X space left, we stop compiling.") \
duke@0 2824 \
duke@0 2825 product_pd(uintx, CodeCacheExpansionSize, \
duke@0 2826 "Code cache expansion size (in bytes)") \
duke@0 2827 \
duke@0 2828 develop_pd(uintx, CodeCacheMinBlockLength, \
duke@0 2829 "Minimum number of segments in a code cache block.") \
duke@0 2830 \
duke@0 2831 notproduct(bool, ExitOnFullCodeCache, false, \
duke@0 2832 "Exit the VM if we fill the code cache.") \
duke@0 2833 \
duke@0 2834 /* interpreter debugging */ \
duke@0 2835 develop(intx, BinarySwitchThreshold, 5, \
duke@0 2836 "Minimal number of lookupswitch entries for rewriting to binary " \
duke@0 2837 "switch") \
duke@0 2838 \
duke@0 2839 develop(intx, StopInterpreterAt, 0, \
duke@0 2840 "Stops interpreter execution at specified bytecode number") \
duke@0 2841 \
duke@0 2842 develop(intx, TraceBytecodesAt, 0, \
duke@0 2843 "Traces bytecodes starting with specified bytecode number") \
duke@0 2844 \
duke@0 2845 /* compiler interface */ \
duke@0 2846 develop(intx, CIStart, 0, \
duke@0 2847 "the id of the first compilation to permit") \
duke@0 2848 \
duke@0 2849 develop(intx, CIStop, -1, \
duke@0 2850 "the id of the last compilation to permit") \
duke@0 2851 \
duke@0 2852 develop(intx, CIStartOSR, 0, \
duke@0 2853 "the id of the first osr compilation to permit " \
duke@0 2854 "(CICountOSR must be on)") \
duke@0 2855 \
duke@0 2856 develop(intx, CIStopOSR, -1, \
duke@0 2857 "the id of the last osr compilation to permit " \
duke@0 2858 "(CICountOSR must be on)") \
duke@0 2859 \
duke@0 2860 develop(intx, CIBreakAtOSR, -1, \
duke@0 2861 "id of osr compilation to break at") \
duke@0 2862 \
duke@0 2863 develop(intx, CIBreakAt, -1, \
duke@0 2864 "id of compilation to break at") \
duke@0 2865 \
duke@0 2866 product(ccstrlist, CompileOnly, "", \
duke@0 2867 "List of methods (pkg/class.name) to restrict compilation to") \
duke@0 2868 \
duke@0 2869 product(ccstr, CompileCommandFile, NULL, \
duke@0 2870 "Read compiler commands from this file [.hotspot_compiler]") \
duke@0 2871 \
duke@0 2872 product(ccstrlist, CompileCommand, "", \
duke@0 2873 "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \
duke@0 2874 \
duke@0 2875 product(bool, CICompilerCountPerCPU, false, \
duke@0 2876 "1 compiler thread for log(N CPUs)") \
duke@0 2877 \
duke@0 2878 develop(intx, CIFireOOMAt, -1, \
duke@0 2879 "Fire OutOfMemoryErrors throughout CI for testing the compiler " \
duke@0 2880 "(non-negative value throws OOM after this many CI accesses " \
duke@0 2881 "in each compile)") \
duke@0 2882 \
duke@0 2883 develop(intx, CIFireOOMAtDelay, -1, \
duke@0 2884 "Wait for this many CI accesses to occur in all compiles before " \
duke@0 2885 "beginning to throw OutOfMemoryErrors in each compile") \
duke@0 2886 \
duke@0 2887 /* Priorities */ \
duke@0 2888 product_pd(bool, UseThreadPriorities, "Use native thread priorities") \
duke@0 2889 \
duke@0 2890 product(intx, ThreadPriorityPolicy, 0, \
duke@0 2891 "0 : Normal. "\
duke@0 2892 " VM chooses priorities that are appropriate for normal "\
duke@0 2893 " applications. On Solaris NORM_PRIORITY and above are mapped "\
duke@0 2894 " to normal native priority. Java priorities below NORM_PRIORITY"\
duke@0 2895 " map to lower native priority values. On Windows applications"\
duke@0 2896 " are allowed to use higher native priorities. However, with "\
duke@0 2897 " ThreadPriorityPolicy=0, VM will not use the highest possible"\
duke@0 2898 " native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may "\
duke@0 2899 " interfere with system threads. On Linux thread priorities "\
duke@0 2900 " are ignored because the OS does not support static priority "\
duke@0 2901 " in SCHED_OTHER scheduling class which is the only choice for"\
duke@0 2902 " non-root, non-realtime applications. "\
duke@0 2903 "1 : Aggressive. "\
duke@0 2904 " Java thread priorities map over to the entire range of "\
duke@0 2905 " native thread priorities. Higher Java thread priorities map "\
duke@0 2906 " to higher native thread priorities. This policy should be "\
duke@0 2907 " used with care, as sometimes it can cause performance "\
duke@0 2908 " degradation in the application and/or the entire system. On "\
duke@0 2909 " Linux this policy requires root privilege.") \
duke@0 2910 \
duke@0 2911 product(bool, ThreadPriorityVerbose, false, \
duke@0 2912 "print priority changes") \
duke@0 2913 \
duke@0 2914 product(intx, DefaultThreadPriority, -1, \
duke@0 2915 "what native priority threads run at if not specified elsewhere (-1 means no change)") \
duke@0 2916 \
duke@0 2917 product(intx, CompilerThreadPriority, -1, \
duke@0 2918 "what priority should compiler threads run at (-1 means no change)") \
duke@0 2919 \
duke@0 2920 product(intx, VMThreadPriority, -1, \
duke@0 2921 "what priority should VM threads run at (-1 means no change)") \
duke@0 2922 \
duke@0 2923 product(bool, CompilerThreadHintNoPreempt, true, \
duke@0 2924 "(Solaris only) Give compiler threads an extra quanta") \
duke@0 2925 \
duke@0 2926 product(bool, VMThreadHintNoPreempt, false, \
duke@0 2927 "(Solaris only) Give VM thread an extra quanta") \
duke@0 2928 \
duke@0 2929 product(intx, JavaPriority1_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2930 product(intx, JavaPriority2_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2931 product(intx, JavaPriority3_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2932 product(intx, JavaPriority4_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2933 product(intx, JavaPriority5_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2934 product(intx, JavaPriority6_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2935 product(intx, JavaPriority7_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2936 product(intx, JavaPriority8_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2937 product(intx, JavaPriority9_To_OSPriority, -1, "Map Java priorities to OS priorities") \
duke@0 2938 product(intx, JavaPriority10_To_OSPriority,-1, "Map Java priorities to OS priorities") \
duke@0 2939 \
duke@0 2940 /* compiler debugging */ \
duke@0 2941 notproduct(intx, CompileTheWorldStartAt, 1, \
duke@0 2942 "First class to consider when using +CompileTheWorld") \
duke@0 2943 \
duke@0 2944 notproduct(intx, CompileTheWorldStopAt, max_jint, \
duke@0 2945 "Last class to consider when using +CompileTheWorld") \
duke@0 2946 \
duke@0 2947 develop(intx, NewCodeParameter, 0, \
duke@0 2948 "Testing Only: Create a dedicated integer parameter before " \
duke@0 2949 "putback") \
duke@0 2950 \
duke@0 2951 /* new oopmap storage allocation */ \
duke@0 2952 develop(intx, MinOopMapAllocation, 8, \
duke@0 2953 "Minimum number of OopMap entries in an OopMapSet") \
duke@0 2954 \
duke@0 2955 /* Background Compilation */ \
duke@0 2956 develop(intx, LongCompileThreshold, 50, \
duke@0 2957 "Used with +TraceLongCompiles") \
duke@0 2958 \
duke@0 2959 product(intx, StarvationMonitorInterval, 200, \
duke@0 2960 "Pause between each check in ms") \
duke@0 2961 \
duke@0 2962 /* recompilation */ \
duke@0 2963 product_pd(intx, CompileThreshold, \
duke@0 2964 "number of interpreted method invocations before (re-)compiling") \
duke@0 2965 \
duke@0 2966 product_pd(intx, BackEdgeThreshold, \
duke@0 2967 "Interpreter Back edge threshold at which an OSR compilation is invoked")\
duke@0 2968 \
duke@0 2969 product(intx, Tier1BytecodeLimit, 10, \
duke@0 2970 "Must have at least this many bytecodes before tier1" \
duke@0 2971 "invocation counters are used") \
duke@0 2972 \
duke@0 2973 product_pd(intx, Tier2CompileThreshold, \
duke@0 2974 "threshold at which a tier 2 compilation is invoked") \
duke@0 2975 \
duke@0 2976 product_pd(intx, Tier2BackEdgeThreshold, \
duke@0 2977 "Back edge threshold at which a tier 2 compilation is invoked") \
duke@0 2978 \
duke@0 2979 product_pd(intx, Tier3CompileThreshold, \
duke@0 2980 "threshold at which a tier 3 compilation is invoked") \
duke@0 2981 \
duke@0 2982 product_pd(intx, Tier3BackEdgeThreshold, \
duke@0 2983 "Back edge threshold at which a tier 3 compilation is invoked") \
duke@0 2984 \
duke@0 2985 product_pd(intx, Tier4CompileThreshold, \
duke@0 2986 "threshold at which a tier 4 compilation is invoked") \
duke@0 2987 \
duke@0 2988 product_pd(intx, Tier4BackEdgeThreshold, \
duke@0 2989 "Back edge threshold at which a tier 4 compilation is invoked") \
duke@0 2990 \
duke@0 2991 product_pd(bool, TieredCompilation, \
duke@0 2992 "Enable two-tier compilation") \
duke@0 2993 \
duke@0 2994 product(bool, StressTieredRuntime, false, \
duke@0 2995 "Alternate client and server compiler on compile requests") \
duke@0 2996 \
duke@0 2997 product_pd(intx, OnStackReplacePercentage, \
duke@0 2998 "NON_TIERED number of method invocations/branches (expressed as %"\
duke@0 2999 "of CompileThreshold) before (re-)compiling OSR code") \
duke@0 3000 \
duke@0 3001 product(intx, InterpreterProfilePercentage, 33, \
duke@0 3002 "NON_TIERED number of method invocations/branches (expressed as %"\
duke@0 3003 "of CompileThreshold) before profiling in the interpreter") \
duke@0 3004 \
duke@0 3005 develop(intx, MaxRecompilationSearchLength, 10, \
duke@0 3006 "max. # frames to inspect searching for recompilee") \
duke@0 3007 \
duke@0 3008 develop(intx, MaxInterpretedSearchLength, 3, \
duke@0 3009 "max. # interp. frames to skip when searching for recompilee") \
duke@0 3010 \
duke@0 3011 develop(intx, DesiredMethodLimit, 8000, \
duke@0 3012 "desired max. method size (in bytecodes) after inlining") \
duke@0 3013 \
duke@0 3014 develop(intx, HugeMethodLimit, 8000, \
duke@0 3015 "don't compile methods larger than this if " \
duke@0 3016 "+DontCompileHugeMethods") \
duke@0 3017 \
duke@0 3018 /* New JDK 1.4 reflection implementation */ \
duke@0 3019 \
duke@0 3020 develop(bool, UseNewReflection, true, \
duke@0 3021 "Temporary flag for transition to reflection based on dynamic " \
duke@0 3022 "bytecode generation in 1.4; can no longer be turned off in 1.4 " \
duke@0 3023 "JDK, and is unneeded in 1.3 JDK, but marks most places VM " \
duke@0 3024 "changes were needed") \
duke@0 3025 \
duke@0 3026 develop(bool, VerifyReflectionBytecodes, false, \
duke@0 3027 "Force verification of 1.4 reflection bytecodes. Does not work " \
duke@0 3028 "in situations like that described in 4486457 or for " \
duke@0 3029 "constructors generated for serialization, so can not be enabled "\
duke@0 3030 "in product.") \
duke@0 3031 \
duke@0 3032 product(bool, ReflectionWrapResolutionErrors, true, \
duke@0 3033 "Temporary flag for transition to AbstractMethodError wrapped " \
duke@0 3034 "in InvocationTargetException. See 6531596") \
duke@0 3035 \
duke@0 3036 \
duke@0 3037 develop(intx, FastSuperclassLimit, 8, \
duke@0 3038 "Depth of hardwired instanceof accelerator array") \
duke@0 3039 \
duke@0 3040 /* Properties for Java libraries */ \
duke@0 3041 \
duke@0 3042 product(intx, MaxDirectMemorySize, -1, \
duke@0 3043 "Maximum total size of NIO direct-buffer allocations") \
duke@0 3044 \
duke@0 3045 /* temporary developer defined flags */ \
duke@0 3046 \
duke@0 3047 diagnostic(bool, UseNewCode, false, \
duke@0 3048 "Testing Only: Use the new version while testing") \
duke@0 3049 \
duke@0 3050 diagnostic(bool, UseNewCode2, false, \
duke@0 3051 "Testing Only: Use the new version while testing") \
duke@0 3052 \
duke@0 3053 diagnostic(bool, UseNewCode3, false, \
duke@0 3054 "Testing Only: Use the new version while testing") \
duke@0 3055 \
duke@0 3056 /* flags for performance data collection */ \
duke@0 3057 \
duke@0 3058 product(bool, UsePerfData, true, \
duke@0 3059 "Flag to disable jvmstat instrumentation for performance testing" \
duke@0 3060 "and problem isolation purposes.") \
duke@0 3061 \
duke@0 3062 product(bool, PerfDataSaveToFile, false, \
duke@0 3063 "Save PerfData memory to hsperfdata_<pid> file on exit") \
duke@0 3064 \
duke@0 3065 product(ccstr, PerfDataSaveFile, NULL, \
duke@0 3066 "Save PerfData memory to the specified absolute pathname," \
duke@0 3067 "%p in the file name if present will be replaced by pid") \
duke@0 3068 \
duke@0 3069 product(intx, PerfDataSamplingInterval, 50 /*ms*/, \
duke@0 3070 "Data sampling interval in milliseconds") \
duke@0 3071 \
duke@0 3072 develop(bool, PerfTraceDataCreation, false, \
duke@0 3073 "Trace creation of Performance Data Entries") \
duke@0 3074 \
duke@0 3075 develop(bool, PerfTraceMemOps, false, \
duke@0 3076 "Trace PerfMemory create/attach/detach calls") \
duke@0 3077 \
duke@0 3078 product(bool, PerfDisableSharedMem, false, \
duke@0 3079 "Store performance data in standard memory") \
duke@0 3080 \
duke@0 3081 product(intx, PerfDataMemorySize, 32*K, \
duke@0 3082 "Size of performance data memory region. Will be rounded " \
duke@0 3083 "up to a multiple of the native os page size.") \
duke@0 3084 \
duke@0 3085 product(intx, PerfMaxStringConstLength, 1024, \
duke@0 3086 "Maximum PerfStringConstant string length before truncation") \
duke@0 3087 \
duke@0 3088 product(bool, PerfAllowAtExitRegistration, false, \
duke@0 3089 "Allow registration of atexit() methods") \
duke@0 3090 \
duke@0 3091 product(bool, PerfBypassFileSystemCheck, false, \
duke@0 3092 "Bypass Win32 file system criteria checks (Windows Only)") \
duke@0 3093 \
duke@0 3094 product(intx, UnguardOnExecutionViolation, 0, \
duke@0 3095 "Unguard page and retry on no-execute fault (Win32 only)" \
duke@0 3096 "0=off, 1=conservative, 2=aggressive") \
duke@0 3097 \
duke@0 3098 /* Serviceability Support */ \
duke@0 3099 \
duke@0 3100 product(bool, ManagementServer, false, \
duke@0 3101 "Create JMX Management Server") \
duke@0 3102 \
duke@0 3103 product(bool, DisableAttachMechanism, false, \
duke@0 3104 "Disable mechanism that allows tools to attach to this VM") \
duke@0 3105 \
duke@0 3106 product(bool, StartAttachListener, false, \
duke@0 3107 "Always start Attach Listener at VM startup") \
duke@0 3108 \
duke@0 3109 manageable(bool, PrintConcurrentLocks, false, \
duke@0 3110 "Print java.util.concurrent locks in thread dump") \
duke@0 3111 \
duke@0 3112 /* Shared spaces */ \
duke@0 3113 \
duke@0 3114 product(bool, UseSharedSpaces, true, \
duke@0 3115 "Use shared spaces in the permanent generation") \
duke@0 3116 \
duke@0 3117 product(bool, RequireSharedSpaces, false, \
duke@0 3118 "Require shared spaces in the permanent generation") \
duke@0 3119 \
duke@0 3120 product(bool, ForceSharedSpaces, false, \
duke@0 3121 "Require shared spaces in the permanent generation") \
duke@0 3122 \
duke@0 3123 product(bool, DumpSharedSpaces, false, \
duke@0 3124 "Special mode: JVM reads a class list, loads classes, builds " \
duke@0 3125 "shared spaces, and dumps the shared spaces to a file to be " \
duke@0 3126 "used in future JVM runs.") \
duke@0 3127 \
duke@0 3128 product(bool, PrintSharedSpaces, false, \
duke@0 3129 "Print usage of shared spaces") \
duke@0 3130 \
duke@0 3131 product(uintx, SharedDummyBlockSize, 512*M, \
duke@0 3132 "Size of dummy block used to shift heap addresses (in bytes)") \
duke@0 3133 \
duke@0 3134 product(uintx, SharedReadWriteSize, 12*M, \
duke@0 3135 "Size of read-write space in permanent generation (in bytes)") \
duke@0 3136 \
duke@0 3137 product(uintx, SharedReadOnlySize, 8*M, \
duke@0 3138 "Size of read-only space in permanent generation (in bytes)") \
duke@0 3139 \
duke@0 3140 product(uintx, SharedMiscDataSize, 4*M, \
duke@0 3141 "Size of the shared data area adjacent to the heap (in bytes)") \
duke@0 3142 \
duke@0 3143 product(uintx, SharedMiscCodeSize, 4*M, \
duke@0 3144 "Size of the shared code area adjacent to the heap (in bytes)") \
duke@0 3145 \
duke@0 3146 diagnostic(bool, SharedOptimizeColdStart, true, \
duke@0 3147 "At dump time, order shared objects to achieve better " \
duke@0 3148 "cold startup time.") \
duke@0 3149 \
duke@0 3150 develop(intx, SharedOptimizeColdStartPolicy, 2, \
duke@0 3151 "Reordering policy for SharedOptimizeColdStart " \
duke@0 3152 "0=favor classload-time locality, 1=balanced, " \
duke@0 3153 "2=favor runtime locality") \
duke@0 3154 \
duke@0 3155 diagnostic(bool, SharedSkipVerify, false, \
duke@0 3156 "Skip assert() and verify() which page-in unwanted shared " \
duke@0 3157 "objects. ") \
duke@0 3158 \
duke@0 3159 product(bool, TaggedStackInterpreter, false, \
duke@0 3160 "Insert tags in interpreter execution stack for oopmap generaion")\
duke@0 3161 \
duke@0 3162 diagnostic(bool, PauseAtStartup, false, \
duke@0 3163 "Causes the VM to pause at startup time and wait for the pause " \
duke@0 3164 "file to be removed (default: ./vm.paused.<pid>)") \
duke@0 3165 \
duke@0 3166 diagnostic(ccstr, PauseAtStartupFile, NULL, \
duke@0 3167 "The file to create and for whose removal to await when pausing " \
duke@0 3168 "at startup. (default: ./vm.paused.<pid>)") \
duke@0 3169 \
duke@0 3170 product(bool, ExtendedDTraceProbes, false, \
duke@0 3171 "Enable performance-impacting dtrace probes") \
duke@0 3172 \
duke@0 3173 product(bool, DTraceMethodProbes, false, \
duke@0 3174 "Enable dtrace probes for method-entry and method-exit") \
duke@0 3175 \
duke@0 3176 product(bool, DTraceAllocProbes, false, \
duke@0 3177 "Enable dtrace probes for object allocation") \
duke@0 3178 \
duke@0 3179 product(bool, DTraceMonitorProbes, false, \
duke@0 3180 "Enable dtrace probes for monitor events") \
duke@0 3181 \
duke@0 3182 product(bool, RelaxAccessControlCheck, false, \
duke@0 3183 "Relax the access control checks in the verifier") \
duke@0 3184 \
duke@0 3185 product(bool, UseVMInterruptibleIO, true, \
duke@0 3186 "(Unstable, Solaris-specific) Thread interrupt before or with " \
duke@0 3187 "EINTR for I/O operations results in OS_INTRPT")
duke@0 3188
duke@0 3189
duke@0 3190 /*
duke@0 3191 * Macros for factoring of globals
duke@0 3192 */
duke@0 3193
duke@0 3194 // Interface macros
duke@0 3195 #define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3196 #define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name;
duke@0 3197 #define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3198 #define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3199 #define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3200 #ifdef PRODUCT
duke@0 3201 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) const type name = value;
duke@0 3202 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) const type name = pd_##name;
duke@0 3203 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc)
duke@0 3204 #else
duke@0 3205 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3206 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name;
duke@0 3207 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name;
duke@0 3208 #endif
duke@0 3209
duke@0 3210 // Implementation macros
duke@0 3211 #define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value;
duke@0 3212 #define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name;
duke@0 3213 #define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value;
duke@0 3214 #define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value;
duke@0 3215 #define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value;
duke@0 3216 #ifdef PRODUCT
duke@0 3217 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) /* flag name is constant */
duke@0 3218 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) /* flag name is constant */
duke@0 3219 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc)
duke@0 3220 #else
duke@0 3221 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value;
duke@0 3222 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name;
duke@0 3223 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value;
duke@0 3224 #endif
duke@0 3225
duke@0 3226 RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
duke@0 3227
duke@0 3228 RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)