globals.hpp 268.3 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28
#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
#define SHARE_VM_RUNTIME_GLOBALS_HPP

#include "utilities/debug.hpp"
I
iveresov 已提交
29 30 31 32 33 34 35 36 37 38 39

// use this for flags that are true per default in the tiered build
// but false in non-tiered builds, and vice versa
#ifdef TIERED
#define  trueInTiered true
#define falseInTiered false
#else
#define  trueInTiered false
#define falseInTiered true
#endif

40 41 42 43 44 45 46 47 48
#ifdef TARGET_ARCH_x86
# include "globals_x86.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "globals_sparc.hpp"
#endif
#ifdef TARGET_ARCH_zero
# include "globals_zero.hpp"
#endif
49 50 51 52 53 54
#ifdef TARGET_ARCH_arm
# include "globals_arm.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "globals_ppc.hpp"
#endif
55 56 57 58 59 60 61 62 63
#ifdef TARGET_OS_FAMILY_linux
# include "globals_linux.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "globals_solaris.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "globals_windows.hpp"
#endif
N
never 已提交
64 65 66
#ifdef TARGET_OS_FAMILY_bsd
# include "globals_bsd.hpp"
#endif
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
#ifdef TARGET_OS_ARCH_linux_x86
# include "globals_linux_x86.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_sparc
# include "globals_linux_sparc.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_zero
# include "globals_linux_zero.hpp"
#endif
#ifdef TARGET_OS_ARCH_solaris_x86
# include "globals_solaris_x86.hpp"
#endif
#ifdef TARGET_OS_ARCH_solaris_sparc
# include "globals_solaris_sparc.hpp"
#endif
#ifdef TARGET_OS_ARCH_windows_x86
# include "globals_windows_x86.hpp"
#endif
85 86 87 88 89 90
#ifdef TARGET_OS_ARCH_linux_arm
# include "globals_linux_arm.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_ppc
# include "globals_linux_ppc.hpp"
#endif
N
never 已提交
91 92 93 94 95 96
#ifdef TARGET_OS_ARCH_bsd_x86
# include "globals_bsd_x86.hpp"
#endif
#ifdef TARGET_OS_ARCH_bsd_zero
# include "globals_bsd_zero.hpp"
#endif
97 98 99 100 101 102 103
#ifdef COMPILER1
#ifdef TARGET_ARCH_x86
# include "c1_globals_x86.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "c1_globals_sparc.hpp"
#endif
104 105 106 107 108 109
#ifdef TARGET_ARCH_arm
# include "c1_globals_arm.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "c1_globals_ppc.hpp"
#endif
110 111 112 113 114 115 116 117 118
#ifdef TARGET_OS_FAMILY_linux
# include "c1_globals_linux.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "c1_globals_solaris.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "c1_globals_windows.hpp"
#endif
N
never 已提交
119 120 121
#ifdef TARGET_OS_FAMILY_bsd
# include "c1_globals_bsd.hpp"
#endif
122 123 124 125 126 127 128 129
#endif
#ifdef COMPILER2
#ifdef TARGET_ARCH_x86
# include "c2_globals_x86.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "c2_globals_sparc.hpp"
#endif
130 131 132
#ifdef TARGET_ARCH_arm
# include "c2_globals_arm.hpp"
#endif
133 134 135 136 137 138 139 140 141
#ifdef TARGET_OS_FAMILY_linux
# include "c2_globals_linux.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "c2_globals_solaris.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "c2_globals_windows.hpp"
#endif
N
never 已提交
142 143 144
#ifdef TARGET_OS_FAMILY_bsd
# include "c2_globals_bsd.hpp"
#endif
145 146 147 148 149 150 151
#endif
#ifdef SHARK
#ifdef TARGET_ARCH_zero
# include "shark_globals_zero.hpp"
#endif
#endif

152
#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK)
D
duke 已提交
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
define_pd_global(bool, BackgroundCompilation,        false);
define_pd_global(bool, UseTLAB,                      false);
define_pd_global(bool, CICompileOSR,                 false);
define_pd_global(bool, UseTypeProfile,               false);
define_pd_global(bool, UseOnStackReplacement,        false);
define_pd_global(bool, InlineIntrinsics,             false);
define_pd_global(bool, PreferInterpreterNativeStubs, true);
define_pd_global(bool, ProfileInterpreter,           false);
define_pd_global(bool, ProfileTraps,                 false);
define_pd_global(bool, TieredCompilation,            false);

define_pd_global(intx, CompileThreshold,             0);
define_pd_global(intx, BackEdgeThreshold,            0);

define_pd_global(intx, OnStackReplacePercentage,     0);
define_pd_global(bool, ResizeTLAB,                   false);
define_pd_global(intx, FreqInlineSize,               0);
P
phh 已提交
170
define_pd_global(intx, InlineSmallCode,              0);
D
duke 已提交
171 172 173 174 175 176 177
define_pd_global(intx, NewSizeThreadIncrease,        4*K);
define_pd_global(intx, InlineClassNatives,           true);
define_pd_global(intx, InlineUnsafeOps,              true);
define_pd_global(intx, InitialCodeCacheSize,         160*K);
define_pd_global(intx, ReservedCodeCacheSize,        32*M);
define_pd_global(intx, CodeCacheExpansionSize,       32*K);
define_pd_global(intx, CodeCacheMinBlockLength,      1);
178
define_pd_global(intx, CodeCacheMinimumUseSpace,     200*K);
179
define_pd_global(uintx,MetaspaceSize,    ScaleForWordSize(4*M));
D
duke 已提交
180
define_pd_global(bool, NeverActAsServerClassMachine, true);
P
phh 已提交
181
define_pd_global(uint64_t,MaxRAM,                    1ULL*G);
D
duke 已提交
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
#define CI_COMPILER_COUNT 0
#else

#ifdef COMPILER2
#define CI_COMPILER_COUNT 2
#else
#define CI_COMPILER_COUNT 1
#endif // COMPILER2

#endif // no compilers

// string type aliases used only in this file
typedef const char* ccstr;
typedef const char* ccstrlist;   // represents string arguments which accumulate

enum FlagValueOrigin {
  DEFAULT          = 0,
  COMMAND_LINE     = 1,
  ENVIRON_VAR      = 2,
  CONFIG_FILE      = 3,
  MANAGEMENT       = 4,
  ERGONOMIC        = 5,
  ATTACH_ON_DEMAND = 6,
  INTERNAL         = 99
};

struct Flag {
  const char *type;
  const char *name;
  void*       addr;
212 213 214

  NOT_PRODUCT(const char *doc;)

D
duke 已提交
215 216 217 218 219 220 221 222 223
  const char *kind;
  FlagValueOrigin origin;

  // points to all Flags static array
  static Flag *flags;

  // number of flags
  static size_t numFlags;

224 225
  static Flag* find_flag(const char* name, size_t length, bool allow_locked = false);
  static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
D
duke 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238

  bool is_bool() const        { return strcmp(type, "bool") == 0; }
  bool get_bool() const       { return *((bool*) addr); }
  void set_bool(bool value)   { *((bool*) addr) = value; }

  bool is_intx()  const       { return strcmp(type, "intx")  == 0; }
  intx get_intx() const       { return *((intx*) addr); }
  void set_intx(intx value)   { *((intx*) addr) = value; }

  bool is_uintx() const       { return strcmp(type, "uintx") == 0; }
  uintx get_uintx() const     { return *((uintx*) addr); }
  void set_uintx(uintx value) { *((uintx*) addr) = value; }

P
phh 已提交
239 240 241 242
  bool is_uint64_t() const          { return strcmp(type, "uint64_t") == 0; }
  uint64_t get_uint64_t() const     { return *((uint64_t*) addr); }
  void set_uint64_t(uint64_t value) { *((uint64_t*) addr) = value; }

D
duke 已提交
243 244 245 246 247 248 249 250 251 252 253 254 255 256
  bool is_double() const        { return strcmp(type, "double") == 0; }
  double get_double() const     { return *((double*) addr); }
  void set_double(double value) { *((double*) addr) = value; }

  bool is_ccstr() const          { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; }
  bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; }
  ccstr get_ccstr() const     { return *((ccstr*) addr); }
  void set_ccstr(ccstr value) { *((ccstr*) addr) = value; }

  bool is_unlocker() const;
  bool is_unlocked() const;
  bool is_writeable() const;
  bool is_external() const;

257 258
  bool is_unlocker_ext() const;
  bool is_unlocked_ext() const;
259 260
  bool is_writeable_ext() const;
  bool is_external_ext() const;
261 262 263

  void get_locked_message(char*, int) const;
  void get_locked_message_ext(char*, int) const;
264

265
  void print_on(outputStream* st, bool withComments = false );
D
duke 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
  void print_as_flag(outputStream* st);
};

// debug flags control various aspects of the VM and are global accessible

// use FlagSetting to temporarily change some debug flag
// e.g. FlagSetting fs(DebugThisAndThat, true);
// restored to previous value upon leaving scope
class FlagSetting {
  bool val;
  bool* flag;
 public:
  FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }
  ~FlagSetting()                       { *flag = val; }
};


class CounterSetting {
  intx* counter;
 public:
  CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }
  ~CounterSetting()         { (*counter)--; }
};


291 292 293
class UIntFlagSetting {
  uintx val;
  uintx* flag;
D
duke 已提交
294
 public:
295 296
  UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
  ~UIntFlagSetting()                         { *flag = val; }
D
duke 已提交
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
};


class DoubleFlagSetting {
  double val;
  double* flag;
 public:
  DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }
  ~DoubleFlagSetting()                           { *flag = val; }
};


class CommandLineFlags {
 public:
  static bool boolAt(char* name, size_t len, bool* value);
  static bool boolAt(char* name, bool* value)      { return boolAt(name, strlen(name), value); }
  static bool boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin);
  static bool boolAtPut(char* name, bool* value, FlagValueOrigin origin)   { return boolAtPut(name, strlen(name), value, origin); }

  static bool intxAt(char* name, size_t len, intx* value);
  static bool intxAt(char* name, intx* value)      { return intxAt(name, strlen(name), value); }
  static bool intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin);
  static bool intxAtPut(char* name, intx* value, FlagValueOrigin origin)   { return intxAtPut(name, strlen(name), value, origin); }

  static bool uintxAt(char* name, size_t len, uintx* value);
  static bool uintxAt(char* name, uintx* value)    { return uintxAt(name, strlen(name), value); }
  static bool uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin);
  static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin origin) { return uintxAtPut(name, strlen(name), value, origin); }

P
phh 已提交
326 327 328 329 330
  static bool uint64_tAt(char* name, size_t len, uint64_t* value);
  static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }
  static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin);
  static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); }

D
duke 已提交
331 332 333 334 335 336 337 338 339 340 341 342
  static bool doubleAt(char* name, size_t len, double* value);
  static bool doubleAt(char* name, double* value)    { return doubleAt(name, strlen(name), value); }
  static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);
  static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }

  static bool ccstrAt(char* name, size_t len, ccstr* value);
  static bool ccstrAt(char* name, ccstr* value)    { return ccstrAt(name, strlen(name), value); }
  static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);
  static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }

  // Returns false if name is not a command line flag.
  static bool wasSetOnCmdline(const char* name, bool* value);
F
fparain 已提交
343
  static void printSetFlags(outputStream* out);
D
duke 已提交
344

F
fparain 已提交
345
  static void printFlags(outputStream* out, bool withComments);
D
duke 已提交
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369

  static void verify() PRODUCT_RETURN;
};

// use this for flags that are true by default in the debug version but
// false in the optimized version, and vice versa
#ifdef ASSERT
#define trueInDebug  true
#define falseInDebug false
#else
#define trueInDebug  false
#define falseInDebug true
#endif

// use this for flags that are true per default in the product build
// but false in development builds, and vice versa
#ifdef PRODUCT
#define trueInProduct  true
#define falseInProduct false
#else
#define trueInProduct  false
#define falseInProduct true
#endif

370 371 372 373 374 375
#ifdef JAVASE_EMBEDDED
#define falseInEmbedded false
#else
#define falseInEmbedded true
#endif

D
duke 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
// develop flags are settable / visible only during development and are constant in the PRODUCT version
// product flags are always settable / visible
// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version

// A flag must be declared with one of the following types:
// bool, intx, uintx, ccstr.
// The type "ccstr" is an alias for "const char*" and is used
// only in this file, because the macrology requires single-token type names.

// Note: Diagnostic options not meant for VM tuning or for product modes.
// They are to be used for VM quality assurance or field diagnosis
// of VM bugs.  They are hidden so that users will not be encouraged to
// try them as if they were VM ordinary execution options.  However, they
// are available in the product version of the VM.  Under instruction
// from support engineers, VM customers can turn them on to collect
// diagnostic information about VM problems.  To use a VM diagnostic
// option, you must first specify +UnlockDiagnosticVMOptions.
// (This master switch also affects the behavior of -Xprintflags.)
394 395 396 397 398 399 400 401 402 403 404 405 406
//
// experimental flags are in support of features that are not
//    part of the officially supported product, but are available
//    for experimenting with. They could, for example, be performance
//    features that may not have undergone full or rigorous QA, but which may
//    help performance in some cases and released for experimentation
//    by the community of users and developers. This flag also allows one to
//    be able to build a fully supported product that nonetheless also
//    ships with some unsupported, lightly tested, experimental features.
//    Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
//    UnlockExperimentalVMOptions flag, which allows the control and
//    modification of the experimental flags.
//
407 408 409 410
// Nota bene: neither diagnostic nor experimental options should be used casually,
//    and they are not supported on production loads, except under explicit
//    direction from support engineers.
//
D
duke 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
// manageable flags are writeable external product flags.
//    They are dynamically writeable through the JDK management interface
//    (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
//    These flags are external exported interface (see CCC).  The list of
//    manageable flags can be queried programmatically through the management
//    interface.
//
//    A flag can be made as "manageable" only if
//    - the flag is defined in a CCC as an external exported interface.
//    - the VM implementation supports dynamic setting of the flag.
//      This implies that the VM must *always* query the flag variable
//      and not reuse state related to the flag state at any given time.
//    - you want the flag to be queried programmatically by the customers.
//
// product_rw flags are writeable internal product flags.
//    They are like "manageable" flags but for internal/private use.
//    The list of product_rw flags are internal/private flags which
//    may be changed/removed in a future release.  It can be set
//    through the management interface to get/set value
//    when the name of flag is supplied.
//
//    A flag can be made as "product_rw" only if
//    - the VM implementation supports dynamic setting of the flag.
//      This implies that the VM must *always* query the flag variable
//      and not reuse state related to the flag state at any given time.
//
// Note that when there is a need to support develop flags to be writeable,
// it can be done in the same way as product_rw.

440
#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \
441 442
                                                                            \
  lp64_product(bool, UseCompressedOops, false,                              \
443 444 445 446 447
            "Use 32-bit object references in 64-bit VM  "                   \
            "lp64_product means flag is always constant in 32 bit VM")      \
                                                                            \
  lp64_product(bool, UseCompressedKlassPointers, false,                     \
            "Use 32-bit klass pointers in 64-bit VM  "                      \
448
            "lp64_product means flag is always constant in 32 bit VM")      \
D
duke 已提交
449
                                                                            \
450 451
  notproduct(bool, CheckCompressedOops, true,                               \
            "generate checks in encoding/decoding code in debug VM")        \
452
                                                                            \
453 454 455 456 457
  product_pd(uintx, HeapBaseMinAddress,                                     \
            "OS specific low limit for heap base address")                  \
                                                                            \
  diagnostic(bool, PrintCompressedOopsMode, false,                          \
            "Print compressed oops base address and encoding mode")         \
458
                                                                            \
459 460 461
  lp64_product(intx, ObjectAlignmentInBytes, 8,                             \
          "Default object alignment in bytes, 8 is minimum")                \
                                                                            \
462 463 464
  product(bool, AssumeMP, false,                                            \
          "Instruct the VM to assume multiple processors are available")    \
                                                                            \
D
duke 已提交
465 466 467
  /* UseMembar is theoretically a temp flag used for memory barrier         \
   * removal testing.  It was supposed to be removed before FCS but has     \
   * been re-added (see 6401008) */                                         \
468
  product_pd(bool, UseMembar,                                               \
D
duke 已提交
469 470
          "(Unstable) Issues membars on thread state transitions")          \
                                                                            \
471 472 473 474 475 476 477
  /* Temp PPC Flag to allow disabling the use of lwsync on ppc platforms    \
   * that don't support it.  This will be replaced by processor detection   \
   * logic.                                                                 \
   */                                                                       \
  product(bool, UsePPCLWSYNC, true,                                         \
          "Use lwsync instruction if true, else use slower sync")           \
                                                                            \
478 479 480
  develop(bool, CleanChunkPoolAsync, falseInEmbedded,                       \
          "Whether to clean the chunk pool asynchronously")                 \
                                                                            \
481
  /* Temporary: See 6948537 */                                              \
482 483 484
  experimental(bool, UseMemSetInBOT, true,                                  \
          "(Unstable) uses memset in BOT updates in GC code")               \
                                                                            \
D
duke 已提交
485
  diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \
486 487 488 489
          "Enable normal processing of flags relating to field diagnostics")\
                                                                            \
  experimental(bool, UnlockExperimentalVMOptions, false,                    \
          "Enable normal processing of flags relating to experimental features")\
D
duke 已提交
490 491 492 493 494 495 496
                                                                            \
  product(bool, JavaMonitorsInStackTrace, true,                             \
          "Print info. about Java monitor locks when the stacks are dumped")\
                                                                            \
  product_pd(bool, UseLargePages,                                           \
          "Use large page memory")                                          \
                                                                            \
497 498 499 500 501 502
  product_pd(bool, UseLargePagesIndividualAllocation,                       \
          "Allocate large pages individually for better affinity")          \
                                                                            \
  develop(bool, LargePagesIndividualAllocationInjectError, false,           \
          "Fail large pages individual allocation")                         \
                                                                            \
D
duke 已提交
503 504 505 506 507 508
  develop(bool, TracePageSizes, false,                                      \
          "Trace page size selection and usage.")                           \
                                                                            \
  product(bool, UseNUMA, false,                                             \
          "Use NUMA if available")                                          \
                                                                            \
I
iveresov 已提交
509 510 511 512 513 514
  product(bool, UseNUMAInterleaving, false,                                 \
          "Interleave memory across NUMA nodes if available")               \
                                                                            \
  product(uintx, NUMAInterleaveGranularity, 2*M,                            \
          "Granularity to use for NUMA interleaving on Windows OS")         \
                                                                            \
515 516 517
  product(bool, ForceNUMA, false,                                           \
          "Force NUMA optimizations on single-node/UMA systems")            \
                                                                            \
518 519
  product(uintx, NUMAChunkResizeWeight, 20,                                 \
          "Percentage (0-100) used to weigh the current sample when "      \
D
duke 已提交
520 521 522
          "computing exponentially decaying average for "                   \
          "AdaptiveNUMAChunkSizing")                                        \
                                                                            \
523
  product(uintx, NUMASpaceResizeRate, 1*G,                                  \
D
duke 已提交
524 525 526 527 528 529 530 531
          "Do not reallocate more that this amount per collection")         \
                                                                            \
  product(bool, UseAdaptiveNUMAChunkSizing, true,                           \
          "Enable adaptive chunk sizing for NUMA")                          \
                                                                            \
  product(bool, NUMAStats, false,                                           \
          "Print NUMA stats in detailed heap information")                  \
                                                                            \
532
  product(uintx, NUMAPageScanRate, 256,                                     \
D
duke 已提交
533 534 535 536 537 538 539 540
          "Maximum number of pages to include in the page scan procedure")  \
                                                                            \
  product_pd(bool, NeedsDeoptSuspend,                                       \
          "True for register window machines (sparc/ia64)")                 \
                                                                            \
  product(intx, UseSSE, 99,                                                 \
          "Highest supported SSE instructions set on x86/x64")              \
                                                                            \
541 542 543
  product(bool, UseAES, false,                                               \
          "Control whether AES instructions can be used on x86/x64")        \
                                                                            \
D
duke 已提交
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
  product(uintx, LargePageSizeInBytes, 0,                                   \
          "Large page size (0 to let VM choose the page size")              \
                                                                            \
  product(uintx, LargePageHeapSizeThreshold, 128*M,                         \
          "Use large pages if max heap is at least this big")               \
                                                                            \
  product(bool, ForceTimeHighResolution, false,                             \
          "Using high time resolution(For Win32 only)")                     \
                                                                            \
  develop(bool, TraceItables, false,                                        \
          "Trace initialization and use of itables")                        \
                                                                            \
  develop(bool, TracePcPatching, false,                                     \
          "Trace usage of frame::patch_pc")                                 \
                                                                            \
  develop(bool, TraceJumps, false,                                          \
          "Trace assembly jumps in thread ring buffer")                     \
                                                                            \
  develop(bool, TraceRelocator, false,                                      \
          "Trace the bytecode relocator")                                   \
                                                                            \
  develop(bool, TraceLongCompiles, false,                                   \
          "Print out every time compilation is longer than "                \
          "a given threashold")                                             \
                                                                            \
  develop(bool, SafepointALot, false,                                       \
          "Generates a lot of safepoints. Works with "                      \
          "GuaranteedSafepointInterval")                                    \
                                                                            \
  product_pd(bool, BackgroundCompilation,                                   \
          "A thread requesting compilation is not blocked during "          \
          "compilation")                                                    \
                                                                            \
  product(bool, PrintVMQWaitTime, false,                                    \
          "Prints out the waiting time in VM operation queue")              \
                                                                            \
  develop(bool, NoYieldsInMicrolock, false,                                 \
          "Disable yields in microlock")                                    \
                                                                            \
  develop(bool, TraceOopMapGeneration, false,                               \
          "Shows oopmap generation")                                        \
                                                                            \
  product(bool, MethodFlushing, true,                                       \
          "Reclamation of zombie and not-entrant methods")                  \
                                                                            \
  develop(bool, VerifyStack, false,                                         \
          "Verify stack of each thread when it is entering a runtime call") \
                                                                            \
592 593
  diagnostic(bool, ForceUnreachable, false,                                 \
          "Make all non code cache addresses to be unreachable with forcing use of 64bit literal fixups") \
D
duke 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
                                                                            \
  notproduct(bool, StressDerivedPointers, false,                            \
          "Force scavenge when a derived pointers is detected on stack "    \
          "after rtm call")                                                 \
                                                                            \
  develop(bool, TraceDerivedPointers, false,                                \
          "Trace traversal of derived pointers on stack")                   \
                                                                            \
  notproduct(bool, TraceCodeBlobStacks, false,                              \
          "Trace stack-walk of codeblobs")                                  \
                                                                            \
  product(bool, PrintJNIResolving, false,                                   \
          "Used to implement -v:jni")                                       \
                                                                            \
  notproduct(bool, PrintRewrites, false,                                    \
          "Print methods that are being rewritten")                         \
                                                                            \
  product(bool, UseInlineCaches, true,                                      \
          "Use Inline Caches for virtual calls ")                           \
                                                                            \
  develop(bool, InlineArrayCopy, true,                                      \
          "inline arraycopy native that is known to be part of "            \
          "base library DLL")                                               \
                                                                            \
  develop(bool, InlineObjectHash, true,                                     \
          "inline Object::hashCode() native that is known to be part "      \
          "of base library DLL")                                            \
                                                                            \
  develop(bool, InlineNatives, true,                                        \
          "inline natives that are known to be part of base library DLL")   \
                                                                            \
  develop(bool, InlineMathNatives, true,                                    \
          "inline SinD, CosD, etc.")                                        \
                                                                            \
  develop(bool, InlineClassNatives, true,                                   \
          "inline Class.isInstance, etc")                                   \
                                                                            \
  develop(bool, InlineThreadNatives, true,                                  \
          "inline Thread.currentThread, etc")                               \
                                                                            \
  develop(bool, InlineUnsafeOps, true,                                      \
          "inline memory ops (native methods) from sun.misc.Unsafe")        \
                                                                            \
637 638 639 640 641 642
  product(bool, CriticalJNINatives, true,                                   \
          "check for critical JNI entry points")                            \
                                                                            \
  notproduct(bool, StressCriticalJNINatives, false,                         \
            "Exercise register saving code in critical natives")            \
                                                                            \
C
cfang 已提交
643 644 645
  product(bool, UseSSE42Intrinsics, false,                                  \
          "SSE4.2 versions of intrinsics")                                  \
                                                                            \
646 647 648
  product(bool, UseAESIntrinsics, false,                                    \
          "use intrinsics for AES versions of crypto")                      \
                                                                            \
649 650 651
  product(bool, UseCRC32Intrinsics, false,                                  \
          "use intrinsics for java.util.zip.CRC32")                         \
                                                                            \
D
duke 已提交
652 653 654 655 656 657
  develop(bool, TraceCallFixup, false,                                      \
          "traces all call fixups")                                         \
                                                                            \
  develop(bool, DeoptimizeALot, false,                                      \
          "deoptimize at every exit from the runtime system")               \
                                                                            \
K
kvn 已提交
658
  notproduct(ccstrlist, DeoptimizeOnlyAt, "",                               \
D
duke 已提交
659 660 661 662 663 664 665 666
          "a comma separated list of bcis to deoptimize at")                \
                                                                            \
  product(bool, DeoptimizeRandom, false,                                    \
          "deoptimize random frames on random exit from the runtime system")\
                                                                            \
  notproduct(bool, ZombieALot, false,                                       \
          "creates zombies (non-entrant) at exit from the runt. system")    \
                                                                            \
667 668 669
  product(bool, UnlinkSymbolsALot, false,                                   \
          "unlink unreferenced symbols from the symbol table at safepoints")\
                                                                            \
D
duke 已提交
670 671 672
  notproduct(bool, WalkStackALot, false,                                    \
          "trace stack (no print) at every exit from the runtime system")   \
                                                                            \
D
dcubed 已提交
673
  product(bool, Debugging, false,                                           \
D
duke 已提交
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
          "set when executing debug methods in debug.ccp "                  \
          "(to prevent triggering assertions)")                             \
                                                                            \
  notproduct(bool, StrictSafepointChecks, trueInDebug,                      \
          "Enable strict checks that safepoints cannot happen for threads " \
          "that used No_Safepoint_Verifier")                                \
                                                                            \
  notproduct(bool, VerifyLastFrame, false,                                  \
          "Verify oops on last frame on entry to VM")                       \
                                                                            \
  develop(bool, TraceHandleAllocation, false,                               \
          "Prints out warnings when suspicious many handles are allocated") \
                                                                            \
  product(bool, UseCompilerSafepoints, true,                                \
          "Stop at safepoints in compiled code")                            \
                                                                            \
  product(bool, FailOverToOldVerifier, true,                                \
          "fail over to old verifier when split verifier fails")            \
                                                                            \
  develop(bool, ShowSafepointMsgs, false,                                   \
          "Show msg. about safepoint synch.")                               \
                                                                            \
  product(bool, SafepointTimeout, false,                                    \
          "Time out and warn or fail after SafepointTimeoutDelay "          \
          "milliseconds if failed to reach safepoint")                      \
                                                                            \
  develop(bool, DieOnSafepointTimeout, false,                               \
          "Die upon failure to reach safepoint (see SafepointTimeout)")     \
                                                                            \
  /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */      \
  /* typically, at most a few retries are needed */                         \
  product(intx, SuspendRetryCount, 50,                                      \
          "Maximum retry count for an external suspend request")            \
                                                                            \
  product(intx, SuspendRetryDelay, 5,                                       \
          "Milliseconds to delay per retry (* current_retry_count)")        \
                                                                            \
  product(bool, AssertOnSuspendWaitFailure, false,                          \
          "Assert/Guarantee on external suspend wait failure")              \
                                                                            \
  product(bool, TraceSuspendWaitFailures, false,                            \
          "Trace external suspend wait failures")                           \
                                                                            \
  product(bool, MaxFDLimit, true,                                           \
          "Bump the number of file descriptors to max in solaris.")         \
                                                                            \
720 721 722
  diagnostic(bool, LogEvents, true,                                         \
             "Enable the various ring buffer event logs")                   \
                                                                            \
723
  diagnostic(uintx, LogEventsBufferEntries, 10,                             \
724
             "Enable the various ring buffer event logs")                   \
D
duke 已提交
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
                                                                            \
  product(bool, BytecodeVerificationRemote, true,                           \
          "Enables the Java bytecode verifier for remote classes")          \
                                                                            \
  product(bool, BytecodeVerificationLocal, false,                           \
          "Enables the Java bytecode verifier for local classes")           \
                                                                            \
  develop(bool, ForceFloatExceptions, trueInDebug,                          \
          "Force exceptions on FP stack under/overflow")                    \
                                                                            \
  develop(bool, VerifyStackAtCalls, false,                                  \
          "Verify that the stack pointer is unchanged after calls")         \
                                                                            \
  develop(bool, TraceJavaAssertions, false,                                 \
          "Trace java language assertions")                                 \
                                                                            \
  notproduct(bool, CheckAssertionStatusDirectives, false,                   \
          "temporary - see javaClasses.cpp")                                \
                                                                            \
  notproduct(bool, PrintMallocFree, false,                                  \
          "Trace calls to C heap malloc/free allocation")                   \
                                                                            \
747
  product(bool, PrintOopAddress, false,                                     \
D
duke 已提交
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
          "Always print the location of the oop")                           \
                                                                            \
  notproduct(bool, VerifyCodeCacheOften, false,                             \
          "Verify compiled-code cache often")                               \
                                                                            \
  develop(bool, ZapDeadCompiledLocals, false,                               \
          "Zap dead locals in compiler frames")                             \
                                                                            \
  notproduct(bool, ZapDeadLocalsOld, false,                                 \
          "Zap dead locals (old version, zaps all frames when "             \
          "entering the VM")                                                \
                                                                            \
  notproduct(bool, CheckOopishValues, false,                                \
          "Warn if value contains oop ( requires ZapDeadLocals)")           \
                                                                            \
  develop(bool, UseMallocOnly, false,                                       \
          "use only malloc/free for allocation (no resource area/arena)")   \
                                                                            \
  develop(bool, PrintMalloc, false,                                         \
          "print all malloc/free calls")                                    \
                                                                            \
769 770 771
  develop(bool, PrintMallocStatistics, false,                               \
          "print malloc/free statistics")                                   \
                                                                            \
D
duke 已提交
772 773 774 775 776 777 778 779 780
  develop(bool, ZapResourceArea, trueInDebug,                               \
          "Zap freed resource/arena space with 0xABABABAB")                 \
                                                                            \
  notproduct(bool, ZapVMHandleArea, trueInDebug,                            \
          "Zap freed VM handle space with 0xBCBCBCBC")                      \
                                                                            \
  develop(bool, ZapJNIHandleArea, trueInDebug,                              \
          "Zap freed JNI handle space with 0xFEFEFEFE")                     \
                                                                            \
781 782 783
  notproduct(bool, ZapStackSegments, trueInDebug,                           \
             "Zap allocated/freed Stack segments with 0xFADFADED")          \
                                                                            \
784
  develop(bool, ZapUnusedHeapArea, trueInDebug,                             \
D
duke 已提交
785 786
          "Zap unused heap space with 0xBAADBABE")                          \
                                                                            \
787 788 789 790 791 792
  develop(bool, TraceZapUnusedHeapArea, false,                              \
          "Trace zapping of unused heap space")                             \
                                                                            \
  develop(bool, CheckZapUnusedHeapArea, false,                              \
          "Check zapping of unused heap space")                             \
                                                                            \
793 794 795
  develop(bool, ZapFillerObjects, trueInDebug,                              \
          "Zap filler objects with 0xDEAFBABE")                             \
                                                                            \
D
duke 已提交
796 797 798 799 800 801 802 803 804
  develop(bool, PrintVMMessages, true,                                      \
          "Print vm messages on console")                                   \
                                                                            \
  product(bool, PrintGCApplicationConcurrentTime, false,                    \
          "Print the time the application has been running")                \
                                                                            \
  product(bool, PrintGCApplicationStoppedTime, false,                       \
          "Print the time the application has been stopped")                \
                                                                            \
805 806 807
  diagnostic(bool, VerboseVerification, false,                              \
             "Display detailed verification details")                       \
                                                                            \
808 809 810 811 812
  notproduct(uintx, ErrorHandlerTest, 0,                                    \
          "If > 0, provokes an error after VM initialization; the value"    \
          "determines which error to provoke.  See test_error_handler()"    \
          "in debug.cpp.")                                                  \
                                                                            \
D
duke 已提交
813 814 815 816 817 818 819 820 821 822 823
  develop(bool, Verbose, false,                                             \
          "Prints additional debugging information from other modes")       \
                                                                            \
  develop(bool, PrintMiscellaneous, false,                                  \
          "Prints uncategorized debugging information (requires +Verbose)") \
                                                                            \
  develop(bool, WizardMode, false,                                          \
          "Prints much more debugging information")                         \
                                                                            \
  product(bool, ShowMessageBoxOnError, false,                               \
          "Keep process alive on VM fatal error")                           \
824 825 826
                                                                            \
  product(bool, CreateMinidumpOnCrash, false,                               \
          "Create minidump on VM fatal error")                              \
D
duke 已提交
827 828 829 830 831 832 833 834 835 836 837 838 839 840
                                                                            \
  product_pd(bool, UseOSErrorReporting,                                     \
          "Let VM fatal error propagate to the OS (ie. WER on Windows)")    \
                                                                            \
  product(bool, SuppressFatalErrorMessage, false,                           \
          "Do NO Fatal Error report [Avoid deadlock]")                      \
                                                                            \
  product(ccstrlist, OnError, "",                                           \
          "Run user-defined commands on fatal error; see VMError.cpp "      \
          "for examples")                                                   \
                                                                            \
  product(ccstrlist, OnOutOfMemoryError, "",                                \
          "Run user-defined commands on first java.lang.OutOfMemoryError")  \
                                                                            \
841 842 843 844 845 846
  manageable(bool, HeapDumpBeforeFullGC, false,                             \
          "Dump heap to file before any major stop-world GC")               \
                                                                            \
  manageable(bool, HeapDumpAfterFullGC, false,                              \
          "Dump heap to file after any major stop-world GC")                \
                                                                            \
D
duke 已提交
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
  manageable(bool, HeapDumpOnOutOfMemoryError, false,                       \
          "Dump heap to file when java.lang.OutOfMemoryError is thrown")    \
                                                                            \
  manageable(ccstr, HeapDumpPath, NULL,                                     \
          "When HeapDumpOnOutOfMemoryError is on, the path (filename or"    \
          "directory) of the dump file (defaults to java_pid<pid>.hprof"    \
          "in the working directory)")                                      \
                                                                            \
  develop(uintx, SegmentedHeapDumpThreshold, 2*G,                           \
          "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) "     \
          "when the heap usage is larger than this")                        \
                                                                            \
  develop(uintx, HeapDumpSegmentSize, 1*G,                                  \
          "Approximate segment size when generating a segmented heap dump") \
                                                                            \
  develop(bool, BreakAtWarning, false,                                      \
          "Execute breakpoint upon encountering VM warning")                \
                                                                            \
  develop(bool, TraceVMOperation, false,                                    \
          "Trace vm operations")                                            \
                                                                            \
  develop(bool, UseFakeTimers, false,                                       \
          "Tells whether the VM should use system time or a fake timer")    \
                                                                            \
Z
zgu 已提交
871 872 873
  product(ccstr, NativeMemoryTracking, "off",                               \
          "Native memory tracking options")                                 \
                                                                            \
874 875 876
  diagnostic(bool, PrintNMTStatistics, false,                               \
          "Print native memory tracking summary data if it is on")          \
                                                                            \
877 878 879 880 881
  diagnostic(bool, AutoShutdownNMT, true,                                   \
          "Automatically shutdown native memory tracking under stress "     \
          "situation. When set to false, native memory tracking tries to "  \
          "stay alive at the expense of JVM performance")                   \
                                                                            \
D
duke 已提交
882 883 884 885 886 887 888 889 890
  diagnostic(bool, LogCompilation, false,                                   \
          "Log compilation activity in detail to hotspot.log or LogFile")   \
                                                                            \
  product(bool, PrintCompilation, false,                                    \
          "Print compilations")                                             \
                                                                            \
  diagnostic(bool, TraceNMethodInstalls, false,                             \
             "Trace nmethod intallation")                                   \
                                                                            \
891
  diagnostic(intx, ScavengeRootsInCode, 2,                                  \
892 893 894 895
             "0: do not allow scavengable oops in the code cache; "         \
             "1: allow scavenging from the code cache; "                    \
             "2: emit as many constants as the compiler can see")           \
                                                                            \
D
duke 已提交
896 897 898
  product(bool, AlwaysRestoreFPU, false,                                    \
          "Restore the FPU control word after every JNI call (expensive)")  \
                                                                            \
899
  diagnostic(bool, PrintCompilation2, false,                                \
D
duke 已提交
900 901
          "Print additional statistics per compilation")                    \
                                                                            \
902
  diagnostic(bool, PrintAdapterHandlers, false,                             \
D
duke 已提交
903 904
          "Print code generated for i2c/c2i adapters")                      \
                                                                            \
905 906 907
  diagnostic(bool, VerifyAdapterCalls, trueInDebug,                         \
          "Verify that i2c/c2i adapters are called properly")               \
                                                                            \
908 909 910
  develop(bool, VerifyAdapterSharing, false,                                \
          "Verify that the code for shared adapters is the equivalent")     \
                                                                            \
911 912
  diagnostic(bool, PrintAssembly, false,                                    \
          "Print assembly code (using external disassembler.so)")           \
D
duke 已提交
913
                                                                            \
914
  diagnostic(ccstr, PrintAssemblyOptions, NULL,                             \
915 916 917
          "Options string passed to disassembler.so")                       \
                                                                            \
  diagnostic(bool, PrintNMethods, false,                                    \
D
duke 已提交
918 919
          "Print assembly code for nmethods when generated")                \
                                                                            \
920
  diagnostic(bool, PrintNativeNMethods, false,                              \
D
duke 已提交
921 922 923 924 925 926 927 928 929 930 931 932 933 934
          "Print assembly code for native nmethods when generated")         \
                                                                            \
  develop(bool, PrintDebugInfo, false,                                      \
          "Print debug information for all nmethods when generated")        \
                                                                            \
  develop(bool, PrintRelocations, false,                                    \
          "Print relocation information for all nmethods when generated")   \
                                                                            \
  develop(bool, PrintDependencies, false,                                   \
          "Print dependency information for all nmethods when generated")   \
                                                                            \
  develop(bool, PrintExceptionHandlers, false,                              \
          "Print exception handler tables for all nmethods when generated") \
                                                                            \
935 936 937
  develop(bool, StressCompiledExceptionHandlers, false,                     \
         "Exercise compiled exception handlers")                            \
                                                                            \
D
duke 已提交
938 939 940 941
  develop(bool, InterceptOSException, false,                                \
          "Starts debugger when an implicit OS (e.g., NULL) "               \
          "exception happens")                                              \
                                                                            \
942 943
  product(bool, PrintCodeCache, false,                                      \
          "Print the code cache memory usage when exiting")                 \
D
duke 已提交
944 945
                                                                            \
  develop(bool, PrintCodeCache2, false,                                     \
946 947 948 949
          "Print detailed usage info on the code cache when exiting")       \
                                                                            \
  product(bool, PrintCodeCacheOnCompilation, false,                         \
          "Print the code cache memory usage each time a method is compiled") \
D
duke 已提交
950
                                                                            \
951
  diagnostic(bool, PrintStubCode, false,                                    \
D
duke 已提交
952 953 954 955 956 957 958 959 960 961 962 963 964 965
          "Print generated stub code")                                      \
                                                                            \
  product(bool, StackTraceInThrowable, true,                                \
          "Collect backtrace in throwable when exception happens")          \
                                                                            \
  product(bool, OmitStackTraceInFastThrow, true,                            \
          "Omit backtraces for some 'hot' exceptions in optimized code")    \
                                                                            \
  product(bool, ProfilerPrintByteCodeStatistics, false,                     \
          "Prints byte code statictics when dumping profiler output")       \
                                                                            \
  product(bool, ProfilerRecordPC, false,                                    \
          "Collects tick for each 16 byte interval of compiled code")       \
                                                                            \
P
phh 已提交
966
  product(bool, ProfileVM, false,                                           \
D
duke 已提交
967 968 969 970 971 972 973 974 975 976 977 978
          "Profiles ticks that fall within VM (either in the VM Thread "    \
          "or VM code called through stubs)")                               \
                                                                            \
  product(bool, ProfileIntervals, false,                                    \
          "Prints profiles for each interval (see ProfileIntervalsTicks)")  \
                                                                            \
  notproduct(bool, ProfilerCheckIntervals, false,                           \
          "Collect and print info on spacing of profiler ticks")            \
                                                                            \
  develop(bool, PrintJVMWarnings, false,                                    \
          "Prints warnings for unimplemented JVM functions")                \
                                                                            \
979 980 981
  product(bool, PrintWarnings, true,                                        \
          "Prints JVM warnings to output stream")                           \
                                                                            \
D
duke 已提交
982 983 984 985 986
  notproduct(uintx, WarnOnStalledSpinLock, 0,                               \
          "Prints warnings for stalled SpinLocks")                          \
                                                                            \
  product(bool, RegisterFinalizersAtInit, true,                             \
          "Register finalizable objects at end of Object.<init> or "        \
P
phh 已提交
987
          "after allocation")                                               \
D
duke 已提交
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
                                                                            \
  develop(bool, RegisterReferences, true,                                   \
          "Tells whether the VM should register soft/weak/final/phantom "   \
          "references")                                                     \
                                                                            \
  develop(bool, IgnoreRewrites, false,                                      \
          "Supress rewrites of bytecodes in the oopmap generator. "         \
          "This is unsafe!")                                                \
                                                                            \
  develop(bool, PrintCodeCacheExtension, false,                             \
          "Print extension of code cache")                                  \
                                                                            \
  develop(bool, UsePrivilegedStack, true,                                   \
          "Enable the security JVM functions")                              \
                                                                            \
  develop(bool, ProtectionDomainVerification, true,                         \
          "Verifies protection domain before resolution in system "         \
          "dictionary")                                                     \
                                                                            \
  product(bool, ClassUnloading, true,                                       \
          "Do unloading of classes")                                        \
                                                                            \
  develop(bool, DisableStartThread, false,                                  \
          "Disable starting of additional Java threads "                    \
          "(for debugging only)")                                           \
                                                                            \
  develop(bool, MemProfiling, false,                                        \
          "Write memory usage profiling to log file")                       \
                                                                            \
  notproduct(bool, PrintSystemDictionaryAtExit, false,                      \
          "Prints the system dictionary at exit")                           \
                                                                            \
1020 1021 1022
  experimental(intx, PredictedLoadedClassCount, 0,                          \
          "Experimental: Tune loaded class cache starting size.")           \
                                                                            \
D
duke 已提交
1023
  diagnostic(bool, UnsyncloadClass, false,                                  \
1024 1025 1026 1027 1028 1029 1030
          "Unstable: VM calls loadClass unsynchronized. Custom "            \
          "class loader  must call VM synchronized for findClass "          \
          "and defineClass.")                                               \
                                                                            \
  product(bool, AlwaysLockClassLoader, false,                               \
          "Require the VM to acquire the class loader lock before calling " \
          "loadClass() even for class loaders registering "                 \
P
phh 已提交
1031
          "as parallel capable")                                            \
1032 1033 1034
                                                                            \
  product(bool, AllowParallelDefineClass, false,                            \
          "Allow parallel defineClass requests for class loaders "          \
P
phh 已提交
1035
          "registering as parallel capable")                                \
1036 1037
                                                                            \
  product(bool, MustCallLoadClassInternal, false,                           \
P
phh 已提交
1038
          "Call loadClassInternal() rather than loadClass()")               \
D
duke 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
                                                                            \
  product_pd(bool, DontYieldALot,                                           \
          "Throw away obvious excess yield calls (for SOLARIS only)")       \
                                                                            \
  product_pd(bool, ConvertSleepToYield,                                     \
          "Converts sleep(0) to thread yield "                              \
          "(may be off for SOLARIS to improve GUI)")                        \
                                                                            \
  product(bool, ConvertYieldToSleep, false,                                 \
          "Converts yield to a sleep of MinSleepInterval to simulate Win32 "\
          "behavior (SOLARIS only)")                                        \
                                                                            \
  product(bool, UseBoundThreads, true,                                      \
          "Bind user level threads to kernel threads (for SOLARIS only)")   \
                                                                            \
  develop(bool, UseDetachedThreads, true,                                   \
          "Use detached threads that are recycled upon termination "        \
          "(for SOLARIS only)")                                             \
                                                                            \
  product(bool, UseLWPSynchronization, true,                                \
          "Use LWP-based instead of libthread-based synchronization "       \
          "(SPARC only)")                                                   \
                                                                            \
1062
  product(ccstr, SyncKnobs, NULL,                                           \
D
duke 已提交
1063 1064 1065 1066 1067 1068
          "(Unstable) Various monitor synchronization tunables")            \
                                                                            \
  product(intx, EmitSync, 0,                                                \
          "(Unsafe,Unstable) "                                              \
          " Controls emission of inline sync fast-path code")               \
                                                                            \
A
acorn 已提交
1069 1070 1071 1072
  product(intx, MonitorBound, 0, "Bound Monitor population")                \
                                                                            \
  product(bool, MonitorInUseLists, false, "Track Monitors for Deflation")   \
                                                                            \
D
duke 已提交
1073 1074 1075 1076 1077 1078
  product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
                                                                            \
  product(intx, SyncVerbose, 0, "(Unstable)" )                              \
                                                                            \
  product(intx, ClearFPUAtPark, 0, "(Unsafe,Unstable)" )                    \
                                                                            \
1079
  product(intx, hashCode, 5,                                                \
D
duke 已提交
1080 1081 1082 1083 1084 1085
         "(Unstable) select hashCode generation algorithm" )                \
                                                                            \
  product(intx, WorkAroundNPTLTimedWaitHang, 1,                             \
         "(Unstable, Linux-specific)"                                       \
         " avoid NPTL-FUTEX hang pthread_cond_timedwait" )                  \
                                                                            \
P
phh 已提交
1086 1087 1088
  product(bool, FilterSpuriousWakeups, true,                                \
          "Prevent spurious or premature wakeups from object.wait "         \
          "(Solaris only)")                                                 \
D
duke 已提交
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
                                                                            \
  product(intx, NativeMonitorTimeout, -1, "(Unstable)" )                    \
  product(intx, NativeMonitorFlags, 0, "(Unstable)" )                       \
  product(intx, NativeMonitorSpinLimit, 20, "(Unstable)" )                  \
                                                                            \
  develop(bool, UsePthreads, false,                                         \
          "Use pthread-based instead of libthread-based synchronization "   \
          "(SPARC only)")                                                   \
                                                                            \
  product(bool, AdjustConcurrency, false,                                   \
          "call thr_setconcurrency at thread create time to avoid "         \
          "LWP starvation on MP systems (For Solaris Only)")                \
                                                                            \
  product(bool, ReduceSignalUsage, false,                                   \
          "Reduce the use of OS signals in Java and/or the VM")             \
                                                                            \
  develop_pd(bool, ShareVtableStubs,                                        \
          "Share vtable stubs (smaller code but worse branch prediction")   \
                                                                            \
  develop(bool, LoadLineNumberTables, true,                                 \
          "Tells whether the class file parser loads line number tables")   \
                                                                            \
  develop(bool, LoadLocalVariableTables, true,                              \
          "Tells whether the class file parser loads local variable tables")\
                                                                            \
  develop(bool, LoadLocalVariableTypeTables, true,                          \
          "Tells whether the class file parser loads local variable type tables")\
                                                                            \
  product(bool, AllowUserSignalHandlers, false,                             \
          "Do not complain if the application installs signal handlers "    \
          "(Solaris & Linux only)")                                         \
                                                                            \
  product(bool, UseSignalChaining, true,                                    \
          "Use signal-chaining to invoke signal handlers installed "        \
          "by the application (Solaris & Linux only)")                      \
                                                                            \
  product(bool, UseAltSigs, false,                                          \
          "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM "      \
P
phh 已提交
1127
          "internal signals (Solaris only)")                                \
D
duke 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
                                                                            \
  product(bool, AllowJNIEnvProxy, false,                                    \
          "Allow JNIEnv proxies for jdbx")                                  \
                                                                            \
  product(bool, JNIDetachReleasesMonitors, true,                            \
          "JNI DetachCurrentThread releases monitors owned by thread")      \
                                                                            \
  product(bool, RestoreMXCSROnJNICalls, false,                              \
          "Restore MXCSR when returning from JNI calls")                    \
                                                                            \
  product(bool, CheckJNICalls, false,                                       \
          "Verify all arguments to JNI calls")                              \
                                                                            \
  product(bool, UseFastJNIAccessors, true,                                  \
          "Use optimized versions of Get<Primitive>Field")                  \
                                                                            \
  product(bool, EagerXrunInit, false,                                       \
          "Eagerly initialize -Xrun libraries; allows startup profiling, "  \
          " but not all -Xrun libraries may support the state of the VM at this time") \
                                                                            \
  product(bool, PreserveAllAnnotations, false,                              \
          "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations") \
                                                                            \
  develop(uintx, PreallocatedOutOfMemoryErrorCount, 4,                      \
          "Number of OutOfMemoryErrors preallocated with backtrace")        \
                                                                            \
  product(bool, LazyBootClassLoader, true,                                  \
          "Enable/disable lazy opening of boot class path entries")         \
                                                                            \
1157 1158 1159
  product(bool, UseXMMForArrayCopy, false,                                  \
          "Use SSE2 MOVQ instruction for Arraycopy")                        \
                                                                            \
D
duke 已提交
1160
  product(intx, FieldsAllocationStyle, 1,                                   \
1161 1162
          "0 - type based with oops first, 1 - with oops last, "            \
          "2 - oops in super and sub classes are together")                 \
D
duke 已提交
1163 1164 1165 1166
                                                                            \
  product(bool, CompactFields, true,                                        \
          "Allocate nonstatic fields in gaps between previous fields")      \
                                                                            \
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
  notproduct(bool, PrintFieldLayout, false,                                 \
          "Print field layout for each class")                              \
                                                                            \
  product(intx, ContendedPaddingWidth, 128,                                 \
          "How many bytes to pad the fields/classes marked @Contended with")\
                                                                            \
  product(bool, EnableContended, true,                                      \
          "Enable @Contended annotation support")                           \
                                                                            \
  product(bool, RestrictContended, true,                                    \
          "Restrict @Contended to trusted classes")                         \
                                                                            \
D
duke 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
  product(bool, UseBiasedLocking, true,                                     \
          "Enable biased locking in JVM")                                   \
                                                                            \
  product(intx, BiasedLockingStartupDelay, 4000,                            \
          "Number of milliseconds to wait before enabling biased locking")  \
                                                                            \
  diagnostic(bool, PrintBiasedLockingStatistics, false,                     \
          "Print statistics of biased locking in JVM")                      \
                                                                            \
  product(intx, BiasedLockingBulkRebiasThreshold, 20,                       \
          "Threshold of number of revocations per type to try to "          \
          "rebias all objects in the heap of that type")                    \
                                                                            \
  product(intx, BiasedLockingBulkRevokeThreshold, 40,                       \
          "Threshold of number of revocations per type to permanently "     \
          "revoke biases of all objects in the heap of that type")          \
                                                                            \
  product(intx, BiasedLockingDecayTime, 25000,                              \
          "Decay time (in milliseconds) to re-enable bulk rebiasing of a "  \
          "type after previous bulk rebias")                                \
                                                                            \
  /* tracing */                                                             \
                                                                            \
  notproduct(bool, TraceRuntimeCalls, false,                                \
          "Trace run-time calls")                                           \
                                                                            \
  develop(bool, TraceJNICalls, false,                                       \
          "Trace JNI calls")                                                \
                                                                            \
  notproduct(bool, TraceJVMCalls, false,                                    \
          "Trace JVM calls")                                                \
                                                                            \
1211
  product(ccstr, TraceJVMTI, NULL,                                          \
D
duke 已提交
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
          "Trace flags for JVMTI functions and events")                     \
                                                                            \
  /* This option can change an EMCP method into an obsolete method. */      \
  /* This can affect tests that except specific methods to be EMCP. */      \
  /* This option should be used with caution. */                            \
  product(bool, StressLdcRewrite, false,                                    \
          "Force ldc -> ldc_w rewrite during RedefineClasses")              \
                                                                            \
  product(intx, TraceRedefineClasses, 0,                                    \
          "Trace level for JVMTI RedefineClasses")                          \
                                                                            \
1223 1224 1225
  develop(bool, StressMethodComparator, false,                              \
          "run the MethodComparator on all loaded methods")                 \
                                                                            \
D
duke 已提交
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
  /* change to false by default sometime after Mustang */                   \
  product(bool, VerifyMergedCPBytecodes, true,                              \
          "Verify bytecodes after RedefineClasses constant pool merging")   \
                                                                            \
  develop(bool, TraceJNIHandleAllocation, false,                            \
          "Trace allocation/deallocation of JNI handle blocks")             \
                                                                            \
  develop(bool, TraceThreadEvents, false,                                   \
          "Trace all thread events")                                        \
                                                                            \
  develop(bool, TraceBytecodes, false,                                      \
          "Trace bytecode execution")                                       \
                                                                            \
  develop(bool, TraceClassInitialization, false,                            \
          "Trace class initialization")                                     \
                                                                            \
  develop(bool, TraceExceptions, false,                                     \
          "Trace exceptions")                                               \
                                                                            \
  develop(bool, TraceICs, false,                                            \
          "Trace inline cache changes")                                     \
                                                                            \
  notproduct(bool, TraceInvocationCounterOverflow, false,                   \
          "Trace method invocation counter overflow")                       \
                                                                            \
  develop(bool, TraceInlineCacheClearing, false,                            \
          "Trace clearing of inline caches in nmethods")                    \
                                                                            \
  develop(bool, TraceDependencies, false,                                   \
          "Trace dependencies")                                             \
                                                                            \
  develop(bool, VerifyDependencies, trueInDebug,                            \
         "Exercise and verify the compilation dependency mechanism")        \
                                                                            \
  develop(bool, TraceNewOopMapGeneration, false,                            \
          "Trace OopMapGeneration")                                         \
                                                                            \
  develop(bool, TraceNewOopMapGenerationDetailed, false,                    \
          "Trace OopMapGeneration: print detailed cell states")             \
                                                                            \
  develop(bool, TimeOopMap, false,                                          \
          "Time calls to GenerateOopMap::compute_map() in sum")             \
                                                                            \
  develop(bool, TimeOopMap2, false,                                         \
          "Time calls to GenerateOopMap::compute_map() individually")       \
                                                                            \
  develop(bool, TraceMonitorMismatch, false,                                \
          "Trace monitor matching failures during OopMapGeneration")        \
                                                                            \
  develop(bool, TraceOopMapRewrites, false,                                 \
          "Trace rewritting of method oops during oop map generation")      \
                                                                            \
  develop(bool, TraceSafepoint, false,                                      \
          "Trace safepoint operations")                                     \
                                                                            \
  develop(bool, TraceICBuffer, false,                                       \
          "Trace usage of IC buffer")                                       \
                                                                            \
  develop(bool, TraceCompiledIC, false,                                     \
          "Trace changes of compiled IC")                                   \
                                                                            \
  notproduct(bool, TraceZapDeadLocals, false,                               \
          "Trace zapping dead locals")                                      \
                                                                            \
  develop(bool, TraceStartupTime, false,                                    \
          "Trace setup time")                                               \
                                                                            \
  develop(bool, TraceProtectionDomainVerification, false,                   \
          "Trace protection domain verifcation")                            \
                                                                            \
  develop(bool, TraceClearedExceptions, false,                              \
          "Prints when an exception is forcibly cleared")                   \
                                                                            \
  product(bool, TraceClassResolution, false,                                \
          "Trace all constant pool resolutions (for debugging)")            \
                                                                            \
  product(bool, TraceBiasedLocking, false,                                  \
          "Trace biased locking in JVM")                                    \
                                                                            \
  product(bool, TraceMonitorInflation, false,                               \
          "Trace monitor inflation in JVM")                                 \
                                                                            \
  /* gc */                                                                  \
                                                                            \
  product(bool, UseSerialGC, false,                                         \
1311 1312
          "Use the serial garbage collector")                               \
                                                                            \
1313
  product(bool, UseG1GC, false,                                             \
1314
          "Use the Garbage-First garbage collector")                        \
D
duke 已提交
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
                                                                            \
  product(bool, UseParallelGC, false,                                       \
          "Use the Parallel Scavenge garbage collector")                    \
                                                                            \
  product(bool, UseParallelOldGC, false,                                    \
          "Use the Parallel Old garbage collector")                         \
                                                                            \
  product(uintx, HeapMaximumCompactionInterval, 20,                         \
          "How often should we maximally compact the heap (not allowing "   \
          "any dead space)")                                                \
                                                                            \
  product(uintx, HeapFirstMaximumCompactionCount, 3,                        \
          "The collection count for the first maximum compaction")          \
                                                                            \
  product(bool, UseMaximumCompactionOnSystemGC, true,                       \
          "In the Parallel Old garbage collector maximum compaction for "   \
          "a system GC")                                                    \
                                                                            \
  product(uintx, ParallelOldDeadWoodLimiterMean, 50,                        \
          "The mean used by the par compact dead wood"                      \
          "limiter (a number between 0-100).")                              \
                                                                            \
  product(uintx, ParallelOldDeadWoodLimiterStdDev, 80,                      \
          "The standard deviation used by the par compact dead wood"        \
          "limiter (a number between 0-100).")                              \
                                                                            \
  product(uintx, ParallelGCThreads, 0,                                      \
          "Number of parallel threads parallel gc will use")                \
                                                                            \
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
  product(bool, UseDynamicNumberOfGCThreads, false,                         \
          "Dynamically choose the number of parallel threads "              \
          "parallel gc will use")                                           \
                                                                            \
  diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
          "Force dynamic selection of the number of"                        \
          "parallel threads parallel gc will use to aid debugging")         \
                                                                            \
  product(uintx, HeapSizePerGCThread, ScaleForWordSize(64*M),               \
          "Size of heap (bytes) per GC thread used in calculating the "     \
          "number of GC threads")                                           \
                                                                            \
  product(bool, TraceDynamicGCThreads, false,                               \
          "Trace the dynamic GC thread usage")                              \
                                                                            \
1359 1360 1361
  develop(bool, ParallelOldGCSplitALot, false,                              \
          "Provoke splitting (copying data from a young gen space to"       \
          "multiple destination spaces)")                                   \
D
duke 已提交
1362
                                                                            \
1363 1364
  develop(uintx, ParallelOldGCSplitInterval, 3,                             \
          "How often to provoke splitting a young gen space")               \
D
duke 已提交
1365
                                                                            \
1366 1367
  product(uintx, ConcGCThreads, 0,                                          \
          "Number of threads concurrent gc will use")                       \
1368
                                                                            \
D
duke 已提交
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
  product(uintx, YoungPLABSize, 4096,                                       \
          "Size of young gen promotion labs (in HeapWords)")                \
                                                                            \
  product(uintx, OldPLABSize, 1024,                                         \
          "Size of old gen promotion labs (in HeapWords)")                  \
                                                                            \
  product(uintx, GCTaskTimeStampEntries, 200,                               \
          "Number of time stamp entries per gc worker thread")              \
                                                                            \
  product(bool, AlwaysTenure, false,                                        \
          "Always tenure objects in eden. (ParallelGC only)")               \
                                                                            \
  product(bool, NeverTenure, false,                                         \
P
phh 已提交
1382 1383
          "Never tenure objects in eden, May tenure on overflow "           \
          "(ParallelGC only)")                                              \
D
duke 已提交
1384 1385
                                                                            \
  product(bool, ScavengeBeforeFullGC, true,                                 \
P
phh 已提交
1386 1387
          "Scavenge youngest generation before each full GC, "              \
          "used with UseParallelGC")                                        \
D
duke 已提交
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
                                                                            \
  develop(bool, ScavengeWithObjectsInToSpace, false,                        \
          "Allow scavenges to occur when to_space contains objects.")       \
                                                                            \
  product(bool, UseConcMarkSweepGC, false,                                  \
          "Use Concurrent Mark-Sweep GC in the old generation")             \
                                                                            \
  product(bool, ExplicitGCInvokesConcurrent, false,                         \
          "A System.gc() request invokes a concurrent collection;"          \
          " (effective only when UseConcMarkSweepGC)")                      \
                                                                            \
  product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false,        \
P
phh 已提交
1400 1401 1402
          "A System.gc() request invokes a concurrent collection and "      \
          "also unloads classes during such a concurrent gc cycle "         \
          "(effective only when UseConcMarkSweepGC)")                       \
D
duke 已提交
1403
                                                                            \
1404 1405 1406 1407
  product(bool, GCLockerInvokesConcurrent, false,                           \
          "The exit of a JNI CS necessitating a scavenge also"              \
          " kicks off a bkgrd concurrent collection")                       \
                                                                            \
1408 1409 1410 1411
  product(uintx, GCLockerEdenExpansionPercent, 5,                           \
          "How much the GC can expand the eden by while the GC locker  "    \
          "is active (as a percentage)")                                    \
                                                                            \
1412 1413 1414 1415
  diagnostic(intx, GCLockerRetryAllocationCount, 2,                         \
          "Number of times to retry allocations when"                       \
          " blocked by the GC locker")                                      \
                                                                            \
D
duke 已提交
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
  develop(bool, UseCMSAdaptiveFreeLists, true,                              \
          "Use Adaptive Free Lists in the CMS generation")                  \
                                                                            \
  develop(bool, UseAsyncConcMarkSweepGC, true,                              \
          "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
                                                                            \
  develop(bool, RotateCMSCollectionTypes, false,                            \
          "Rotate the CMS collections among concurrent and STW")            \
                                                                            \
  product(bool, UseCMSBestFit, true,                                        \
          "Use CMS best fit allocation strategy")                           \
                                                                            \
  product(bool, UseCMSCollectionPassing, true,                              \
          "Use passing of collection from background to foreground")        \
                                                                            \
  product(bool, UseParNewGC, false,                                         \
          "Use parallel threads in the new generation.")                    \
                                                                            \
  product(bool, ParallelGCVerbose, false,                                   \
          "Verbose output for parallel GC.")                                \
                                                                            \
1437 1438
  product(uintx, ParallelGCBufferWastePct, 10,                              \
          "Wasted fraction of parallel allocation buffer.")                 \
D
duke 已提交
1439
                                                                            \
1440 1441 1442 1443
  diagnostic(bool, ParallelGCRetainPLAB, false,                             \
             "Retain parallel allocation buffers across scavenges; "        \
             " -- disabled because this currently conflicts with "          \
             " parallel card scanning under certain conditions ")           \
D
duke 已提交
1444
                                                                            \
1445 1446 1447
  product(uintx, TargetPLABWastePct, 10,                                    \
          "Target wasted space in last buffer as percent of overall "       \
          "allocation")                                                     \
D
duke 已提交
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
                                                                            \
  product(uintx, PLABWeight, 75,                                            \
          "Percentage (0-100) used to weight the current sample when"       \
          "computing exponentially decaying average for ResizePLAB.")       \
                                                                            \
  product(bool, ResizePLAB, true,                                           \
          "Dynamically resize (survivor space) promotion labs")             \
                                                                            \
  product(bool, PrintPLAB, false,                                           \
          "Print (survivor space) promotion labs sizing decisions")         \
                                                                            \
  product(intx, ParGCArrayScanChunk, 50,                                    \
          "Scan a subset and push remainder, if array is bigger than this") \
                                                                            \
1462 1463 1464
  product(bool, ParGCUseLocalOverflow, false,                               \
          "Instead of a global overflow list, use local overflow stacks")   \
                                                                            \
1465
  product(bool, ParGCTrimOverflow, true,                                    \
1466
          "Eagerly trim the local overflow lists (when ParGCUseLocalOverflow") \
1467
                                                                            \
1468 1469 1470 1471
  notproduct(bool, ParGCWorkQueueOverflowALot, false,                       \
          "Whether we should simulate work queue overflow in ParNew")       \
                                                                            \
  notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000,                   \
P
phh 已提交
1472 1473
          "An `interval' counter that determines how frequently "           \
          "we simulate overflow; a smaller number increases frequency")     \
1474 1475
                                                                            \
  product(uintx, ParGCDesiredObjsFromOverflowList, 20,                      \
D
duke 已提交
1476 1477
          "The desired number of objects to claim from the overflow list")  \
                                                                            \
1478
  diagnostic(uintx, ParGCStridesPerThread, 2,                               \
1479 1480 1481 1482 1483 1484 1485 1486
          "The number of strides per worker thread that we divide up the "  \
          "card table scanning work into")                                  \
                                                                            \
  diagnostic(intx, ParGCCardsPerStrideChunk, 256,                           \
          "The number of cards in each chunk of the parallel chunks used "  \
          "during card table scanning")                                     \
                                                                            \
  product(uintx, CMSParPromoteBlocksToClaim, 16,                            \
D
duke 已提交
1487 1488 1489
          "Number of blocks to attempt to claim when refilling CMS LAB for "\
          "parallel GC.")                                                   \
                                                                            \
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
  product(uintx, OldPLABWeight, 50,                                         \
          "Percentage (0-100) used to weight the current sample when"       \
          "computing exponentially decaying average for resizing CMSParPromoteBlocksToClaim.") \
                                                                            \
  product(bool, ResizeOldPLAB, true,                                        \
          "Dynamically resize (old gen) promotion labs")                    \
                                                                            \
  product(bool, PrintOldPLAB, false,                                        \
          "Print (old gen) promotion labs sizing decisions")                \
                                                                            \
  product(uintx, CMSOldPLABMin, 16,                                         \
          "Min size of CMS gen promotion lab caches per worker per blksize")\
                                                                            \
  product(uintx, CMSOldPLABMax, 1024,                                       \
          "Max size of CMS gen promotion lab caches per worker per blksize")\
                                                                            \
  product(uintx, CMSOldPLABNumRefills, 4,                                   \
          "Nominal number of refills of CMS gen promotion lab cache"        \
          " per worker per block size")                                     \
                                                                            \
  product(bool, CMSOldPLABResizeQuicker, false,                             \
          "Whether to react on-the-fly during a scavenge to a sudden"       \
          " change in block demand rate")                                   \
                                                                            \
  product(uintx, CMSOldPLABToleranceFactor, 4,                              \
          "The tolerance of the phase-change detector for on-the-fly"       \
          " PLAB resizing during a scavenge")                               \
                                                                            \
  product(uintx, CMSOldPLABReactivityFactor, 2,                             \
          "The gain in the feedback loop for on-the-fly PLAB resizing"      \
          " during a scavenge")                                             \
                                                                            \
D
duke 已提交
1522 1523 1524
  product(bool, AlwaysPreTouch, false,                                      \
          "It forces all freshly committed pages to be pre-touched.")       \
                                                                            \
1525
  product_pd(uintx, CMSYoungGenPerWorker,                                   \
1526
          "The maximum size of young gen chosen by default per GC worker "  \
P
phh 已提交
1527
          "thread available")                                               \
D
duke 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
                                                                            \
  product(bool, CMSIncrementalMode, false,                                  \
          "Whether CMS GC should operate in \"incremental\" mode")          \
                                                                            \
  product(uintx, CMSIncrementalDutyCycle, 10,                               \
          "CMS incremental mode duty cycle (a percentage, 0-100).  If"      \
          "CMSIncrementalPacing is enabled, then this is just the initial"  \
          "value")                                                          \
                                                                            \
  product(bool, CMSIncrementalPacing, true,                                 \
          "Whether the CMS incremental mode duty cycle should be "          \
          "automatically adjusted")                                         \
                                                                            \
  product(uintx, CMSIncrementalDutyCycleMin, 0,                             \
P
phh 已提交
1542 1543
          "Lower bound on the duty cycle when CMSIncrementalPacing is "     \
          "enabled (a percentage, 0-100)")                                  \
D
duke 已提交
1544 1545
                                                                            \
  product(uintx, CMSIncrementalSafetyFactor, 10,                            \
P
phh 已提交
1546 1547
          "Percentage (0-100) used to add conservatism when computing the " \
          "duty cycle")                                                     \
D
duke 已提交
1548 1549 1550
                                                                            \
  product(uintx, CMSIncrementalOffset, 0,                                   \
          "Percentage (0-100) by which the CMS incremental mode duty cycle" \
P
phh 已提交
1551
          " is shifted to the right within the period between young GCs")   \
D
duke 已提交
1552
                                                                            \
1553 1554 1555
  product(uintx, CMSExpAvgFactor, 50,                                       \
          "Percentage (0-100) used to weight the current sample when"       \
          "computing exponential averages for CMS statistics.")             \
D
duke 已提交
1556
                                                                            \
1557 1558 1559
  product(uintx, CMS_FLSWeight, 75,                                         \
          "Percentage (0-100) used to weight the current sample when"       \
          "computing exponentially decating averages for CMS FLS statistics.") \
D
duke 已提交
1560
                                                                            \
1561 1562
  product(uintx, CMS_FLSPadding, 1,                                         \
          "The multiple of deviation from mean to use for buffering"        \
D
duke 已提交
1563 1564 1565 1566 1567
          "against volatility in free list demand.")                        \
                                                                            \
  product(uintx, FLSCoalescePolicy, 2,                                      \
          "CMS: Aggression level for coalescing, increasing from 0 to 4")   \
                                                                            \
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
  product(bool, FLSAlwaysCoalesceLarge, false,                              \
          "CMS: Larger free blocks are always available for coalescing")    \
                                                                            \
  product(double, FLSLargestBlockCoalesceProximity, 0.99,                   \
          "CMS: the smaller the percentage the greater the coalition force")\
                                                                            \
  product(double, CMSSmallCoalSurplusPercent, 1.05,                         \
          "CMS: the factor by which to inflate estimated demand of small"   \
          " block sizes to prevent coalescing with an adjoining block")     \
                                                                            \
  product(double, CMSLargeCoalSurplusPercent, 0.95,                         \
          "CMS: the factor by which to inflate estimated demand of large"   \
          " block sizes to prevent coalescing with an adjoining block")     \
                                                                            \
  product(double, CMSSmallSplitSurplusPercent, 1.10,                        \
          "CMS: the factor by which to inflate estimated demand of small"   \
          " block sizes to prevent splitting to supply demand for smaller"  \
          " blocks")                                                        \
                                                                            \
  product(double, CMSLargeSplitSurplusPercent, 1.00,                        \
          "CMS: the factor by which to inflate estimated demand of large"   \
          " block sizes to prevent splitting to supply demand for smaller"  \
          " blocks")                                                        \
                                                                            \
  product(bool, CMSExtrapolateSweep, false,                                 \
          "CMS: cushion for block demand during sweep")                     \
                                                                            \
  product(uintx, CMS_SweepWeight, 75,                                       \
P
phh 已提交
1596 1597 1598
          "Percentage (0-100) used to weight the current sample when "      \
          "computing exponentially decaying average for inter-sweep "       \
          "duration")                                                       \
D
duke 已提交
1599
                                                                            \
1600
  product(uintx, CMS_SweepPadding, 1,                                       \
P
phh 已提交
1601
          "The multiple of deviation from mean to use for buffering "       \
D
duke 已提交
1602 1603 1604 1605
          "against volatility in inter-sweep duration.")                    \
                                                                            \
  product(uintx, CMS_SweepTimerThresholdMillis, 10,                         \
          "Skip block flux-rate sampling for an epoch unless inter-sweep "  \
P
phh 已提交
1606
          "duration exceeds this threhold in milliseconds")                 \
D
duke 已提交
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
                                                                            \
  develop(bool, CMSTraceIncrementalMode, false,                             \
          "Trace CMS incremental mode")                                     \
                                                                            \
  develop(bool, CMSTraceIncrementalPacing, false,                           \
          "Trace CMS incremental mode pacing computation")                  \
                                                                            \
  develop(bool, CMSTraceThreadState, false,                                 \
          "Trace the CMS thread state (enable the trace_state() method)")   \
                                                                            \
1617
  product(bool, CMSClassUnloadingEnabled, true,                             \
D
duke 已提交
1618 1619
          "Whether class unloading enabled when using CMS GC")              \
                                                                            \
1620 1621 1622 1623
  product(uintx, CMSClassUnloadingMaxInterval, 0,                           \
          "When CMS class unloading is enabled, the maximum CMS cycle count"\
          " for which classes may not be unloaded")                         \
                                                                            \
D
duke 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
  product(bool, CMSCompactWhenClearAllSoftRefs, true,                       \
          "Compact when asked to collect CMS gen with clear_all_soft_refs") \
                                                                            \
  product(bool, UseCMSCompactAtFullCollection, true,                        \
          "Use mark sweep compact at full collections")                     \
                                                                            \
  product(uintx, CMSFullGCsBeforeCompaction, 0,                             \
          "Number of CMS full collection done before compaction if > 0")    \
                                                                            \
  develop(intx, CMSDictionaryChoice, 0,                                     \
          "Use BinaryTreeDictionary as default in the CMS generation")      \
                                                                            \
  product(uintx, CMSIndexedFreeListReplenish, 4,                            \
1637
          "Replenish an indexed free list with this number of chunks")      \
D
duke 已提交
1638
                                                                            \
1639 1640 1641 1642
  product(bool, CMSReplenishIntermediate, true,                             \
          "Replenish all intermediate free-list caches")                    \
                                                                            \
  product(bool, CMSSplitIndexedFreeListBlocks, true,                        \
1643
          "When satisfying batched demand, split blocks from the "          \
1644 1645
          "IndexedFreeList whose size is a multiple of requested size")     \
                                                                            \
D
duke 已提交
1646 1647 1648 1649 1650 1651
  product(bool, CMSLoopWarn, false,                                         \
          "Warn in case of excessive CMS looping")                          \
                                                                            \
  develop(bool, CMSOverflowEarlyRestoration, false,                         \
          "Whether preserved marks should be restored early")               \
                                                                            \
1652 1653
  product(uintx, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M),              \
          "Size of marking stack")                                          \
D
duke 已提交
1654
                                                                            \
1655 1656
  product(uintx, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M),          \
          "Max size of marking stack")                                      \
D
duke 已提交
1657 1658 1659 1660 1661
                                                                            \
  notproduct(bool, CMSMarkStackOverflowALot, false,                         \
          "Whether we should simulate frequent marking stack / work queue"  \
          " overflow")                                                      \
                                                                            \
1662 1663
  notproduct(uintx, CMSMarkStackOverflowInterval, 1000,                     \
          "An `interval' counter that determines how frequently"            \
D
duke 已提交
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
          " we simulate overflow; a smaller number increases frequency")    \
                                                                            \
  product(uintx, CMSMaxAbortablePrecleanLoops, 0,                           \
          "(Temporary, subject to experimentation)"                         \
          "Maximum number of abortable preclean iterations, if > 0")        \
                                                                            \
  product(intx, CMSMaxAbortablePrecleanTime, 5000,                          \
          "(Temporary, subject to experimentation)"                         \
          "Maximum time in abortable preclean in ms")                       \
                                                                            \
  product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100,              \
          "(Temporary, subject to experimentation)"                         \
          "Nominal minimum work per abortable preclean iteration")          \
                                                                            \
1678
  manageable(intx, CMSAbortablePrecleanWaitMillis, 100,                     \
D
duke 已提交
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
          "(Temporary, subject to experimentation)"                         \
          " Time that we sleep between iterations when not given"           \
          " enough work per iteration")                                     \
                                                                            \
  product(uintx, CMSRescanMultiple, 32,                                     \
          "Size (in cards) of CMS parallel rescan task")                    \
                                                                            \
  product(uintx, CMSConcMarkMultiple, 32,                                   \
          "Size (in cards) of CMS concurrent MT marking task")              \
                                                                            \
  product(bool, CMSAbortSemantics, false,                                   \
          "Whether abort-on-overflow semantics is implemented")             \
                                                                            \
  product(bool, CMSParallelRemarkEnabled, true,                             \
          "Whether parallel remark enabled (only if ParNewGC)")             \
                                                                            \
  product(bool, CMSParallelSurvivorRemarkEnabled, true,                     \
          "Whether parallel remark of survivor space"                       \
          " enabled (effective only if CMSParallelRemarkEnabled)")          \
                                                                            \
  product(bool, CMSPLABRecordAlways, true,                                  \
          "Whether to always record survivor space PLAB bdries"             \
          " (effective only if CMSParallelSurvivorRemarkEnabled)")          \
                                                                            \
  product(bool, CMSConcurrentMTEnabled, true,                               \
          "Whether multi-threaded concurrent work enabled (if ParNewGC)")   \
                                                                            \
  product(bool, CMSPrecleaningEnabled, true,                                \
          "Whether concurrent precleaning enabled")                         \
                                                                            \
  product(uintx, CMSPrecleanIter, 3,                                        \
          "Maximum number of precleaning iteration passes")                 \
                                                                            \
  product(uintx, CMSPrecleanNumerator, 2,                                   \
          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence"  \
          " ratio")                                                         \
                                                                            \
  product(uintx, CMSPrecleanDenominator, 3,                                 \
          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence"  \
          " ratio")                                                         \
                                                                            \
1720
  product(bool, CMSPrecleanRefLists1, true,                                 \
D
duke 已提交
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
          "Preclean ref lists during (initial) preclean phase")             \
                                                                            \
  product(bool, CMSPrecleanRefLists2, false,                                \
          "Preclean ref lists during abortable preclean phase")             \
                                                                            \
  product(bool, CMSPrecleanSurvivors1, false,                               \
          "Preclean survivors during (initial) preclean phase")             \
                                                                            \
  product(bool, CMSPrecleanSurvivors2, true,                                \
          "Preclean survivors during abortable preclean phase")             \
                                                                            \
  product(uintx, CMSPrecleanThreshold, 1000,                                \
          "Don't re-iterate if #dirty cards less than this")                \
                                                                            \
  product(bool, CMSCleanOnEnter, true,                                      \
          "Clean-on-enter optimization for reducing number of dirty cards") \
                                                                            \
  product(uintx, CMSRemarkVerifyVariant, 1,                                 \
          "Choose variant (1,2) of verification following remark")          \
                                                                            \
  product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M,                   \
          "If Eden used is below this value, don't try to schedule remark") \
                                                                            \
  product(uintx, CMSScheduleRemarkEdenPenetration, 50,                      \
          "The Eden occupancy % at which to try and schedule remark pause") \
                                                                            \
  product(uintx, CMSScheduleRemarkSamplingRatio, 5,                         \
          "Start sampling Eden top at least before yg occupancy reaches"    \
          " 1/<ratio> of the size at which we plan to schedule remark")     \
                                                                            \
  product(uintx, CMSSamplingGrain, 16*K,                                    \
          "The minimum distance between eden samples for CMS (see above)")  \
                                                                            \
  product(bool, CMSScavengeBeforeRemark, false,                             \
          "Attempt scavenge before the CMS remark step")                    \
                                                                            \
  develop(bool, CMSTraceSweeper, false,                                     \
          "Trace some actions of the CMS sweeper")                          \
                                                                            \
  product(uintx, CMSWorkQueueDrainThreshold, 10,                            \
          "Don't drain below this size per parallel worker/thief")          \
                                                                            \
1763
  manageable(intx, CMSWaitDuration, 2000,                                   \
D
duke 已提交
1764 1765
          "Time in milliseconds that CMS thread waits for young GC")        \
                                                                            \
1766 1767 1768 1769
  develop(uintx, CMSCheckInterval, 1000,                                    \
          "Interval in milliseconds that CMS thread checks if it "          \
          "should start a collection cycle")                                \
                                                                            \
D
duke 已提交
1770 1771 1772 1773 1774 1775 1776
  product(bool, CMSYield, true,                                             \
          "Yield between steps of concurrent mark & sweep")                 \
                                                                            \
  product(uintx, CMSBitMapYieldQuantum, 10*M,                               \
          "Bitmap operations should process at most this many bits"         \
          "between yields")                                                 \
                                                                            \
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
  product(bool, CMSDumpAtPromotionFailure, false,                           \
          "Dump useful information about the state of the CMS old "         \
          " generation upon a promotion failure.")                          \
                                                                            \
  product(bool, CMSPrintChunksInDump, false,                                \
          "In a dump enabled by CMSDumpAtPromotionFailure, include "        \
          " more detailed information about the free chunks.")              \
                                                                            \
  product(bool, CMSPrintObjectsInDump, false,                               \
          "In a dump enabled by CMSDumpAtPromotionFailure, include "        \
          " more detailed information about the allocated objects.")        \
                                                                            \
D
duke 已提交
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
  diagnostic(bool, FLSVerifyAllHeapReferences, false,                       \
          "Verify that all refs across the FLS boundary "                   \
          " are to valid objects")                                          \
                                                                            \
  diagnostic(bool, FLSVerifyLists, false,                                   \
          "Do lots of (expensive) FreeListSpace verification")              \
                                                                            \
  diagnostic(bool, FLSVerifyIndexTable, false,                              \
          "Do lots of (expensive) FLS index table verification")            \
                                                                            \
  develop(bool, FLSVerifyDictionary, false,                                 \
          "Do lots of (expensive) FLS dictionary verification")             \
                                                                            \
  develop(bool, VerifyBlockOffsetArray, false,                              \
          "Do (expensive!) block offset array verification")                \
                                                                            \
1805
  diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false,              \
D
duke 已提交
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
          "Maintain _unallocated_block in BlockOffsetArray"                 \
          " (currently applicable only to CMS collector)")                  \
                                                                            \
  develop(bool, TraceCMSState, false,                                       \
          "Trace the state of the CMS collection")                          \
                                                                            \
  product(intx, RefDiscoveryPolicy, 0,                                      \
          "Whether reference-based(0) or referent-based(1)")                \
                                                                            \
  product(bool, ParallelRefProcEnabled, false,                              \
          "Enable parallel reference processing whenever possible")         \
                                                                            \
  product(bool, ParallelRefProcBalancingEnabled, true,                      \
          "Enable balancing of reference processing queues")                \
                                                                            \
1821
  product(uintx, CMSTriggerRatio, 80,                                       \
D
duke 已提交
1822
          "Percentage of MinHeapFreeRatio in CMS generation that is "       \
P
phh 已提交
1823
          "allocated before a CMS collection cycle commences")              \
D
duke 已提交
1824
                                                                            \
1825
  product(uintx, CMSBootstrapOccupancy, 50,                                 \
D
duke 已提交
1826
          "Percentage CMS generation occupancy at which to "                \
P
phh 已提交
1827
          "initiate CMS collection for bootstrapping collection stats")     \
D
duke 已提交
1828 1829 1830
                                                                            \
  product(intx, CMSInitiatingOccupancyFraction, -1,                         \
          "Percentage CMS generation occupancy to start a CMS collection "  \
P
phh 已提交
1831
          "cycle. A negative value means that CMSTriggerRatio is used")     \
1832
                                                                            \
1833 1834
  product(uintx, InitiatingHeapOccupancyPercent, 45,                        \
          "Percentage of the (entire) heap occupancy to start a "           \
1835
          "concurrent GC cycle. It is used by GCs that trigger a "          \
1836 1837 1838 1839
          "concurrent GC cycle based on the occupancy of the entire heap, " \
          "not just one of the generations (e.g., G1). A value of 0 "       \
          "denotes 'do constant GC cycles'.")                               \
                                                                            \
D
duke 已提交
1840 1841 1842
  product(bool, UseCMSInitiatingOccupancyOnly, false,                       \
          "Only use occupancy as a crierion for starting a CMS collection") \
                                                                            \
1843
  product(uintx, CMSIsTooFullPercentage, 98,                                \
P
phh 已提交
1844
          "An absolute ceiling above which CMS will always consider the "   \
1845
          "unloading of classes when class unloading is enabled")           \
1846
                                                                            \
D
duke 已提交
1847 1848
  develop(bool, CMSTestInFreeList, false,                                   \
          "Check if the coalesced range is already in the "                 \
P
phh 已提交
1849
          "free lists as claimed")                                          \
D
duke 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
                                                                            \
  notproduct(bool, CMSVerifyReturnedBytes, false,                           \
          "Check that all the garbage collected was returned to the "       \
          "free lists.")                                                    \
                                                                            \
  notproduct(bool, ScavengeALot, false,                                     \
          "Force scavenge at every Nth exit from the runtime system "       \
          "(N=ScavengeALotInterval)")                                       \
                                                                            \
  develop(bool, FullGCALot, false,                                          \
          "Force full gc at every Nth exit from the runtime system "        \
          "(N=FullGCALotInterval)")                                         \
                                                                            \
  notproduct(bool, GCALotAtAllSafepoints, false,                            \
          "Enforce ScavengeALot/GCALot at all potential safepoints")        \
                                                                            \
1866 1867 1868 1869
  product(bool, PrintPromotionFailure, false,                               \
          "Print additional diagnostic information following "              \
          " promotion failure")                                             \
                                                                            \
D
duke 已提交
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
  notproduct(bool, PromotionFailureALot, false,                             \
          "Use promotion failure handling on every youngest generation "    \
          "collection")                                                     \
                                                                            \
  develop(uintx, PromotionFailureALotCount, 1000,                           \
          "Number of promotion failures occurring at ParGCAllocBuffer"      \
          "refill attempts (ParNew) or promotion attempts "                 \
          "(other young collectors) ")                                      \
                                                                            \
  develop(uintx, PromotionFailureALotInterval, 5,                           \
          "Total collections between promotion failures alot")              \
                                                                            \
1882
  experimental(uintx, WorkStealingSleepMillis, 1,                           \
D
duke 已提交
1883 1884
          "Sleep time when sleep is used for yields")                       \
                                                                            \
1885
  experimental(uintx, WorkStealingYieldsBeforeSleep, 5000,                  \
D
duke 已提交
1886 1887
          "Number of yields before a sleep is done during workstealing")    \
                                                                            \
1888
  experimental(uintx, WorkStealingHardSpins, 4096,                          \
1889 1890 1891
          "Number of iterations in a spin loop between checks on "          \
          "time out of hard spin")                                          \
                                                                            \
1892
  experimental(uintx, WorkStealingSpinToYieldRatio, 10,                     \
1893 1894
          "Ratio of hard spins to calls to yield")                          \
                                                                            \
1895 1896 1897 1898
  develop(uintx, ObjArrayMarkingStride, 512,                                \
          "Number of ObjArray elements to push onto the marking stack"      \
          "before pushing a continuation entry")                            \
                                                                            \
1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
  develop(bool, MetadataAllocationFailALot, false,                          \
          "Fail metadata allocations at intervals controlled by "           \
          "MetadataAllocationFailALotInterval")                             \
                                                                            \
  develop(uintx, MetadataAllocationFailALotInterval, 1000,                  \
          "metadata allocation failure alot interval")                      \
                                                                            \
  develop(bool, MetaDataDeallocateALot, false,                              \
          "Deallocation bunches of metadata at intervals controlled by "    \
          "MetaDataAllocateALotInterval")                                   \
                                                                            \
  develop(uintx, MetaDataDeallocateALotInterval, 100,                       \
          "Metadata deallocation alot interval")                            \
                                                                            \
  develop(bool, TraceMetadataChunkAllocation, false,                        \
1914
          "Trace chunk metadata allocations")                               \
1915 1916 1917 1918 1919
                                                                            \
  product(bool, TraceMetadataHumongousAllocation, false,                    \
          "Trace humongous metadata allocations")                           \
                                                                            \
  develop(bool, TraceMetavirtualspaceAllocation, false,                     \
1920
          "Trace virtual space metadata allocations")                       \
1921
                                                                            \
1922 1923 1924
  notproduct(bool, ExecuteInternalVMTests, false,                           \
          "Enable execution of internal VM tests.")                         \
                                                                            \
D
duke 已提交
1925 1926 1927 1928 1929 1930 1931 1932
  product_pd(bool, UseTLAB, "Use thread-local object allocation")           \
                                                                            \
  product_pd(bool, ResizeTLAB,                                              \
          "Dynamically resize tlab size for threads")                       \
                                                                            \
  product(bool, ZeroTLAB, false,                                            \
          "Zero out the newly created TLAB")                                \
                                                                            \
1933 1934 1935
  product(bool, FastTLABRefill, true,                                       \
          "Use fast TLAB refill code")                                      \
                                                                            \
D
duke 已提交
1936 1937 1938 1939 1940 1941
  product(bool, PrintTLAB, false,                                           \
          "Print various TLAB related information")                         \
                                                                            \
  product(bool, TLABStats, true,                                            \
          "Print various TLAB related information")                         \
                                                                            \
1942 1943 1944
  EMBEDDED_ONLY(product(bool, LowMemoryProtection, true,                    \
          "Enable LowMemoryProtection"))                                    \
                                                                            \
D
duke 已提交
1945 1946 1947 1948 1949 1950
  product_pd(bool, NeverActAsServerClassMachine,                            \
          "Never act like a server-class machine")                          \
                                                                            \
  product(bool, AlwaysActAsServerClassMachine, false,                       \
          "Always act like a server-class machine")                         \
                                                                            \
P
phh 已提交
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
  product_pd(uint64_t, MaxRAM,                                              \
          "Real memory size (in bytes) used to set maximum heap size")      \
                                                                            \
  product(uintx, ErgoHeapSizeLimit, 0,                                      \
          "Maximum ergonomically set heap size (in bytes); zero means use " \
          "MaxRAM / MaxRAMFraction")                                        \
                                                                            \
  product(uintx, MaxRAMFraction, 4,                                         \
          "Maximum fraction (1/n) of real memory used for maximum heap "    \
          "size")                                                           \
D
duke 已提交
1961 1962
                                                                            \
  product(uintx, DefaultMaxRAMFraction, 4,                                  \
P
phh 已提交
1963 1964
          "Maximum fraction (1/n) of real memory used for maximum heap "    \
          "size; deprecated: to be renamed to MaxRAMFraction")              \
D
duke 已提交
1965
                                                                            \
P
phh 已提交
1966 1967 1968 1969 1970 1971
  product(uintx, MinRAMFraction, 2,                                         \
          "Minimum fraction (1/n) of real memory used for maxmimum heap "   \
          "size on systems with small physical memory size")                \
                                                                            \
  product(uintx, InitialRAMFraction, 64,                                    \
          "Fraction (1/n) of real memory used for initial heap size")       \
D
duke 已提交
1972
                                                                            \
1973 1974 1975 1976
  develop(uintx, MaxVirtMemFraction, 2,                                     \
          "Maximum fraction (1/n) of virtual memory used for ergonomically" \
          "determining maximum heap size")                                  \
                                                                            \
D
duke 已提交
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
  product(bool, UseAutoGCSelectPolicy, false,                               \
          "Use automatic collection selection policy")                      \
                                                                            \
  product(uintx, AutoGCSelectPauseMillis, 5000,                             \
          "Automatic GC selection pause threshhold in ms")                  \
                                                                            \
  product(bool, UseAdaptiveSizePolicy, true,                                \
          "Use adaptive generation sizing policies")                        \
                                                                            \
  product(bool, UsePSAdaptiveSurvivorSizePolicy, true,                      \
          "Use adaptive survivor sizing policies")                          \
                                                                            \
  product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true,     \
          "Use adaptive young-old sizing policies at minor collections")    \
                                                                            \
  product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true,     \
          "Use adaptive young-old sizing policies at major collections")    \
                                                                            \
  product(bool, UseAdaptiveSizePolicyWithSystemGC, false,                   \
          "Use statistics from System.GC for adaptive size policy")         \
                                                                            \
  product(bool, UseAdaptiveGCBoundary, false,                               \
          "Allow young-old boundary to move")                               \
                                                                            \
  develop(bool, TraceAdaptiveGCBoundary, false,                             \
          "Trace young-old boundary moves")                                 \
                                                                            \
  develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1,             \
          "Resize the virtual spaces of the young or old generations")      \
                                                                            \
  product(uintx, AdaptiveSizeThroughPutPolicy, 0,                           \
          "Policy for changeing generation size for throughput goals")      \
                                                                            \
  product(uintx, AdaptiveSizePausePolicy, 0,                                \
          "Policy for changing generation size for pause goals")            \
                                                                            \
  develop(bool, PSAdjustTenuredGenForMinorPause, false,                     \
          "Adjust tenured generation to achive a minor pause goal")         \
                                                                            \
  develop(bool, PSAdjustYoungGenForMajorPause, false,                       \
          "Adjust young generation to achive a major pause goal")           \
                                                                            \
  product(uintx, AdaptiveSizePolicyInitializingSteps, 20,                   \
          "Number of steps where heuristics is used before data is used")   \
                                                                            \
  develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
          "Number of collections before the adaptive sizing is started")    \
                                                                            \
  product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
2026
          "Collection interval for printing information; zero means never") \
D
duke 已提交
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
                                                                            \
  product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
          "Use adaptive minimum footprint as a goal")                       \
                                                                            \
  product(uintx, AdaptiveSizePolicyWeight, 10,                              \
          "Weight given to exponential resizing, between 0 and 100")        \
                                                                            \
  product(uintx, AdaptiveTimeWeight,       25,                              \
          "Weight given to time in adaptive policy, between 0 and 100")     \
                                                                            \
  product(uintx, PausePadding, 1,                                           \
          "How much buffer to keep for pause time")                         \
                                                                            \
  product(uintx, PromotedPadding, 3,                                        \
          "How much buffer to keep for promotion failure")                  \
                                                                            \
  product(uintx, SurvivorPadding, 3,                                        \
          "How much buffer to keep for survivor overflow")                  \
                                                                            \
  product(uintx, ThresholdTolerance, 10,                                    \
          "Allowed collection cost difference between generations")         \
                                                                            \
  product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50,                \
P
phh 已提交
2050 2051
          "If collection costs are within margin, reduce both by full "     \
          "delta")                                                          \
D
duke 已提交
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
                                                                            \
  product(uintx, YoungGenerationSizeIncrement, 20,                          \
          "Adaptive size percentage change in young generation")            \
                                                                            \
  product(uintx, YoungGenerationSizeSupplement, 80,                         \
          "Supplement to YoungedGenerationSizeIncrement used at startup")   \
                                                                            \
  product(uintx, YoungGenerationSizeSupplementDecay, 8,                     \
          "Decay factor to YoungedGenerationSizeSupplement")                \
                                                                            \
  product(uintx, TenuredGenerationSizeIncrement, 20,                        \
          "Adaptive size percentage change in tenured generation")          \
                                                                            \
  product(uintx, TenuredGenerationSizeSupplement, 80,                       \
          "Supplement to TenuredGenerationSizeIncrement used at startup")   \
                                                                            \
  product(uintx, TenuredGenerationSizeSupplementDecay, 2,                   \
          "Decay factor to TenuredGenerationSizeIncrement")                 \
                                                                            \
2071
  product(uintx, MaxGCPauseMillis, max_uintx,                               \
J
johnc 已提交
2072 2073 2074
          "Adaptive size policy maximum GC pause time goal in msec, "       \
          "or (G1 Only) the max. GC time per MMU time slice")               \
                                                                            \
2075
  product(uintx, GCPauseIntervalMillis, 0,                                  \
J
johnc 已提交
2076
          "Time slice for MMU specification")                               \
D
duke 已提交
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
                                                                            \
  product(uintx, MaxGCMinorPauseMillis, max_uintx,                          \
          "Adaptive size policy maximum GC minor pause time goal in msec")  \
                                                                            \
  product(uintx, GCTimeRatio, 99,                                           \
          "Adaptive size policy application time to GC time ratio")         \
                                                                            \
  product(uintx, AdaptiveSizeDecrementScaleFactor, 4,                       \
          "Adaptive size scale down factor for shrinking")                  \
                                                                            \
  product(bool, UseAdaptiveSizeDecayMajorGCCost, true,                      \
          "Adaptive size decays the major cost for long major intervals")   \
                                                                            \
  product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10,                     \
          "Time scale over which major costs decay")                        \
                                                                            \
  product(uintx, MinSurvivorRatio, 3,                                       \
          "Minimum ratio of young generation/survivor space size")          \
                                                                            \
  product(uintx, InitialSurvivorRatio, 8,                                   \
          "Initial ratio of eden/survivor space size")                      \
                                                                            \
  product(uintx, BaseFootPrintEstimate, 256*M,                              \
          "Estimate of footprint other than Java Heap")                     \
                                                                            \
  product(bool, UseGCOverheadLimit, true,                                   \
          "Use policy to limit of proportion of time spent in GC "          \
          "before an OutOfMemory error is thrown")                          \
                                                                            \
  product(uintx, GCTimeLimit, 98,                                           \
          "Limit of proportion of time spent in GC before an OutOfMemory"   \
          "error is thrown (used with GCHeapFreeLimit)")                    \
                                                                            \
  product(uintx, GCHeapFreeLimit, 2,                                        \
          "Minimum percentage of free space after a full GC before an "     \
          "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
                                                                            \
  develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5,                 \
          "Number of consecutive collections before gc time limit fires")   \
                                                                            \
  product(bool, PrintAdaptiveSizePolicy, false,                             \
          "Print information about AdaptiveSizePolicy")                     \
                                                                            \
  product(intx, PrefetchCopyIntervalInBytes, -1,                            \
          "How far ahead to prefetch destination area (<= 0 means off)")    \
                                                                            \
  product(intx, PrefetchScanIntervalInBytes, -1,                            \
          "How far ahead to prefetch scan area (<= 0 means off)")           \
                                                                            \
  product(intx, PrefetchFieldsAhead, -1,                                    \
          "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
                                                                            \
2129 2130 2131
  diagnostic(bool, VerifySilently, false,                                   \
          "Don't print print the verification progress")                    \
                                                                            \
2132 2133 2134 2135
  diagnostic(bool, VerifyDuringStartup, false,                              \
          "Verify memory system before executing any Java code "            \
          "during VM initialization")                                       \
                                                                            \
D
duke 已提交
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147
  diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
          "Verify system before exiting")                                   \
                                                                            \
  diagnostic(bool, VerifyBeforeGC, false,                                   \
          "Verify memory system before GC")                                 \
                                                                            \
  diagnostic(bool, VerifyAfterGC, false,                                    \
          "Verify memory system after GC")                                  \
                                                                            \
  diagnostic(bool, VerifyDuringGC, false,                                   \
          "Verify memory system during GC (between phases)")                \
                                                                            \
2148 2149 2150
  diagnostic(bool, GCParallelVerificationEnabled, true,                     \
          "Enable parallel memory system verification")                     \
                                                                            \
2151 2152 2153 2154
  diagnostic(bool, DeferInitialCardMark, false,                             \
          "When +ReduceInitialCardMarks, explicitly defer any that "        \
           "may arise from new_pre_store_barrier")                          \
                                                                            \
D
duke 已提交
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
  diagnostic(bool, VerifyRememberedSets, false,                             \
          "Verify GC remembered sets")                                      \
                                                                            \
  diagnostic(bool, VerifyObjectStartArray, true,                            \
          "Verify GC object start array if verify before/after")            \
                                                                            \
  product(bool, DisableExplicitGC, false,                                   \
          "Tells whether calling System.gc() does a full GC")               \
                                                                            \
  notproduct(bool, CheckMemoryInitialization, false,                        \
          "Checks memory initialization")                                   \
                                                                            \
  product(bool, CollectGen0First, false,                                    \
          "Collect youngest generation before each full GC")                \
                                                                            \
  diagnostic(bool, BindCMSThreadToCPU, false,                               \
          "Bind CMS Thread to CPU if possible")                             \
                                                                            \
  diagnostic(uintx, CPUForCMSThread, 0,                                     \
          "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
                                                                            \
  product(bool, BindGCTaskThreadsToCPUs, false,                             \
          "Bind GCTaskThreads to CPUs if possible")                         \
                                                                            \
  product(bool, UseGCTaskAffinity, false,                                   \
          "Use worker affinity when asking for GCTasks")                    \
                                                                            \
  product(uintx, ProcessDistributionStride, 4,                              \
          "Stride through processors when distributing processes")          \
                                                                            \
  product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
          "number of times the coordinator GC thread will sleep while "     \
          "yielding before giving up and resuming GC")                      \
                                                                            \
  product(uintx, CMSYieldSleepCount, 0,                                     \
          "number of times a GC thread (minus the coordinator) "            \
          "will sleep while yielding before giving up and resuming GC")     \
                                                                            \
  /* gc tracing */                                                          \
  manageable(bool, PrintGC, false,                                          \
          "Print message at garbage collect")                               \
                                                                            \
  manageable(bool, PrintGCDetails, false,                                   \
          "Print more details at garbage collect")                          \
                                                                            \
  manageable(bool, PrintGCDateStamps, false,                                \
          "Print date stamps at garbage collect")                           \
                                                                            \
  manageable(bool, PrintGCTimeStamps, false,                                \
          "Print timestamps at garbage collect")                            \
                                                                            \
  product(bool, PrintGCTaskTimeStamps, false,                               \
          "Print timestamps for individual gc worker thread tasks")         \
                                                                            \
  develop(intx, ConcGCYieldTimeout, 0,                                      \
          "If non-zero, assert that GC threads yield within this # of ms.") \
                                                                            \
  notproduct(bool, TraceMarkSweep, false,                                   \
          "Trace mark sweep")                                               \
                                                                            \
  product(bool, PrintReferenceGC, false,                                    \
          "Print times spent handling reference objects during GC "         \
          " (enabled only when PrintGCDetails)")                            \
                                                                            \
  develop(bool, TraceReferenceGC, false,                                    \
          "Trace handling of soft/weak/final/phantom references")           \
                                                                            \
  develop(bool, TraceFinalizerRegistration, false,                          \
         "Trace registration of final references")                          \
                                                                            \
  notproduct(bool, TraceScavenge, false,                                    \
          "Trace scavenge")                                                 \
                                                                            \
  product_rw(bool, TraceClassLoading, false,                                \
          "Trace all classes loaded")                                       \
                                                                            \
  product(bool, TraceClassLoadingPreorder, false,                           \
          "Trace all classes loaded in order referenced (not loaded)")      \
                                                                            \
  product_rw(bool, TraceClassUnloading, false,                              \
          "Trace unloading of classes")                                     \
                                                                            \
  product_rw(bool, TraceLoaderConstraints, false,                           \
          "Trace loader constraints")                                       \
                                                                            \
2240 2241 2242
  develop(bool, TraceClassLoaderData, false,                                \
          "Trace class loader loader_data lifetime")                        \
                                                                            \
2243 2244
  product(uintx, InitialBootClassLoaderMetaspaceSize,                       \
          NOT_LP64(2200*K) LP64_ONLY(4*M),                                  \
2245 2246
          "Initial size of the boot class loader data metaspace")           \
                                                                            \
D
duke 已提交
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
  product(bool, TraceGen0Time, false,                                       \
          "Trace accumulated time for Gen 0 collection")                    \
                                                                            \
  product(bool, TraceGen1Time, false,                                       \
          "Trace accumulated time for Gen 1 collection")                    \
                                                                            \
  product(bool, PrintTenuringDistribution, false,                           \
          "Print tenuring age information")                                 \
                                                                            \
  product_rw(bool, PrintHeapAtGC, false,                                    \
          "Print heap layout before and after each GC")                     \
                                                                            \
2259 2260 2261 2262
  product_rw(bool, PrintHeapAtGCExtended, false,                            \
          "Prints extended information about the layout of the heap "       \
          "when -XX:+PrintHeapAtGC is set")                                 \
                                                                            \
D
duke 已提交
2263 2264 2265
  product(bool, PrintHeapAtSIGBREAK, true,                                  \
          "Print heap layout in response to SIGBREAK")                      \
                                                                            \
2266 2267 2268 2269 2270 2271
  manageable(bool, PrintClassHistogramBeforeFullGC, false,                  \
          "Print a class histogram before any major stop-world GC")         \
                                                                            \
  manageable(bool, PrintClassHistogramAfterFullGC, false,                   \
          "Print a class histogram after any major stop-world GC")          \
                                                                            \
D
duke 已提交
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
  manageable(bool, PrintClassHistogram, false,                              \
          "Print a histogram of class instances")                           \
                                                                            \
  develop(bool, TraceWorkGang, false,                                       \
          "Trace activities of work gangs")                                 \
                                                                            \
  product(bool, TraceParallelOldGCTasks, false,                             \
          "Trace multithreaded GC activity")                                \
                                                                            \
  develop(bool, TraceBlockOffsetTable, false,                               \
          "Print BlockOffsetTable maps")                                    \
                                                                            \
  develop(bool, TraceCardTableModRefBS, false,                              \
          "Print CardTableModRefBS maps")                                   \
                                                                            \
  develop(bool, TraceGCTaskManager, false,                                  \
          "Trace actions of the GC task manager")                           \
                                                                            \
  develop(bool, TraceGCTaskQueue, false,                                    \
          "Trace actions of the GC task queues")                            \
                                                                            \
2293
  diagnostic(bool, TraceGCTaskThread, false,                                \
D
duke 已提交
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
          "Trace actions of the GC task threads")                           \
                                                                            \
  product(bool, PrintParallelOldGCPhaseTimes, false,                        \
          "Print the time taken by each parallel old gc phase."             \
          "PrintGCDetails must also be enabled.")                           \
                                                                            \
  develop(bool, TraceParallelOldGCMarkingPhase, false,                      \
          "Trace parallel old gc marking phase")                            \
                                                                            \
  develop(bool, TraceParallelOldGCSummaryPhase, false,                      \
          "Trace parallel old gc summary phase")                            \
                                                                            \
  develop(bool, TraceParallelOldGCCompactionPhase, false,                   \
          "Trace parallel old gc compaction phase")                         \
                                                                            \
  develop(bool, TraceParallelOldGCDensePrefix, false,                       \
          "Trace parallel old gc dense prefix computation")                 \
                                                                            \
  develop(bool, IgnoreLibthreadGPFault, false,                              \
          "Suppress workaround for libthread GP fault")                     \
                                                                            \
2315 2316 2317 2318
  product(bool, PrintJNIGCStalls, false,                                    \
          "Print diagnostic message when GC is stalled"                     \
          "by JNI critical section")                                        \
                                                                            \
S
sla 已提交
2319 2320 2321 2322
  experimental(double, ObjectCountCutOffPercent, 0.5,                       \
          "The percentage of the used heap that the instances of a class "  \
          "must occupy for the class to generate a trace event.")           \
                                                                            \
2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
  /* GC log rotation setting */                                             \
                                                                            \
  product(bool, UseGCLogFileRotation, false,                                \
          "Prevent large gclog file for long running app. "                 \
          "Requires -Xloggc:<filename>")                                    \
                                                                            \
  product(uintx, NumberOfGCLogFiles, 0,                                     \
          "Number of gclog files in rotation, "                             \
          "Default: 0, no rotation")                                        \
                                                                            \
  product(uintx, GCLogFileSize, 0,                                          \
          "GC log file size, Default: 0 bytes, no rotation "                \
          "Only valid with UseGCLogFileRotation")                           \
                                                                            \
D
duke 已提交
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
  /* JVMTI heap profiling */                                                \
                                                                            \
  diagnostic(bool, TraceJVMTIObjectTagging, false,                          \
          "Trace JVMTI object tagging calls")                               \
                                                                            \
  diagnostic(bool, VerifyBeforeIteration, false,                            \
          "Verify memory system before JVMTI iteration")                    \
                                                                            \
  /* compiler interface */                                                  \
                                                                            \
  develop(bool, CIPrintCompilerName, false,                                 \
          "when CIPrint is active, print the name of the active compiler")  \
                                                                            \
  develop(bool, CIPrintCompileQueue, false,                                 \
          "display the contents of the compile queue whenever a "           \
          "compilation is enqueued")                                        \
                                                                            \
  develop(bool, CIPrintRequests, false,                                     \
          "display every request for compilation")                          \
                                                                            \
  product(bool, CITime, false,                                              \
          "collect timing information for compilation")                     \
                                                                            \
  develop(bool, CITimeEach, false,                                          \
          "display timing information after each successful compilation")   \
                                                                            \
V
vlivanov 已提交
2363
  develop(bool, CICountOSR, false,                                          \
D
duke 已提交
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381
          "use a separate counter when assigning ids to osr compilations")  \
                                                                            \
  develop(bool, CICompileNatives, true,                                     \
          "compile native methods if supported by the compiler")            \
                                                                            \
  develop_pd(bool, CICompileOSR,                                            \
          "compile on stack replacement methods if supported by the "       \
          "compiler")                                                       \
                                                                            \
  develop(bool, CIPrintMethodCodes, false,                                  \
          "print method bytecodes of the compiled code")                    \
                                                                            \
  develop(bool, CIPrintTypeFlow, false,                                     \
          "print the results of ciTypeFlow analysis")                       \
                                                                            \
  develop(bool, CITraceTypeFlow, false,                                     \
          "detailed per-bytecode tracing of ciTypeFlow analysis")           \
                                                                            \
2382 2383 2384
  develop(intx, OSROnlyBCI, -1,                                             \
          "OSR only at this bci.  Negative values mean exclude that bci")   \
                                                                            \
D
duke 已提交
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
  /* compiler */                                                            \
                                                                            \
  product(intx, CICompilerCount, CI_COMPILER_COUNT,                         \
          "Number of compiler threads to run")                              \
                                                                            \
  product(intx, CompilationPolicyChoice, 0,                                 \
          "which compilation policy (0/1)")                                 \
                                                                            \
  develop(bool, UseStackBanging, true,                                      \
          "use stack banging for stack overflow checks (required for "      \
          "proper StackOverflow handling; disable only to measure cost "    \
          "of stackbanging)")                                               \
                                                                            \
  develop(bool, UseStrictFP, true,                                          \
          "use strict fp if modifier strictfp is set")                      \
                                                                            \
  develop(bool, GenerateSynchronizationCode, true,                          \
          "generate locking/unlocking code for synchronized methods and "   \
          "monitors")                                                       \
                                                                            \
  develop(bool, GenerateCompilerNullChecks, true,                           \
          "Generate explicit null checks for loads/stores/calls")           \
                                                                            \
  develop(bool, GenerateRangeChecks, true,                                  \
          "Generate range checks for array accesses")                       \
                                                                            \
  develop_pd(bool, ImplicitNullChecks,                                      \
          "generate code for implicit null checks")                         \
                                                                            \
  product(bool, PrintSafepointStatistics, false,                            \
          "print statistics about safepoint synchronization")               \
                                                                            \
  product(intx, PrintSafepointStatisticsCount, 300,                         \
          "total number of safepoint statistics collected "                 \
          "before printing them out")                                       \
                                                                            \
  product(intx, PrintSafepointStatisticsTimeout,  -1,                       \
          "print safepoint statistics only when safepoint takes"            \
          " more than PrintSafepointSatisticsTimeout in millis")            \
                                                                            \
2425 2426 2427 2428
  product(bool, TraceSafepointCleanupTime, false,                           \
          "print the break down of clean up tasks performed during"         \
          " safepoint")                                                     \
                                                                            \
D
duke 已提交
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
  product(bool, Inline, true,                                               \
          "enable inlining")                                                \
                                                                            \
  product(bool, ClipInlining, true,                                         \
          "clip inlining if aggregate method exceeds DesiredMethodLimit")   \
                                                                            \
  develop(bool, UseCHA, true,                                               \
          "enable CHA")                                                     \
                                                                            \
  product(bool, UseTypeProfile, true,                                       \
          "Check interpreter profile for historically monomorphic calls")   \
                                                                            \
  notproduct(bool, TimeCompiler, false,                                     \
          "time the compiler")                                              \
                                                                            \
  diagnostic(bool, PrintInlining, false,                                    \
          "prints inlining optimizations")                                  \
                                                                            \
2447 2448 2449
  product(bool, UsePopCountInstruction, false,                              \
          "Use population count instruction")                               \
                                                                            \
D
duke 已提交
2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
  develop(bool, EagerInitialization, false,                                 \
          "Eagerly initialize classes if possible")                         \
                                                                            \
  develop(bool, TraceMethodReplacement, false,                              \
          "Print when methods are replaced do to recompilation")            \
                                                                            \
  develop(bool, PrintMethodFlushing, false,                                 \
          "print the nmethods being flushed")                               \
                                                                            \
  develop(bool, UseRelocIndex, false,                                       \
         "use an index to speed random access to relocations")              \
                                                                            \
  develop(bool, StressCodeBuffers, false,                                   \
         "Exercise code buffer expansion and other rare state changes")     \
                                                                            \
  diagnostic(bool, DebugNonSafepoints, trueInDebug,                         \
         "Generate extra debugging info for non-safepoints in nmethods")    \
                                                                            \
D
dholmes 已提交
2468
  product(bool, PrintVMOptions, false,                                      \
2469
         "Print flags that appeared on the command line")                   \
D
duke 已提交
2470
                                                                            \
2471 2472 2473
  product(bool, IgnoreUnrecognizedVMOptions, false,                         \
         "Ignore unrecognized VM options")                                  \
                                                                            \
2474 2475 2476 2477 2478 2479 2480 2481 2482
  product(bool, PrintCommandLineFlags, false,                               \
         "Print flags specified on command line or set by ergonomics")      \
                                                                            \
  product(bool, PrintFlagsInitial, false,                                   \
         "Print all VM flags before argument processing and exit VM")       \
                                                                            \
  product(bool, PrintFlagsFinal, false,                                     \
         "Print all VM flags after argument and ergonomic processing")      \
                                                                            \
2483 2484 2485
  notproduct(bool, PrintFlagsWithComments, false,                           \
         "Print all VM flags with default values and descriptions and exit")\
                                                                            \
D
duke 已提交
2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
  diagnostic(bool, SerializeVMOutput, true,                                 \
         "Use a mutex to serialize output to tty and hotspot.log")          \
                                                                            \
  diagnostic(bool, DisplayVMOutput, true,                                   \
         "Display all VM output on the tty, independently of LogVMOutput")  \
                                                                            \
  diagnostic(bool, LogVMOutput, trueInDebug,                                \
         "Save VM output to hotspot.log, or to LogFile")                    \
                                                                            \
  diagnostic(ccstr, LogFile, NULL,                                          \
         "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
                                                                            \
  product(ccstr, ErrorFile, NULL,                                           \
         "If an error occurs, save the error data to this file "            \
         "[default: ./hs_err_pid%p.log] (%p replaced with pid)")            \
                                                                            \
  product(bool, DisplayVMOutputToStderr, false,                             \
         "If DisplayVMOutput is true, display all VM output to stderr")     \
                                                                            \
  product(bool, DisplayVMOutputToStdout, false,                             \
         "If DisplayVMOutput is true, display all VM output to stdout")     \
                                                                            \
  product(bool, UseHeavyMonitors, false,                                    \
          "use heavyweight instead of lightweight Java monitors")           \
                                                                            \
2511 2512 2513
  product(bool, PrintStringTableStatistics, false,                          \
          "print statistics about the StringTable and SymbolTable")         \
                                                                            \
D
duke 已提交
2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524
  notproduct(bool, PrintSymbolTableSizeHistogram, false,                    \
          "print histogram of the symbol table")                            \
                                                                            \
  notproduct(bool, ExitVMOnVerifyError, false,                              \
          "standard exit from VM if bytecode verify error "                 \
          "(only in debug mode)")                                           \
                                                                            \
  notproduct(ccstr, AbortVMOnException, NULL,                               \
          "Call fatal if this exception is thrown.  Example: "              \
          "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
                                                                            \
2525 2526 2527 2528
  notproduct(ccstr, AbortVMOnExceptionMessage, NULL,                        \
          "Call fatal if the exception pointed by AbortVMOnException "      \
          "has this message.")                                              \
                                                                            \
D
duke 已提交
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544
  develop(bool, DebugVtables, false,                                        \
          "add debugging code to vtable dispatch")                          \
                                                                            \
  develop(bool, PrintVtables, false,                                        \
          "print vtables when printing klass")                              \
                                                                            \
  notproduct(bool, PrintVtableStats, false,                                 \
          "print vtables stats at end of run")                              \
                                                                            \
  develop(bool, TraceCreateZombies, false,                                  \
          "trace creation of zombie nmethods")                              \
                                                                            \
  notproduct(bool, IgnoreLockingAssertions, false,                          \
          "disable locking assertions (for speed)")                         \
                                                                            \
  product(bool, RangeCheckElimination, true,                                \
2545
          "Eliminate range checks")                                         \
D
duke 已提交
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
                                                                            \
  develop_pd(bool, UncommonNullCast,                                        \
          "track occurrences of null in casts; adjust compiler tactics")    \
                                                                            \
  develop(bool, TypeProfileCasts,  true,                                    \
          "treat casts like calls for purposes of type profiling")          \
                                                                            \
  develop(bool, DelayCompilationDuringStartup, true,                        \
          "Delay invoking the compiler until main application class is "    \
          "loaded")                                                         \
                                                                            \
  develop(bool, CompileTheWorld, false,                                     \
          "Compile all methods in all classes in bootstrap class path "     \
          "(stress test)")                                                  \
                                                                            \
  develop(bool, CompileTheWorldPreloadClasses, true,                        \
          "Preload all classes used by a class before start loading")       \
                                                                            \
2564 2565 2566
  notproduct(intx, CompileTheWorldSafepointInterval, 100,                   \
          "Force a safepoint every n compiles so sweeper can keep up")      \
                                                                            \
D
duke 已提交
2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591
  develop(bool, FillDelaySlots, true,                                       \
          "Fill delay slots (on SPARC only)")                               \
                                                                            \
  develop(bool, TimeLivenessAnalysis, false,                                \
          "Time computation of bytecode liveness analysis")                 \
                                                                            \
  develop(bool, TraceLivenessGen, false,                                    \
          "Trace the generation of liveness analysis information")          \
                                                                            \
  notproduct(bool, TraceLivenessQuery, false,                               \
          "Trace queries of liveness analysis information")                 \
                                                                            \
  notproduct(bool, CollectIndexSetStatistics, false,                        \
          "Collect information about IndexSets")                            \
                                                                            \
  develop(bool, UseLoopSafepoints, true,                                    \
          "Generate Safepoint nodes in every loop")                         \
                                                                            \
  develop(intx, FastAllocateSizeLimit, 128*K,                               \
          /* Note:  This value is zero mod 1<<13 for a cheap sparc set. */  \
          "Inline allocations larger than this in doublewords must go slow")\
                                                                            \
  product(bool, AggressiveOpts, false,                                      \
          "Enable aggressive optimizations - see arguments.cpp")            \
                                                                            \
2592 2593 2594
  product(bool, UseStringCache, false,                                      \
          "Enable String cache capabilities on String.java")                \
                                                                            \
D
duke 已提交
2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
  /* statistics */                                                          \
  develop(bool, CountCompiledCalls, false,                                  \
          "counts method invocations")                                      \
                                                                            \
  notproduct(bool, CountRuntimeCalls, false,                                \
          "counts VM runtime calls")                                        \
                                                                            \
  develop(bool, CountJNICalls, false,                                       \
          "counts jni method invocations")                                  \
                                                                            \
  notproduct(bool, CountJVMCalls, false,                                    \
          "counts jvm method invocations")                                  \
                                                                            \
  notproduct(bool, CountRemovableExceptions, false,                         \
          "count exceptions that could be replaced by branches due to "     \
          "inlining")                                                       \
                                                                            \
  notproduct(bool, ICMissHistogram, false,                                  \
          "produce histogram of IC misses")                                 \
                                                                            \
  notproduct(bool, PrintClassStatistics, false,                             \
          "prints class statistics at end of run")                          \
                                                                            \
  notproduct(bool, PrintMethodStatistics, false,                            \
          "prints method statistics at end of run")                         \
                                                                            \
  /* interpreter */                                                         \
  develop(bool, ClearInterpreterLocals, false,                              \
          "Always clear local variables of interpreter activations upon "   \
          "entry")                                                          \
                                                                            \
  product_pd(bool, RewriteBytecodes,                                        \
          "Allow rewriting of bytecodes (bytecodes are not immutable)")     \
                                                                            \
  product_pd(bool, RewriteFrequentPairs,                                    \
          "Rewrite frequently used bytecode pairs into a single bytecode")  \
                                                                            \
2632
  diagnostic(bool, PrintInterpreter, false,                                 \
D
duke 已提交
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669
          "Prints the generated interpreter code")                          \
                                                                            \
  product(bool, UseInterpreter, true,                                       \
          "Use interpreter for non-compiled methods")                       \
                                                                            \
  develop(bool, UseFastSignatureHandlers, true,                             \
          "Use fast signature handlers for native calls")                   \
                                                                            \
  product(bool, UseLoopCounter, true,                                       \
          "Increment invocation counter on backward branch")                \
                                                                            \
  product(bool, UseFastEmptyMethods, true,                                  \
          "Use fast method entry code for empty methods")                   \
                                                                            \
  product(bool, UseFastAccessorMethods, true,                               \
          "Use fast method entry code for accessor methods")                \
                                                                            \
  product_pd(bool, UseOnStackReplacement,                                   \
           "Use on stack replacement, calls runtime if invoc. counter "     \
           "overflows in loop")                                             \
                                                                            \
  notproduct(bool, TraceOnStackReplacement, false,                          \
          "Trace on stack replacement")                                     \
                                                                            \
  product_pd(bool, PreferInterpreterNativeStubs,                            \
          "Use always interpreter stubs for native methods invoked via "    \
          "interpreter")                                                    \
                                                                            \
  develop(bool, CountBytecodes, false,                                      \
          "Count number of bytecodes executed")                             \
                                                                            \
  develop(bool, PrintBytecodeHistogram, false,                              \
          "Print histogram of the executed bytecodes")                      \
                                                                            \
  develop(bool, PrintBytecodePairHistogram, false,                          \
          "Print histogram of the executed bytecode pairs")                 \
                                                                            \
2670
  diagnostic(bool, PrintSignatureHandlers, false,                           \
D
duke 已提交
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719
          "Print code generated for native method signature handlers")      \
                                                                            \
  develop(bool, VerifyOops, false,                                          \
          "Do plausibility checks for oops")                                \
                                                                            \
  develop(bool, CheckUnhandledOops, false,                                  \
          "Check for unhandled oops in VM code")                            \
                                                                            \
  develop(bool, VerifyJNIFields, trueInDebug,                               \
          "Verify jfieldIDs for instance fields")                           \
                                                                            \
  notproduct(bool, VerifyJNIEnvThread, false,                               \
          "Verify JNIEnv.thread == Thread::current() when entering VM "     \
          "from JNI")                                                       \
                                                                            \
  develop(bool, VerifyFPU, false,                                           \
          "Verify FPU state (check for NaN's, etc.)")                       \
                                                                            \
  develop(bool, VerifyThread, false,                                        \
          "Watch the thread register for corruption (SPARC only)")          \
                                                                            \
  develop(bool, VerifyActivationFrameSize, false,                           \
          "Verify that activation frame didn't become smaller than its "    \
          "minimal size")                                                   \
                                                                            \
  develop(bool, TraceFrequencyInlining, false,                              \
          "Trace frequency based inlining")                                 \
                                                                            \
  develop_pd(bool, InlineIntrinsics,                                        \
           "Inline intrinsics that can be statically resolved")             \
                                                                            \
  product_pd(bool, ProfileInterpreter,                                      \
           "Profile at the bytecode level during interpretation")           \
                                                                            \
  develop_pd(bool, ProfileTraps,                                            \
          "Profile deoptimization traps at the bytecode level")             \
                                                                            \
  product(intx, ProfileMaturityPercentage, 20,                              \
          "number of method invocations/branches (expressed as % of "       \
          "CompileThreshold) before using the method's profile")            \
                                                                            \
  develop(bool, PrintMethodData, false,                                     \
           "Print the results of +ProfileInterpreter at end of run")        \
                                                                            \
  develop(bool, VerifyDataPointer, trueInDebug,                             \
          "Verify the method data pointer during interpreter profiling")    \
                                                                            \
  develop(bool, VerifyCompiledCode, false,                                  \
          "Include miscellaneous runtime verifications in nmethod code; "   \
P
phh 已提交
2720
          "default off because it disturbs nmethod size heuristics")        \
D
duke 已提交
2721
                                                                            \
2722 2723 2724
  notproduct(bool, CrashGCForDumpingJavaThread, false,                      \
          "Manually make GC thread crash then dump java stack trace;  "     \
          "Test only")                                                      \
D
duke 已提交
2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
                                                                            \
  /* compilation */                                                         \
  product(bool, UseCompiler, true,                                          \
          "use compilation")                                                \
                                                                            \
  develop(bool, TraceCompilationPolicy, false,                              \
          "Trace compilation policy")                                       \
                                                                            \
  develop(bool, TimeCompilationPolicy, false,                               \
          "Time the compilation policy")                                    \
                                                                            \
  product(bool, UseCounterDecay, true,                                      \
           "adjust recompilation counters")                                 \
                                                                            \
  develop(intx, CounterHalfLifeTime,    30,                                 \
          "half-life time of invocation counters (in secs)")                \
                                                                            \
  develop(intx, CounterDecayMinIntervalLength,   500,                       \
          "Min. ms. between invocation of CounterDecay")                    \
                                                                            \
  product(bool, AlwaysCompileLoopMethods, false,                            \
          "when using recompilation, never interpret methods "              \
          "containing loops")                                               \
                                                                            \
  product(bool, DontCompileHugeMethods, true,                               \
          "don't compile methods > HugeMethodLimit")                        \
                                                                            \
  /* Bytecode escape analysis estimation. */                                \
  product(bool, EstimateArgEscape, true,                                    \
          "Analyze bytecodes to estimate escape state of arguments")        \
                                                                            \
  product(intx, BCEATraceLevel, 0,                                          \
          "How much tracing to do of bytecode escape analysis estimates")   \
                                                                            \
  product(intx, MaxBCEAEstimateLevel, 5,                                    \
          "Maximum number of nested calls that are analyzed by BC EA.")     \
                                                                            \
  product(intx, MaxBCEAEstimateSize, 150,                                   \
          "Maximum bytecode size of a method to be analyzed by BC EA.")     \
                                                                            \
  product(intx,  AllocatePrefetchStyle, 1,                                  \
          "0 = no prefetch, "                                               \
          "1 = prefetch instructions for each allocation, "                 \
2768 2769
          "2 = use TLAB watermark to gate allocation prefetch, "            \
          "3 = use BIS instruction on Sparc for allocation prefetch")       \
D
duke 已提交
2770 2771 2772 2773
                                                                            \
  product(intx,  AllocatePrefetchDistance, -1,                              \
          "Distance to prefetch ahead of allocation pointer")               \
                                                                            \
2774 2775 2776 2777 2778
  product(intx,  AllocatePrefetchLines, 3,                                  \
          "Number of lines to prefetch ahead of array allocation pointer")  \
                                                                            \
  product(intx,  AllocateInstancePrefetchLines, 1,                          \
          "Number of lines to prefetch ahead of instance allocation pointer") \
D
duke 已提交
2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
                                                                            \
  product(intx,  AllocatePrefetchStepSize, 16,                              \
          "Step size in bytes of sequential prefetch instructions")         \
                                                                            \
  product(intx,  AllocatePrefetchInstr, 0,                                  \
          "Prefetch instruction to prefetch ahead of allocation pointer")   \
                                                                            \
  /* deoptimization */                                                      \
  develop(bool, TraceDeoptimization, false,                                 \
          "Trace deoptimization")                                           \
                                                                            \
  develop(bool, DebugDeoptimization, false,                                 \
          "Tracing various information while debugging deoptimization")     \
                                                                            \
  product(intx, SelfDestructTimer, 0,                                       \
          "Will cause VM to terminate after a given time (in minutes) "     \
          "(0 means off)")                                                  \
                                                                            \
  product(intx, MaxJavaStackTraceDepth, 1024,                               \
          "Max. no. of lines in the stack trace for Java exceptions "       \
          "(0 means all)")                                                  \
                                                                            \
2801
  NOT_EMBEDDED(diagnostic(intx, GuaranteedSafepointInterval, 1000,          \
D
duke 已提交
2802
          "Guarantee a safepoint (at least) every so many milliseconds "    \
2803 2804 2805 2806 2807
          "(0 means none)"))                                                \
                                                                            \
  EMBEDDED_ONLY(product(intx, GuaranteedSafepointInterval, 0,               \
          "Guarantee a safepoint (at least) every so many milliseconds "    \
          "(0 means none)"))                                                \
D
duke 已提交
2808 2809 2810 2811
                                                                            \
  product(intx, SafepointTimeoutDelay, 10000,                               \
          "Delay in milliseconds for option SafepointTimeout")              \
                                                                            \
2812
  product(intx, NmethodSweepFraction, 16,                                   \
D
duke 已提交
2813 2814
          "Number of invocations of sweeper to cover all nmethods")         \
                                                                            \
2815 2816 2817
  product(intx, NmethodSweepCheckInterval, 5,                               \
          "Compilers wake up every n seconds to possibly sweep nmethods")   \
                                                                            \
2818 2819 2820 2821 2822 2823
  notproduct(bool, LogSweeper, false,                                       \
            "Keep a ring buffer of sweeper activity")                       \
                                                                            \
  notproduct(intx, SweeperLogEntries, 1024,                                 \
            "Number of records in the ring buffer of sweeper activity")     \
                                                                            \
D
duke 已提交
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
  notproduct(intx, MemProfilingInterval, 500,                               \
          "Time between each invocation of the MemProfiler")                \
                                                                            \
  develop(intx, MallocCatchPtr, -1,                                         \
          "Hit breakpoint when mallocing/freeing this pointer")             \
                                                                            \
  notproduct(intx, AssertRepeat, 1,                                         \
          "number of times to evaluate expression in assert "               \
          "(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS") \
                                                                            \
  notproduct(ccstrlist, SuppressErrorAt, "",                                \
          "List of assertions (file:line) to muzzle")                       \
                                                                            \
  notproduct(uintx, HandleAllocationLimit, 1024,                            \
          "Threshold for HandleMark allocation when +TraceHandleAllocation "\
          "is used")                                                        \
                                                                            \
  develop(uintx, TotalHandleAllocationLimit, 1024,                          \
          "Threshold for total handle allocation when "                     \
          "+TraceHandleAllocation is used")                                 \
                                                                            \
  develop(intx, StackPrintLimit, 100,                                       \
          "number of stack frames to print in VM-level stack dump")         \
                                                                            \
  notproduct(intx, MaxElementPrintSize, 256,                                \
          "maximum number of elements to print")                            \
                                                                            \
  notproduct(intx, MaxSubklassPrintSize, 4,                                 \
          "maximum number of subklasses to print when printing klass")      \
                                                                            \
2854
  product(intx, MaxInlineLevel, 9,                                          \
D
duke 已提交
2855 2856
          "maximum number of nested calls that are inlined")                \
                                                                            \
2857
  product(intx, MaxRecursiveInlineLevel, 1,                                 \
D
duke 已提交
2858 2859
          "maximum number of nested recursive calls that are inlined")      \
                                                                            \
2860
  product_pd(intx, InlineSmallCode,                                         \
D
duke 已提交
2861 2862 2863 2864 2865 2866 2867 2868 2869
          "Only inline already compiled methods if their code size is "     \
          "less than this")                                                 \
                                                                            \
  product(intx, MaxInlineSize, 35,                                          \
          "maximum bytecode size of a method to be inlined")                \
                                                                            \
  product_pd(intx, FreqInlineSize,                                          \
          "maximum bytecode size of a frequent method to be inlined")       \
                                                                            \
2870
  product(intx, MaxTrivialSize, 6,                                          \
D
duke 已提交
2871 2872
          "maximum bytecode size of a trivial method to be inlined")        \
                                                                            \
2873
  product(intx, MinInliningThreshold, 250,                                  \
D
duke 已提交
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934
          "min. invocation count a method needs to have to be inlined")     \
                                                                            \
  develop(intx, MethodHistogramCutoff, 100,                                 \
          "cutoff value for method invoc. histogram (+CountCalls)")         \
                                                                            \
  develop(intx, ProfilerNumberOfInterpretedMethods, 25,                     \
          "# of interpreted methods to show in profile")                    \
                                                                            \
  develop(intx, ProfilerNumberOfCompiledMethods, 25,                        \
          "# of compiled methods to show in profile")                       \
                                                                            \
  develop(intx, ProfilerNumberOfStubMethods, 25,                            \
          "# of stub methods to show in profile")                           \
                                                                            \
  develop(intx, ProfilerNumberOfRuntimeStubNodes, 25,                       \
          "# of runtime stub nodes to show in profile")                     \
                                                                            \
  product(intx, ProfileIntervalsTicks, 100,                                 \
          "# of ticks between printing of interval profile "                \
          "(+ProfileIntervals)")                                            \
                                                                            \
  notproduct(intx, ScavengeALotInterval,     1,                             \
          "Interval between which scavenge will occur with +ScavengeALot")  \
                                                                            \
  notproduct(intx, FullGCALotInterval,     1,                               \
          "Interval between which full gc will occur with +FullGCALot")     \
                                                                            \
  notproduct(intx, FullGCALotStart,     0,                                  \
          "For which invocation to start FullGCAlot")                       \
                                                                            \
  notproduct(intx, FullGCALotDummies,  32*K,                                \
          "Dummy object allocated with +FullGCALot, forcing all objects "   \
          "to move")                                                        \
                                                                            \
  develop(intx, DontYieldALotInterval,    10,                               \
          "Interval between which yields will be dropped (milliseconds)")   \
                                                                            \
  develop(intx, MinSleepInterval,     1,                                    \
          "Minimum sleep() interval (milliseconds) when "                   \
          "ConvertSleepToYield is off (used for SOLARIS)")                  \
                                                                            \
  develop(intx, ProfilerPCTickThreshold,    15,                             \
          "Number of ticks in a PC buckets to be a hotspot")                \
                                                                            \
  notproduct(intx, DeoptimizeALotInterval,     5,                           \
          "Number of exits until DeoptimizeALot kicks in")                  \
                                                                            \
  notproduct(intx, ZombieALotInterval,     5,                               \
          "Number of exits until ZombieALot kicks in")                      \
                                                                            \
  develop(bool, StressNonEntrant, false,                                    \
          "Mark nmethods non-entrant at registration")                      \
                                                                            \
  diagnostic(intx, MallocVerifyInterval,     0,                             \
          "if non-zero, verify C heap after every N calls to "              \
          "malloc/realloc/free")                                            \
                                                                            \
  diagnostic(intx, MallocVerifyStart,     0,                                \
          "if non-zero, start verifying C heap after Nth call to "          \
          "malloc/realloc/free")                                            \
                                                                            \
2935 2936 2937 2938
  diagnostic(uintx, MallocMaxTestWords,     0,                              \
          "if non-zero, max # of Words that malloc/realloc can allocate "   \
          "(for testing only)")                                             \
                                                                            \
2939
  product(intx, TypeProfileWidth,     2,                                    \
D
duke 已提交
2940 2941 2942 2943 2944 2945 2946 2947
          "number of receiver types to record in call/cast profile")        \
                                                                            \
  develop(intx, BciProfileWidth,      2,                                    \
          "number of return bci's to record in ret profile")                \
                                                                            \
  product(intx, PerMethodRecompilationCutoff, 400,                          \
          "After recompiling N times, stay in the interpreter (-1=>'Inf')") \
                                                                            \
2948
  product(intx, PerBytecodeRecompilationCutoff, 200,                        \
D
duke 已提交
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976
          "Per-BCI limit on repeated recompilation (-1=>'Inf')")            \
                                                                            \
  product(intx, PerMethodTrapLimit,  100,                                   \
          "Limit on traps (of one kind) in a method (includes inlines)")    \
                                                                            \
  product(intx, PerBytecodeTrapLimit,  4,                                   \
          "Limit on traps (of one kind) at a particular BCI")               \
                                                                            \
  develop(intx, InlineFrequencyRatio,    20,                                \
          "Ratio of call site execution to caller method invocation")       \
                                                                            \
  develop_pd(intx, InlineFrequencyCount,                                    \
          "Count of call site execution necessary to trigger frequent "     \
          "inlining")                                                       \
                                                                            \
  develop(intx, InlineThrowCount,    50,                                    \
          "Force inlining of interpreted methods that throw this often")    \
                                                                            \
  develop(intx, InlineThrowMaxSize,   200,                                  \
          "Force inlining of throwing methods smaller than this")           \
                                                                            \
  develop(intx, ProfilerNodeSize,  1024,                                    \
          "Size in K to allocate for the Profile Nodes of each thread")     \
                                                                            \
  product_pd(intx, PreInflateSpin,                                          \
          "Number of times to spin wait before inflation")                  \
                                                                            \
  /* gc parameters */                                                       \
P
phh 已提交
2977
  product(uintx, InitialHeapSize, 0,                                        \
2978
          "Initial heap size (in bytes); zero means use ergonomics")        \
P
phh 已提交
2979 2980 2981
                                                                            \
  product(uintx, MaxHeapSize, ScaleForWordSize(96*M),                       \
          "Maximum heap size (in bytes)")                                   \
D
duke 已提交
2982
                                                                            \
P
phh 已提交
2983 2984 2985
  product(uintx, OldSize, ScaleForWordSize(4*M),                            \
          "Initial tenured generation size (in bytes)")                     \
                                                                            \
2986
  product(uintx, NewSize, ScaleForWordSize(1*M),                            \
P
phh 已提交
2987
          "Initial new generation size (in bytes)")                         \
D
duke 已提交
2988 2989
                                                                            \
  product(uintx, MaxNewSize, max_uintx,                                     \
P
phh 已提交
2990 2991
          "Maximum new generation size (in bytes), max_uintx means set "    \
          "ergonomically")                                                  \
D
duke 已提交
2992 2993
                                                                            \
  product(uintx, PretenureSizeThreshold, 0,                                 \
P
phh 已提交
2994 2995
          "Maximum size in bytes of objects allocated in DefNew "           \
          "generation; zero means no maximum")                              \
D
duke 已提交
2996
                                                                            \
P
phh 已提交
2997 2998
  product(uintx, TLABSize, 0,                                               \
          "Starting TLAB size (in bytes); zero means set ergonomically")    \
D
duke 已提交
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014
                                                                            \
  product(uintx, MinTLABSize, 2*K,                                          \
          "Minimum allowed TLAB size (in bytes)")                           \
                                                                            \
  product(uintx, TLABAllocationWeight, 35,                                  \
          "Allocation averaging weight")                                    \
                                                                            \
  product(uintx, TLABWasteTargetPercent, 1,                                 \
          "Percentage of Eden that can be wasted")                          \
                                                                            \
  product(uintx, TLABRefillWasteFraction,    64,                            \
          "Max TLAB waste at a refill (internal fragmentation)")            \
                                                                            \
  product(uintx, TLABWasteIncrement,    4,                                  \
          "Increment allowed waste at slow allocation")                     \
                                                                            \
3015
  product(uintx, SurvivorRatio, 8,                                          \
D
duke 已提交
3016 3017
          "Ratio of eden/survivor space size")                              \
                                                                            \
3018
  product(uintx, NewRatio, 2,                                               \
D
duke 已提交
3019 3020 3021 3022 3023 3024
          "Ratio of new/old generation sizes")                              \
                                                                            \
  product_pd(uintx, NewSizeThreadIncrease,                                  \
          "Additional size added to desired new generation size per "       \
          "non-daemon thread (in bytes)")                                   \
                                                                            \
3025 3026
  product_pd(uintx, MetaspaceSize,                                          \
          "Initial size of Metaspaces (in bytes)")                          \
D
duke 已提交
3027
                                                                            \
3028 3029 3030
  product(uintx, MaxMetaspaceSize, max_uintx,                               \
          "Maximum size of Metaspaces (in bytes)")                          \
                                                                            \
3031
  product(uintx, ClassMetaspaceSize, 2*M,                                   \
3032 3033
          "Maximum size of InstanceKlass area in Metaspace used for "       \
          "UseCompressedKlassPointers")                                     \
D
duke 已提交
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
                                                                            \
  product(uintx, MinHeapFreeRatio,    40,                                   \
          "Min percentage of heap free after GC to avoid expansion")        \
                                                                            \
  product(uintx, MaxHeapFreeRatio,    70,                                   \
          "Max percentage of heap free after GC to avoid shrinking")        \
                                                                            \
  product(intx, SoftRefLRUPolicyMSPerMB, 1000,                              \
          "Number of milliseconds per MB of free space in the heap")        \
                                                                            \
  product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K),                \
          "Min change in heap space due to GC (in bytes)")                  \
                                                                            \
3047
  product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K),            \
3048 3049 3050 3051 3052 3053 3054
          "Min expansion of Metaspace (in bytes)")                          \
                                                                            \
  product(uintx, MinMetaspaceFreeRatio,    40,                              \
          "Min percentage of Metaspace free after GC to avoid expansion")   \
                                                                            \
  product(uintx, MaxMetaspaceFreeRatio,    70,                              \
          "Max percentage of Metaspace free after GC to avoid shrinking")   \
D
duke 已提交
3055
                                                                            \
3056
  product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M),              \
3057
          "Max expansion of Metaspace without full GC (in bytes)")          \
D
duke 已提交
3058
                                                                            \
3059
  product(uintx, QueuedAllocationWarningCount, 0,                           \
D
duke 已提交
3060 3061 3062 3063 3064 3065 3066 3067 3068
          "Number of times an allocation that queues behind a GC "          \
          "will retry before printing a warning")                           \
                                                                            \
  diagnostic(uintx, VerifyGCStartAt,   0,                                   \
          "GC invoke count where +VerifyBefore/AfterGC kicks in")           \
                                                                            \
  diagnostic(intx, VerifyGCLevel,     0,                                    \
          "Generation level at which to start +VerifyBefore/AfterGC")       \
                                                                            \
3069
  product(uintx, MaxTenuringThreshold,    15,                               \
D
duke 已提交
3070 3071
          "Maximum value for tenuring threshold")                           \
                                                                            \
3072
  product(uintx, InitialTenuringThreshold,    7,                            \
D
duke 已提交
3073 3074
          "Initial value for tenuring threshold")                           \
                                                                            \
3075
  product(uintx, TargetSurvivorRatio,    50,                                \
D
duke 已提交
3076 3077
          "Desired percentage of survivor space used after scavenge")       \
                                                                            \
3078
  product(uintx, MarkSweepDeadRatio,     5,                                 \
D
duke 已提交
3079 3080 3081 3082 3083 3084 3085 3086
          "Percentage (0-100) of the old gen allowed as dead wood."         \
          "Serial mark sweep treats this as both the min and max value."    \
          "CMS uses this value only if it falls back to mark sweep."        \
          "Par compact uses a variable scale based on the density of the"   \
          "generation and treats this as the max value when the heap is"    \
          "either completely full or completely empty.  Par compact also"   \
          "has a smaller default value; see arguments.cpp.")                \
                                                                            \
3087
  product(uintx, MarkSweepAlwaysCompactCount,     4,                        \
D
duke 已提交
3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
          "How often should we fully compact the heap (ignoring the dead "  \
          "space parameters)")                                              \
                                                                            \
  product(intx, PrintCMSStatistics, 0,                                      \
          "Statistics for CMS")                                             \
                                                                            \
  product(bool, PrintCMSInitiationStatistics, false,                        \
          "Statistics for initiating a CMS collection")                     \
                                                                            \
  product(intx, PrintFLSStatistics, 0,                                      \
          "Statistics for CMS' FreeListSpace")                              \
                                                                            \
  product(intx, PrintFLSCensus, 0,                                          \
          "Census for CMS' FreeListSpace")                                  \
                                                                            \
  develop(uintx, GCExpandToAllocateDelayMillis, 0,                          \
          "Delay in ms between expansion and allocation")                   \
                                                                            \
J
jmasa 已提交
3106 3107 3108
  develop(uintx, GCWorkerDelayMillis, 0,                                    \
          "Delay in ms in scheduling GC workers")                           \
                                                                            \
D
duke 已提交
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161
  product(intx, DeferThrSuspendLoopCount,     4000,                         \
          "(Unstable) Number of times to iterate in safepoint loop "        \
          " before blocking VM threads ")                                   \
                                                                            \
  product(intx, DeferPollingPageLoopCount,     -1,                          \
          "(Unsafe,Unstable) Number of iterations in safepoint loop "       \
          "before changing safepoint polling page to RO ")                  \
                                                                            \
  product(intx, SafepointSpinBeforeYield, 2000,  "(Unstable)")              \
                                                                            \
  product(bool, PSChunkLargeArrays, true,                                   \
          "true: process large arrays in chunks")                           \
                                                                            \
  product(uintx, GCDrainStackTargetSize, 64,                                \
          "how many entries we'll try to leave on the stack during "        \
          "parallel GC")                                                    \
                                                                            \
  /* stack parameters */                                                    \
  product_pd(intx, StackYellowPages,                                        \
          "Number of yellow zone (recoverable overflows) pages")            \
                                                                            \
  product_pd(intx, StackRedPages,                                           \
          "Number of red zone (unrecoverable overflows) pages")             \
                                                                            \
  product_pd(intx, StackShadowPages,                                        \
          "Number of shadow zone (for overflow checking) pages"             \
          " this should exceed the depth of the VM and native call stack")  \
                                                                            \
  product_pd(intx, ThreadStackSize,                                         \
          "Thread Stack Size (in Kbytes)")                                  \
                                                                            \
  product_pd(intx, VMThreadStackSize,                                       \
          "Non-Java Thread Stack Size (in Kbytes)")                         \
                                                                            \
  product_pd(intx, CompilerThreadStackSize,                                 \
          "Compiler Thread Stack Size (in Kbytes)")                         \
                                                                            \
  develop_pd(uintx, JVMInvokeMethodSlack,                                   \
          "Stack space (bytes) required for JVM_InvokeMethod to complete")  \
                                                                            \
  product(uintx, ThreadSafetyMargin, 50*M,                                  \
          "Thread safety margin is used on fixed-stack LinuxThreads (on "   \
          "Linux/x86 only) to prevent heap-stack collision. Set to 0 to "   \
          "disable this feature")                                           \
                                                                            \
  /* code cache parameters */                                               \
  develop(uintx, CodeCacheSegmentSize, 64,                                  \
          "Code cache segment size (in bytes) - smallest unit of "          \
          "allocation")                                                     \
                                                                            \
  develop_pd(intx, CodeEntryAlignment,                                      \
          "Code entry alignment for generated code (in bytes)")             \
                                                                            \
3162 3163 3164
  product_pd(intx, OptoLoopAlignment,                                       \
          "Align inner loops to zero relative to this modulus")             \
                                                                            \
D
duke 已提交
3165 3166 3167
  product_pd(uintx, InitialCodeCacheSize,                                   \
          "Initial code cache size (in bytes)")                             \
                                                                            \
3168 3169 3170
  develop_pd(uintx, CodeCacheMinimumUseSpace,                               \
          "Minimum code cache size (in bytes) required to start VM.")       \
                                                                            \
D
duke 已提交
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
  product_pd(uintx, ReservedCodeCacheSize,                                  \
          "Reserved code cache size (in bytes) - maximum code cache size")  \
                                                                            \
  product(uintx, CodeCacheMinimumFreeSpace, 500*K,                          \
          "When less than X space left, we stop compiling.")                \
                                                                            \
  product_pd(uintx, CodeCacheExpansionSize,                                 \
          "Code cache expansion size (in bytes)")                           \
                                                                            \
  develop_pd(uintx, CodeCacheMinBlockLength,                                \
          "Minimum number of segments in a code cache block.")              \
                                                                            \
  notproduct(bool, ExitOnFullCodeCache, false,                              \
          "Exit the VM if we fill the code cache.")                         \
                                                                            \
N
never 已提交
3186
  product(bool, UseCodeCacheFlushing, true,                                 \
3187 3188 3189 3190 3191 3192 3193 3194
          "Attempt to clean the code cache before shutting off compiler")   \
                                                                            \
  product(intx,  MinCodeCacheFlushingInterval, 30,                          \
          "Min number of seconds between code cache cleaning sessions")     \
                                                                            \
  product(uintx,  CodeCacheFlushingMinimumFreeSpace, 1500*K,                \
          "When less than X space left, start code cache cleaning")         \
                                                                            \
3195 3196 3197
  product(uintx, CodeCacheFlushingFraction, 2,                              \
          "Fraction of the code cache that is flushed when full")           \
                                                                            \
D
duke 已提交
3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238
  /* interpreter debugging */                                               \
  develop(intx, BinarySwitchThreshold, 5,                                   \
          "Minimal number of lookupswitch entries for rewriting to binary " \
          "switch")                                                         \
                                                                            \
  develop(intx, StopInterpreterAt, 0,                                       \
          "Stops interpreter execution at specified bytecode number")       \
                                                                            \
  develop(intx, TraceBytecodesAt, 0,                                        \
          "Traces bytecodes starting with specified bytecode number")       \
                                                                            \
  /* compiler interface */                                                  \
  develop(intx, CIStart, 0,                                                 \
          "the id of the first compilation to permit")                      \
                                                                            \
  develop(intx, CIStop,    -1,                                              \
          "the id of the last compilation to permit")                       \
                                                                            \
  develop(intx, CIStartOSR,     0,                                          \
          "the id of the first osr compilation to permit "                  \
          "(CICountOSR must be on)")                                        \
                                                                            \
  develop(intx, CIStopOSR,    -1,                                           \
          "the id of the last osr compilation to permit "                   \
          "(CICountOSR must be on)")                                        \
                                                                            \
  develop(intx, CIBreakAtOSR,    -1,                                        \
          "id of osr compilation to break at")                              \
                                                                            \
  develop(intx, CIBreakAt,    -1,                                           \
          "id of compilation to break at")                                  \
                                                                            \
  product(ccstrlist, CompileOnly, "",                                       \
          "List of methods (pkg/class.name) to restrict compilation to")    \
                                                                            \
  product(ccstr, CompileCommandFile, NULL,                                  \
          "Read compiler commands from this file [.hotspot_compiler]")      \
                                                                            \
  product(ccstrlist, CompileCommand, "",                                    \
          "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \
                                                                            \
3239 3240 3241
  develop(bool, ReplayCompiles, false,                                      \
          "Enable replay of compilations from ReplayDataFile")              \
                                                                            \
3242 3243 3244
  product(ccstr, ReplayDataFile, NULL,                                      \
          "File containing compilation replay information"                  \
          "[default: ./replay_pid%p.log] (%p replaced with pid)")           \
3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256
                                                                            \
  develop(intx, ReplaySuppressInitializers, 2,                              \
          "Controls handling of class initialization during replay"         \
          "0 - don't do anything special"                                   \
          "1 - treat all class initializers as empty"                       \
          "2 - treat class initializers for application classes as empty"   \
          "3 - allow all class initializers to run during bootstrap but"    \
          "    pretend they are empty after starting replay")               \
                                                                            \
  develop(bool, ReplayIgnoreInitErrors, false,                              \
          "Ignore exceptions thrown during initialization for replay")      \
                                                                            \
3257 3258
  product(bool, DumpReplayDataOnError, true,                                \
          "Record replay data for crashing compiler threads")               \
3259
                                                                            \
D
duke 已提交
3260 3261 3262 3263 3264 3265 3266
  product(bool, CICompilerCountPerCPU, false,                               \
          "1 compiler thread for log(N CPUs)")                              \
                                                                            \
  develop(intx, CIFireOOMAt,    -1,                                         \
          "Fire OutOfMemoryErrors throughout CI for testing the compiler "  \
          "(non-negative value throws OOM after this many CI accesses "     \
          "in each compile)")                                               \
3267 3268 3269
  notproduct(intx, CICrashAt, -1,                                           \
          "id of compilation to trigger assert in compiler thread for "     \
          "the purpose of testing, e.g. generation of replay data")         \
3270 3271 3272
  notproduct(bool, CIObjectFactoryVerify, false,                            \
          "enable potentially expensive verification in ciObjectFactory")   \
                                                                            \
D
duke 已提交
3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
  /* Priorities */                                                          \
  product_pd(bool, UseThreadPriorities,  "Use native thread priorities")    \
                                                                            \
  product(intx, ThreadPriorityPolicy, 0,                                    \
          "0 : Normal.                                                     "\
          "    VM chooses priorities that are appropriate for normal       "\
          "    applications. On Solaris NORM_PRIORITY and above are mapped "\
          "    to normal native priority. Java priorities below NORM_PRIORITY"\
          "    map to lower native priority values. On Windows applications"\
          "    are allowed to use higher native priorities. However, with  "\
          "    ThreadPriorityPolicy=0, VM will not use the highest possible"\
          "    native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may   "\
          "    interfere with system threads. On Linux thread priorities   "\
          "    are ignored because the OS does not support static priority "\
          "    in SCHED_OTHER scheduling class which is the only choice for"\
          "    non-root, non-realtime applications.                        "\
          "1 : Aggressive.                                                 "\
          "    Java thread priorities map over to the entire range of      "\
          "    native thread priorities. Higher Java thread priorities map "\
          "    to higher native thread priorities. This policy should be   "\
          "    used with care, as sometimes it can cause performance       "\
          "    degradation in the application and/or the entire system. On "\
          "    Linux this policy requires root privilege.")                 \
                                                                            \
  product(bool, ThreadPriorityVerbose, false,                               \
3298
          "Print priority changes")                                         \
D
duke 已提交
3299 3300
                                                                            \
  product(intx, DefaultThreadPriority, -1,                                  \
3301 3302
          "The native priority at which threads run if not elsewhere "      \
          "specified (-1 means no change)")                                 \
D
duke 已提交
3303 3304
                                                                            \
  product(intx, CompilerThreadPriority, -1,                                 \
3305 3306
          "The native priority at which compiler threads should run "       \
          "(-1 means no change)")                                           \
D
duke 已提交
3307 3308
                                                                            \
  product(intx, VMThreadPriority, -1,                                       \
3309 3310
          "The native priority at which the VM thread should run "          \
          "(-1 means no change)")                                           \
D
duke 已提交
3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
                                                                            \
  product(bool, CompilerThreadHintNoPreempt, true,                          \
          "(Solaris only) Give compiler threads an extra quanta")           \
                                                                            \
  product(bool, VMThreadHintNoPreempt, false,                               \
          "(Solaris only) Give VM thread an extra quanta")                  \
                                                                            \
  product(intx, JavaPriority1_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority2_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority3_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority4_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority5_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority6_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority7_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority8_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority9_To_OSPriority, -1, "Map Java priorities to OS priorities") \
  product(intx, JavaPriority10_To_OSPriority,-1, "Map Java priorities to OS priorities") \
                                                                            \
3329 3330 3331 3332 3333 3334 3335 3336 3337
  experimental(bool, UseCriticalJavaThreadPriority, false,                  \
          "Java thread priority 10 maps to critical scheduling priority")   \
                                                                            \
  experimental(bool, UseCriticalCompilerThreadPriority, false,              \
          "Compiler thread(s) run at critical scheduling priority")         \
                                                                            \
  experimental(bool, UseCriticalCMSThreadPriority, false,                   \
          "ConcurrentMarkSweep thread runs at critical scheduling priority")\
                                                                            \
D
duke 已提交
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366
  /* compiler debugging */                                                  \
  notproduct(intx, CompileTheWorldStartAt,     1,                           \
          "First class to consider when using +CompileTheWorld")            \
                                                                            \
  notproduct(intx, CompileTheWorldStopAt, max_jint,                         \
          "Last class to consider when using +CompileTheWorld")             \
                                                                            \
  develop(intx, NewCodeParameter,      0,                                   \
          "Testing Only: Create a dedicated integer parameter before "      \
          "putback")                                                        \
                                                                            \
  /* new oopmap storage allocation */                                       \
  develop(intx, MinOopMapAllocation,     8,                                 \
          "Minimum number of OopMap entries in an OopMapSet")               \
                                                                            \
  /* Background Compilation */                                              \
  develop(intx, LongCompileThreshold,     50,                               \
          "Used with +TraceLongCompiles")                                   \
                                                                            \
  product(intx, StarvationMonitorInterval,    200,                          \
          "Pause between each check in ms")                                 \
                                                                            \
  /* recompilation */                                                       \
  product_pd(intx, CompileThreshold,                                        \
          "number of interpreted method invocations before (re-)compiling") \
                                                                            \
  product_pd(intx, BackEdgeThreshold,                                       \
          "Interpreter Back edge threshold at which an OSR compilation is invoked")\
                                                                            \
I
iveresov 已提交
3367 3368 3369 3370 3371 3372 3373 3374 3375
  product(intx, Tier0InvokeNotifyFreqLog, 7,                                \
          "Interpreter (tier 0) invocation notification frequency.")        \
                                                                            \
  product(intx, Tier2InvokeNotifyFreqLog, 11,                               \
          "C1 without MDO (tier 2) invocation notification frequency.")     \
                                                                            \
  product(intx, Tier3InvokeNotifyFreqLog, 10,                               \
          "C1 with MDO profiling (tier 3) invocation notification "         \
          "frequency.")                                                     \
3376 3377 3378
                                                                            \
  product(intx, Tier23InlineeNotifyFreqLog, 20,                             \
          "Inlinee invocation (tiers 2 and 3) notification frequency")      \
I
iveresov 已提交
3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401
                                                                            \
  product(intx, Tier0BackedgeNotifyFreqLog, 10,                             \
          "Interpreter (tier 0) invocation notification frequency.")        \
                                                                            \
  product(intx, Tier2BackedgeNotifyFreqLog, 14,                             \
          "C1 without MDO (tier 2) invocation notification frequency.")     \
                                                                            \
  product(intx, Tier3BackedgeNotifyFreqLog, 13,                             \
          "C1 with MDO profiling (tier 3) invocation notification "         \
          "frequency.")                                                     \
                                                                            \
  product(intx, Tier2CompileThreshold, 0,                                   \
          "threshold at which tier 2 compilation is invoked")               \
                                                                            \
  product(intx, Tier2BackEdgeThreshold, 0,                                  \
          "Back edge threshold at which tier 2 compilation is invoked")     \
                                                                            \
  product(intx, Tier3InvocationThreshold, 200,                              \
          "Compile if number of method invocations crosses this "           \
          "threshold")                                                      \
                                                                            \
  product(intx, Tier3MinInvocationThreshold, 100,                           \
          "Minimum invocation to compile at tier 3")                        \
D
duke 已提交
3402
                                                                            \
I
iveresov 已提交
3403 3404 3405
  product(intx, Tier3CompileThreshold, 2000,                                \
          "Threshold at which tier 3 compilation is invoked (invocation "   \
          "minimum must be satisfied.")                                     \
D
duke 已提交
3406
                                                                            \
3407
  product(intx, Tier3BackEdgeThreshold,  60000,                             \
I
iveresov 已提交
3408
          "Back edge threshold at which tier 3 OSR compilation is invoked") \
D
duke 已提交
3409
                                                                            \
I
iveresov 已提交
3410 3411 3412
  product(intx, Tier4InvocationThreshold, 5000,                             \
          "Compile if number of method invocations crosses this "           \
          "threshold")                                                      \
D
duke 已提交
3413
                                                                            \
I
iveresov 已提交
3414 3415
  product(intx, Tier4MinInvocationThreshold, 600,                           \
          "Minimum invocation to compile at tier 4")                        \
D
duke 已提交
3416
                                                                            \
I
iveresov 已提交
3417 3418 3419
  product(intx, Tier4CompileThreshold, 15000,                               \
          "Threshold at which tier 4 compilation is invoked (invocation "   \
          "minimum must be satisfied.")                                     \
D
duke 已提交
3420
                                                                            \
I
iveresov 已提交
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
  product(intx, Tier4BackEdgeThreshold, 40000,                              \
          "Back edge threshold at which tier 4 OSR compilation is invoked") \
                                                                            \
  product(intx, Tier3DelayOn, 5,                                            \
          "If C2 queue size grows over this amount per compiler thread "    \
          "stop compiling at tier 3 and start compiling at tier 2")         \
                                                                            \
  product(intx, Tier3DelayOff, 2,                                           \
          "If C2 queue size is less than this amount per compiler thread "  \
          "allow methods compiled at tier 2 transition to tier 3")          \
                                                                            \
  product(intx, Tier3LoadFeedback, 5,                                       \
          "Tier 3 thresholds will increase twofold when C1 queue size "     \
          "reaches this amount per compiler thread")                        \
                                                                            \
  product(intx, Tier4LoadFeedback, 3,                                       \
          "Tier 4 thresholds will increase twofold when C2 queue size "     \
          "reaches this amount per compiler thread")                        \
                                                                            \
  product(intx, TieredCompileTaskTimeout, 50,                               \
          "Kill compile task if method was not used within "                \
          "given timeout in milliseconds")                                  \
                                                                            \
  product(intx, TieredStopAtLevel, 4,                                       \
          "Stop at given compilation level")                                \
                                                                            \
  product(intx, Tier0ProfilingStartPercentage, 200,                         \
          "Start profiling in interpreter if the counters exceed tier 3"    \
          "thresholds by the specified percentage")                         \
                                                                            \
3451 3452 3453 3454
  product(uintx, IncreaseFirstTierCompileThresholdAt, 50,                   \
          "Increase the compile threshold for C1 compilation if the code"   \
          "cache is filled by the specified percentage.")                   \
                                                                            \
I
iveresov 已提交
3455 3456 3457 3458 3459
  product(intx, TieredRateUpdateMinTime, 1,                                 \
          "Minimum rate sampling interval (in milliseconds)")               \
                                                                            \
  product(intx, TieredRateUpdateMaxTime, 25,                                \
          "Maximum rate sampling interval (in milliseconds)")               \
D
duke 已提交
3460 3461
                                                                            \
  product_pd(bool, TieredCompilation,                                       \
I
iveresov 已提交
3462 3463 3464 3465
          "Enable tiered compilation")                                      \
                                                                            \
  product(bool, PrintTieredEvents, false,                                   \
          "Print tiered events notifications")                              \
D
duke 已提交
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511
                                                                            \
  product_pd(intx, OnStackReplacePercentage,                                \
          "NON_TIERED number of method invocations/branches (expressed as %"\
          "of CompileThreshold) before (re-)compiling OSR code")            \
                                                                            \
  product(intx, InterpreterProfilePercentage, 33,                           \
          "NON_TIERED number of method invocations/branches (expressed as %"\
          "of CompileThreshold) before profiling in the interpreter")       \
                                                                            \
  develop(intx, MaxRecompilationSearchLength,    10,                        \
          "max. # frames to inspect searching for recompilee")              \
                                                                            \
  develop(intx, MaxInterpretedSearchLength,     3,                          \
          "max. # interp. frames to skip when searching for recompilee")    \
                                                                            \
  develop(intx, DesiredMethodLimit,  8000,                                  \
          "desired max. method size (in bytecodes) after inlining")         \
                                                                            \
  develop(intx, HugeMethodLimit,  8000,                                     \
          "don't compile methods larger than this if "                      \
          "+DontCompileHugeMethods")                                        \
                                                                            \
  /* New JDK 1.4 reflection implementation */                               \
                                                                            \
  develop(bool, UseNewReflection, true,                                     \
          "Temporary flag for transition to reflection based on dynamic "   \
          "bytecode generation in 1.4; can no longer be turned off in 1.4 " \
          "JDK, and is unneeded in 1.3 JDK, but marks most places VM "      \
          "changes were needed")                                            \
                                                                            \
  develop(bool, VerifyReflectionBytecodes, false,                           \
          "Force verification of 1.4 reflection bytecodes. Does not work "  \
          "in situations like that described in 4486457 or for "            \
          "constructors generated for serialization, so can not be enabled "\
          "in product.")                                                    \
                                                                            \
  product(bool, ReflectionWrapResolutionErrors, true,                       \
          "Temporary flag for transition to AbstractMethodError wrapped "   \
          "in InvocationTargetException. See 6531596")                      \
                                                                            \
                                                                            \
  develop(intx, FastSuperclassLimit, 8,                                     \
          "Depth of hardwired instanceof accelerator array")                \
                                                                            \
  /* Properties for Java libraries  */                                      \
                                                                            \
3512
  product(uintx, MaxDirectMemorySize, 0,                                    \
D
duke 已提交
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
          "Maximum total size of NIO direct-buffer allocations")            \
                                                                            \
  /* temporary developer defined flags  */                                  \
                                                                            \
  diagnostic(bool, UseNewCode, false,                                       \
          "Testing Only: Use the new version while testing")                \
                                                                            \
  diagnostic(bool, UseNewCode2, false,                                      \
          "Testing Only: Use the new version while testing")                \
                                                                            \
  diagnostic(bool, UseNewCode3, false,                                      \
          "Testing Only: Use the new version while testing")                \
                                                                            \
  /* flags for performance data collection */                               \
                                                                            \
3528
  product(bool, UsePerfData, falseInEmbedded,                               \
D
duke 已提交
3529
          "Flag to disable jvmstat instrumentation for performance testing" \
3530
          "and problem isolation purposes.")                                \
D
duke 已提交
3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581
                                                                            \
  product(bool, PerfDataSaveToFile, false,                                  \
          "Save PerfData memory to hsperfdata_<pid> file on exit")          \
                                                                            \
  product(ccstr, PerfDataSaveFile, NULL,                                    \
          "Save PerfData memory to the specified absolute pathname,"        \
           "%p in the file name if present will be replaced by pid")        \
                                                                            \
  product(intx, PerfDataSamplingInterval, 50 /*ms*/,                        \
          "Data sampling interval in milliseconds")                         \
                                                                            \
  develop(bool, PerfTraceDataCreation, false,                               \
          "Trace creation of Performance Data Entries")                     \
                                                                            \
  develop(bool, PerfTraceMemOps, false,                                     \
          "Trace PerfMemory create/attach/detach calls")                    \
                                                                            \
  product(bool, PerfDisableSharedMem, false,                                \
          "Store performance data in standard memory")                      \
                                                                            \
  product(intx, PerfDataMemorySize, 32*K,                                   \
          "Size of performance data memory region. Will be rounded "        \
          "up to a multiple of the native os page size.")                   \
                                                                            \
  product(intx, PerfMaxStringConstLength, 1024,                             \
          "Maximum PerfStringConstant string length before truncation")     \
                                                                            \
  product(bool, PerfAllowAtExitRegistration, false,                         \
          "Allow registration of atexit() methods")                         \
                                                                            \
  product(bool, PerfBypassFileSystemCheck, false,                           \
          "Bypass Win32 file system criteria checks (Windows Only)")        \
                                                                            \
  product(intx, UnguardOnExecutionViolation, 0,                             \
          "Unguard page and retry on no-execute fault (Win32 only)"         \
          "0=off, 1=conservative, 2=aggressive")                            \
                                                                            \
  /* Serviceability Support */                                              \
                                                                            \
  product(bool, ManagementServer, false,                                    \
          "Create JMX Management Server")                                   \
                                                                            \
  product(bool, DisableAttachMechanism, false,                              \
         "Disable mechanism that allows tools to attach to this VM")        \
                                                                            \
  product(bool, StartAttachListener, false,                                 \
          "Always start Attach Listener at VM startup")                     \
                                                                            \
  manageable(bool, PrintConcurrentLocks, false,                             \
          "Print java.util.concurrent locks in thread dump")                \
                                                                            \
3582
  product(bool, TransmitErrorReport, false,                                 \
3583 3584
          "Enable error report transmission on erroneous termination")      \
                                                                            \
3585
  product(ccstr, ErrorReportServer, NULL,                                   \
3586 3587
          "Override built-in error report server address")                  \
                                                                            \
D
duke 已提交
3588 3589 3590
  /* Shared spaces */                                                       \
                                                                            \
  product(bool, UseSharedSpaces, true,                                      \
3591
          "Use shared spaces for metadata")                                 \
D
duke 已提交
3592 3593
                                                                            \
  product(bool, RequireSharedSpaces, false,                                 \
3594
          "Require shared spaces for metadata")                             \
D
duke 已提交
3595 3596 3597 3598 3599 3600 3601 3602 3603
                                                                            \
  product(bool, DumpSharedSpaces, false,                                    \
           "Special mode: JVM reads a class list, loads classes, builds "   \
            "shared spaces, and dumps the shared spaces to a file to be "   \
            "used in future JVM runs.")                                     \
                                                                            \
  product(bool, PrintSharedSpaces, false,                                   \
          "Print usage of shared spaces")                                   \
                                                                            \
3604
  product(uintx, SharedReadWriteSize,  NOT_LP64(12*M) LP64_ONLY(16*M),      \
3605
          "Size of read-write space for metadata (in bytes)")               \
D
duke 已提交
3606
                                                                            \
3607
  product(uintx, SharedReadOnlySize,  NOT_LP64(12*M) LP64_ONLY(16*M),       \
3608
          "Size of read-only space for metadata (in bytes)")                \
D
duke 已提交
3609
                                                                            \
3610
  product(uintx, SharedMiscDataSize,    NOT_LP64(2*M) LP64_ONLY(4*M),       \
3611
          "Size of the shared miscellaneous data area (in bytes)")          \
D
duke 已提交
3612
                                                                            \
3613
  product(uintx, SharedMiscCodeSize,    120*K,                              \
3614
          "Size of the shared miscellaneous code area (in bytes)")          \
D
duke 已提交
3615
                                                                            \
3616 3617 3618
  product(uintx, SharedBaseAddress, LP64_ONLY(32*G)                         \
          NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)),                           \
          "Address to allocate shared memory region for class data")        \
D
duke 已提交
3619
                                                                            \
3620 3621 3622 3623
  diagnostic(bool, EnableInvokeDynamic, true,                               \
          "support JSR 292 (method handles, invokedynamic, "                \
          "anonymous classes")                                              \
                                                                            \
3624 3625 3626
  diagnostic(bool, PrintMethodHandleStubs, false,                           \
          "Print generated stub code for method handles")                   \
                                                                            \
3627 3628 3629 3630 3631 3632
  develop(bool, TraceMethodHandles, false,                                  \
          "trace internal method handle operations")                        \
                                                                            \
  diagnostic(bool, VerifyMethodHandles, trueInDebug,                        \
          "perform extra checks when constructing method handles")          \
                                                                            \
3633 3634
  diagnostic(bool, ShowHiddenFrames, false,                                 \
          "show method handle implementation frames (usually hidden)")      \
3635
                                                                            \
3636 3637 3638
  experimental(bool, TrustFinalNonStaticFields, false,                      \
          "trust final non-static declarations for constant folding")       \
                                                                            \
3639 3640 3641
  develop(bool, TraceInvokeDynamic, false,                                  \
          "trace internal invoke dynamic operations")                       \
                                                                            \
D
duke 已提交
3642 3643 3644 3645 3646 3647 3648 3649
  diagnostic(bool, PauseAtStartup,      false,                              \
          "Causes the VM to pause at startup time and wait for the pause "  \
          "file to be removed (default: ./vm.paused.<pid>)")                \
                                                                            \
  diagnostic(ccstr, PauseAtStartupFile, NULL,                               \
          "The file to create and for whose removal to await when pausing " \
          "at startup. (default: ./vm.paused.<pid>)")                       \
                                                                            \
3650 3651 3652
  diagnostic(bool, PauseAtExit, false,                                      \
          "Pause and wait for keypress on exit if a debugger is attached")  \
                                                                            \
D
duke 已提交
3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667
  product(bool, ExtendedDTraceProbes,    false,                             \
          "Enable performance-impacting dtrace probes")                     \
                                                                            \
  product(bool, DTraceMethodProbes, false,                                  \
          "Enable dtrace probes for method-entry and method-exit")          \
                                                                            \
  product(bool, DTraceAllocProbes, false,                                   \
          "Enable dtrace probes for object allocation")                     \
                                                                            \
  product(bool, DTraceMonitorProbes, false,                                 \
          "Enable dtrace probes for monitor events")                        \
                                                                            \
  product(bool, RelaxAccessControlCheck, false,                             \
          "Relax the access control checks in the verifier")                \
                                                                            \
3668 3669 3670
  diagnostic(bool, PrintDTraceDOF, false,                                   \
             "Print the DTrace DOF passed to the system for JSDT probes")   \
                                                                            \
3671
  product(uintx, StringTableSize, defaultStringTableSize,                   \
3672 3673
          "Number of buckets in the interned String table")                 \
                                                                            \
3674 3675 3676 3677 3678 3679 3680 3681 3682
  develop(bool, TraceDefaultMethods, false,                                 \
          "Trace the default method processing steps")                      \
                                                                            \
  develop(bool, ParseAllGenericSignatures, false,                           \
          "Parse all generic signatures while classloading")                \
                                                                            \
  develop(bool, VerifyGenericSignatures, false,                             \
          "Abort VM on erroneous or inconsistent generic signatures")       \
                                                                            \
3683 3684 3685
  product(bool, ParseGenericDefaults, false,                                \
          "Parse generic signatures for default method handling")           \
                                                                            \
3686
  product(bool, UseVMInterruptibleIO, false,                                \
D
duke 已提交
3687
          "(Unstable, Solaris-specific) Thread interrupt before or with "   \
3688
          "EINTR for I/O operations results in OS_INTRPT. The default value"\
3689 3690 3691
          " of this flag is true for JDK 6 and earlier")                    \
                                                                            \
  diagnostic(bool, WhiteBoxAPI, false,                                      \
3692 3693 3694
          "Enable internal testing APIs")                                   \
                                                                            \
  product(bool, PrintGCCause, true,                                         \
K
kamg 已提交
3695 3696
          "Include GC cause in GC logging")                                 \
                                                                            \
3697 3698 3699
  product(bool , AllowNonVirtualCalls, false,                               \
          "Obey the ACC_SUPER flag and allow invokenonvirtual calls")       \
                                                                            \
3700 3701 3702
  diagnostic(ccstr, SharedArchiveFile, NULL,                                \
          "Override the default location of the CDS archive file")          \
                                                                            \
3703 3704 3705
  experimental(uintx, ArrayAllocatorMallocLimit,                            \
          SOLARIS_ONLY(64*K) NOT_SOLARIS(max_uintx),                        \
          "Allocation less than this value will be allocated "              \
S
sla 已提交
3706 3707 3708 3709 3710 3711 3712
          "using malloc. Larger allocations will use mmap.")                \
                                                                            \
  product(bool, EnableTracing, false,                                       \
          "Enable event-based tracing")                                     \
  product(bool, UseLockedTracing, false,                                    \
          "Use locked-tracing when doing event-based tracing")

D
duke 已提交
3713 3714 3715 3716 3717 3718 3719 3720 3721

/*
 *  Macros for factoring of globals
 */

// Interface macros
#define DECLARE_PRODUCT_FLAG(type, name, value, doc)    extern "C" type name;
#define DECLARE_PD_PRODUCT_FLAG(type, name, doc)        extern "C" type name;
#define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name;
3722
#define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name;
D
duke 已提交
3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733
#define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name;
#define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name;
#ifdef PRODUCT
#define DECLARE_DEVELOPER_FLAG(type, name, value, doc)  const type name = value;
#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc)      const type name = pd_##name;
#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc)
#else
#define DECLARE_DEVELOPER_FLAG(type, name, value, doc)  extern "C" type name;
#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc)      extern "C" type name;
#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc)  extern "C" type name;
#endif
3734 3735 3736 3737 3738 3739
// Special LP64 flags, product only needed for now.
#ifdef _LP64
#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
#else
#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) const type name = value;
#endif // _LP64
D
duke 已提交
3740 3741 3742 3743 3744

// Implementation macros
#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc)   type name = value;
#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc)       type name = pd_##name;
#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value;
3745
#define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value;
D
duke 已提交
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756
#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value;
#ifdef PRODUCT
#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) /* flag name is constant */
#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc)     /* flag name is constant */
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc)
#else
#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc)     type name = pd_##name;
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value;
#endif
3757 3758 3759 3760 3761
#ifdef _LP64
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc)   type name = value;
#else
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */
#endif // _LP64
D
duke 已提交
3762

3763
RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG, DECLARE_LP64_PRODUCT_FLAG)
D
duke 已提交
3764 3765

RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
3766

3767 3768
ARCH_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG)

3769 3770 3771 3772
// Extensions

#include "runtime/globals_ext.hpp"

3773
#endif // SHARE_VM_RUNTIME_GLOBALS_HPP