annotate src/share/vm/runtime/globals.hpp @ 1145:e018e6884bd8

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