globals.hpp revision 8722:564b61ae7dc8
1177391Sobrien/* 2177391Sobrien * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3177391Sobrien * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4177391Sobrien * 5177391Sobrien * This code is free software; you can redistribute it and/or modify it 6177391Sobrien * under the terms of the GNU General Public License version 2 only, as 7177391Sobrien * published by the Free Software Foundation. 8177391Sobrien * 9177391Sobrien * This code is distributed in the hope that it will be useful, but WITHOUT 10177391Sobrien * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11177391Sobrien * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12177391Sobrien * version 2 for more details (a copy is included in the LICENSE file that 13177391Sobrien * accompanied this code). 14177391Sobrien * 15177391Sobrien * You should have received a copy of the GNU General Public License version 16177391Sobrien * 2 along with this work; if not, write to the Free Software Foundation, 17177391Sobrien * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18177391Sobrien * 19177391Sobrien * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20177391Sobrien * or visit www.oracle.com if you need additional information or have any 21177391Sobrien * questions. 22177391Sobrien * 23177391Sobrien */ 24177391Sobrien 25177391Sobrien#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP 26177391Sobrien#define SHARE_VM_RUNTIME_GLOBALS_HPP 27177391Sobrien 28177391Sobrien#include "utilities/debug.hpp" 29177391Sobrien 30177391Sobrien// use this for flags that are true per default in the tiered build 31177391Sobrien// but false in non-tiered builds, and vice versa 32177391Sobrien#ifdef TIERED 33177391Sobrien#define trueInTiered true 34177391Sobrien#define falseInTiered false 35177391Sobrien#else 36177391Sobrien#define trueInTiered false 37177391Sobrien#define falseInTiered true 38177391Sobrien#endif 39177391Sobrien 40177391Sobrien#ifdef TARGET_ARCH_x86 41177391Sobrien# include "globals_x86.hpp" 42177391Sobrien#endif 43177391Sobrien#ifdef TARGET_ARCH_sparc 44177391Sobrien# include "globals_sparc.hpp" 45177391Sobrien#endif 46177391Sobrien#ifdef TARGET_ARCH_zero 47177391Sobrien# include "globals_zero.hpp" 48177391Sobrien#endif 49177391Sobrien#ifdef TARGET_ARCH_arm 50177391Sobrien# include "globals_arm.hpp" 51177391Sobrien#endif 52177391Sobrien#ifdef TARGET_ARCH_ppc 53177391Sobrien# include "globals_ppc.hpp" 54177391Sobrien#endif 55177391Sobrien#ifdef TARGET_ARCH_aarch64 56177391Sobrien# include "globals_aarch64.hpp" 57177391Sobrien#endif 58177391Sobrien#ifdef TARGET_OS_FAMILY_linux 59177391Sobrien# include "globals_linux.hpp" 60177391Sobrien#endif 61177391Sobrien#ifdef TARGET_OS_FAMILY_solaris 62177391Sobrien# include "globals_solaris.hpp" 63177391Sobrien#endif 64177391Sobrien#ifdef TARGET_OS_FAMILY_windows 65177391Sobrien# include "globals_windows.hpp" 66177391Sobrien#endif 67177391Sobrien#ifdef TARGET_OS_FAMILY_aix 68177391Sobrien# include "globals_aix.hpp" 69177391Sobrien#endif 70177391Sobrien#ifdef TARGET_OS_FAMILY_bsd 71177391Sobrien# include "globals_bsd.hpp" 72177391Sobrien#endif 73177391Sobrien#ifdef TARGET_OS_ARCH_linux_x86 74177391Sobrien# include "globals_linux_x86.hpp" 75177391Sobrien#endif 76177391Sobrien#ifdef TARGET_OS_ARCH_linux_sparc 77177391Sobrien# include "globals_linux_sparc.hpp" 78177391Sobrien#endif 79177391Sobrien#ifdef TARGET_OS_ARCH_linux_zero 80177391Sobrien# include "globals_linux_zero.hpp" 81177391Sobrien#endif 82177391Sobrien#ifdef TARGET_OS_ARCH_solaris_x86 83177391Sobrien# include "globals_solaris_x86.hpp" 84177391Sobrien#endif 85177391Sobrien#ifdef TARGET_OS_ARCH_solaris_sparc 86177391Sobrien# include "globals_solaris_sparc.hpp" 87177391Sobrien#endif 88177391Sobrien#ifdef TARGET_OS_ARCH_windows_x86 89177391Sobrien# include "globals_windows_x86.hpp" 90177391Sobrien#endif 91177391Sobrien#ifdef TARGET_OS_ARCH_linux_arm 92177391Sobrien# include "globals_linux_arm.hpp" 93177391Sobrien#endif 94175261Sobrien#ifdef TARGET_OS_ARCH_linux_ppc 95175261Sobrien# include "globals_linux_ppc.hpp" 96175261Sobrien#endif 97175261Sobrien#ifdef TARGET_OS_ARCH_linux_aarch64 98175261Sobrien# include "globals_linux_aarch64.hpp" 99175261Sobrien#endif 100175261Sobrien#ifdef TARGET_OS_ARCH_aix_ppc 101175261Sobrien# include "globals_aix_ppc.hpp" 102175261Sobrien#endif 103175261Sobrien#ifdef TARGET_OS_ARCH_bsd_x86 104175261Sobrien# include "globals_bsd_x86.hpp" 105175261Sobrien#endif 106175261Sobrien#ifdef TARGET_OS_ARCH_bsd_zero 107175261Sobrien# include "globals_bsd_zero.hpp" 108175261Sobrien#endif 109175261Sobrien#ifdef COMPILER1 110175261Sobrien#ifdef TARGET_ARCH_x86 111175261Sobrien# include "c1_globals_x86.hpp" 112175261Sobrien#endif 113175261Sobrien#ifdef TARGET_ARCH_sparc 114175261Sobrien# include "c1_globals_sparc.hpp" 115175261Sobrien#endif 116175261Sobrien#ifdef TARGET_ARCH_arm 117175261Sobrien# include "c1_globals_arm.hpp" 118175261Sobrien#endif 119175261Sobrien#ifdef TARGET_ARCH_aarch64 120175261Sobrien# include "c1_globals_aarch64.hpp" 121175261Sobrien#endif 122175261Sobrien#ifdef TARGET_OS_FAMILY_linux 123175261Sobrien# include "c1_globals_linux.hpp" 124175261Sobrien#endif 125175261Sobrien#ifdef TARGET_OS_FAMILY_solaris 126175261Sobrien# include "c1_globals_solaris.hpp" 127175261Sobrien#endif 128175261Sobrien#ifdef TARGET_OS_FAMILY_windows 129175261Sobrien# include "c1_globals_windows.hpp" 130175261Sobrien#endif 131175261Sobrien#ifdef TARGET_OS_FAMILY_aix 132175261Sobrien# include "c1_globals_aix.hpp" 133175261Sobrien#endif 134175261Sobrien#ifdef TARGET_OS_FAMILY_bsd 135175261Sobrien# include "c1_globals_bsd.hpp" 136175261Sobrien#endif 137175261Sobrien#ifdef TARGET_ARCH_ppc 138175261Sobrien# include "c1_globals_ppc.hpp" 139175261Sobrien#endif 140175261Sobrien#endif 141175261Sobrien#ifdef COMPILER2 142175261Sobrien#ifdef TARGET_ARCH_x86 143175261Sobrien# include "c2_globals_x86.hpp" 144175261Sobrien#endif 145175261Sobrien#ifdef TARGET_ARCH_sparc 146175261Sobrien# include "c2_globals_sparc.hpp" 147175261Sobrien#endif 148175261Sobrien#ifdef TARGET_ARCH_arm 149175261Sobrien# include "c2_globals_arm.hpp" 150175261Sobrien#endif 151175261Sobrien#ifdef TARGET_ARCH_ppc 152175261Sobrien# include "c2_globals_ppc.hpp" 153175261Sobrien#endif 154175261Sobrien#ifdef TARGET_ARCH_aarch64 155175261Sobrien# include "c2_globals_aarch64.hpp" 156175261Sobrien#endif 157175261Sobrien#ifdef TARGET_OS_FAMILY_linux 158175261Sobrien# include "c2_globals_linux.hpp" 159175261Sobrien#endif 160175261Sobrien#ifdef TARGET_OS_FAMILY_solaris 161175261Sobrien# include "c2_globals_solaris.hpp" 162175261Sobrien#endif 163175261Sobrien#ifdef TARGET_OS_FAMILY_windows 164175261Sobrien# include "c2_globals_windows.hpp" 165175261Sobrien#endif 166175261Sobrien#ifdef TARGET_OS_FAMILY_aix 167175261Sobrien# include "c2_globals_aix.hpp" 168175261Sobrien#endif 169175261Sobrien#ifdef TARGET_OS_FAMILY_bsd 170175261Sobrien# include "c2_globals_bsd.hpp" 171175261Sobrien#endif 172175261Sobrien#endif 173175261Sobrien#ifdef SHARK 174175261Sobrien#ifdef TARGET_ARCH_zero 175175261Sobrien# include "shark_globals_zero.hpp" 176175261Sobrien#endif 177175261Sobrien#endif 178175261Sobrien 179175261Sobrien#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK) 180175261Sobriendefine_pd_global(bool, BackgroundCompilation, false); 181175261Sobriendefine_pd_global(bool, UseTLAB, false); 182175261Sobriendefine_pd_global(bool, CICompileOSR, false); 183175261Sobriendefine_pd_global(bool, UseTypeProfile, false); 184175261Sobriendefine_pd_global(bool, UseOnStackReplacement, false); 185175261Sobriendefine_pd_global(bool, InlineIntrinsics, false); 186175261Sobriendefine_pd_global(bool, PreferInterpreterNativeStubs, true); 187175261Sobriendefine_pd_global(bool, ProfileInterpreter, false); 188175261Sobriendefine_pd_global(bool, ProfileTraps, false); 189175261Sobriendefine_pd_global(bool, TieredCompilation, false); 190175261Sobrien 191175261Sobriendefine_pd_global(intx, CompileThreshold, 0); 192175261Sobrien 193175261Sobriendefine_pd_global(intx, OnStackReplacePercentage, 0); 194175261Sobriendefine_pd_global(bool, ResizeTLAB, false); 195175261Sobriendefine_pd_global(intx, FreqInlineSize, 0); 196175261Sobriendefine_pd_global(size_t, NewSizeThreadIncrease, 4*K); 197175261Sobriendefine_pd_global(intx, InlineClassNatives, true); 198175261Sobriendefine_pd_global(intx, InlineUnsafeOps, true); 199175261Sobriendefine_pd_global(intx, InitialCodeCacheSize, 160*K); 200175261Sobriendefine_pd_global(intx, ReservedCodeCacheSize, 32*M); 201175261Sobriendefine_pd_global(intx, NonProfiledCodeHeapSize, 0); 202175261Sobriendefine_pd_global(intx, ProfiledCodeHeapSize, 0); 203175261Sobriendefine_pd_global(intx, NonNMethodCodeHeapSize, 32*M); 204175261Sobrien 205175261Sobriendefine_pd_global(intx, CodeCacheExpansionSize, 32*K); 206175261Sobriendefine_pd_global(intx, CodeCacheMinBlockLength, 1); 207175261Sobriendefine_pd_global(intx, CodeCacheMinimumUseSpace, 200*K); 208175261Sobriendefine_pd_global(size_t, MetaspaceSize, ScaleForWordSize(4*M)); 209175261Sobriendefine_pd_global(bool, NeverActAsServerClassMachine, true); 210175261Sobriendefine_pd_global(uint64_t,MaxRAM, 1ULL*G); 211175261Sobrien#define CI_COMPILER_COUNT 0 212175261Sobrien#else 213175261Sobrien 214175261Sobrien#ifdef COMPILER2 215175261Sobrien#define CI_COMPILER_COUNT 2 216175261Sobrien#else 217175261Sobrien#define CI_COMPILER_COUNT 1 218175261Sobrien#endif // COMPILER2 219175261Sobrien 220175261Sobrien#endif // no compilers 221175261Sobrien 222175261Sobrien// string type aliases used only in this file 223175261Sobrientypedef const char* ccstr; 224175261Sobrientypedef const char* ccstrlist; // represents string arguments which accumulate 225175261Sobrien 226175261Sobrienstruct Flag { 227175261Sobrien enum Flags { 228175261Sobrien // value origin 229175261Sobrien DEFAULT = 0, 230175261Sobrien COMMAND_LINE = 1, 231175261Sobrien ENVIRON_VAR = 2, 232175261Sobrien CONFIG_FILE = 3, 233175261Sobrien MANAGEMENT = 4, 234175261Sobrien ERGONOMIC = 5, 235175261Sobrien ATTACH_ON_DEMAND = 6, 236175261Sobrien INTERNAL = 7, 237175261Sobrien 238175261Sobrien LAST_VALUE_ORIGIN = INTERNAL, 239175261Sobrien VALUE_ORIGIN_BITS = 4, 240175261Sobrien VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS), 241175261Sobrien 242175261Sobrien // flag kind 243175261Sobrien KIND_PRODUCT = 1 << 4, 244175261Sobrien KIND_MANAGEABLE = 1 << 5, 245175261Sobrien KIND_DIAGNOSTIC = 1 << 6, 246175261Sobrien KIND_EXPERIMENTAL = 1 << 7, 247175261Sobrien KIND_NOT_PRODUCT = 1 << 8, 248175261Sobrien KIND_DEVELOP = 1 << 9, 249175261Sobrien KIND_PLATFORM_DEPENDENT = 1 << 10, 250175261Sobrien KIND_READ_WRITE = 1 << 11, 251175261Sobrien KIND_C1 = 1 << 12, 252175261Sobrien KIND_C2 = 1 << 13, 253175261Sobrien KIND_ARCH = 1 << 14, 254175261Sobrien KIND_SHARK = 1 << 15, 255175261Sobrien KIND_LP64_PRODUCT = 1 << 16, 256175261Sobrien KIND_COMMERCIAL = 1 << 17, 257175261Sobrien 258175261Sobrien KIND_MASK = ~VALUE_ORIGIN_MASK 259175261Sobrien }; 260175261Sobrien 261175261Sobrien enum Error { 262175261Sobrien // no error 263175261Sobrien SUCCESS = 0, 264175261Sobrien // flag name is missing 265175261Sobrien MISSING_NAME, 266175261Sobrien // flag value is missing 267175261Sobrien MISSING_VALUE, 268175261Sobrien // error parsing the textual form of the value 269175261Sobrien WRONG_FORMAT, 270175261Sobrien // flag is not writeable 271175261Sobrien NON_WRITABLE, 272175261Sobrien // flag value is outside of its bounds 273175261Sobrien OUT_OF_BOUNDS, 274175261Sobrien // flag value violates its constraint 275175261Sobrien VIOLATES_CONSTRAINT, 276175261Sobrien // there is no flag with the given name 277175261Sobrien INVALID_FLAG, 278175261Sobrien // other, unspecified error related to setting the flag 279175261Sobrien ERR_OTHER 280175261Sobrien }; 281175261Sobrien 282175261Sobrien const char* _type; 283175261Sobrien const char* _name; 284175261Sobrien void* _addr; 285175261Sobrien NOT_PRODUCT(const char* _doc;) 286175261Sobrien Flags _flags; 287175261Sobrien 288175261Sobrien // points to all Flags static array 289175261Sobrien static Flag* flags; 290175261Sobrien 291175261Sobrien // number of flags 292175261Sobrien static size_t numFlags; 293175261Sobrien 294175261Sobrien static Flag* find_flag(const char* name) { return find_flag(name, strlen(name), true, true); }; 295175261Sobrien static Flag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = false); 296175261Sobrien static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false); 297175261Sobrien 298175261Sobrien void check_writable(); 299175261Sobrien 300175261Sobrien bool is_bool() const; 301175261Sobrien bool get_bool() const; 302175261Sobrien void set_bool(bool value); 303175261Sobrien 304175261Sobrien bool is_int() const; 305175261Sobrien int get_int() const; 306175261Sobrien void set_int(int value); 307175261Sobrien 308175261Sobrien bool is_uint() const; 309175261Sobrien uint get_uint() const; 310175261Sobrien void set_uint(uint value); 311175261Sobrien 312175261Sobrien bool is_intx() const; 313175261Sobrien intx get_intx() const; 314175261Sobrien void set_intx(intx value); 315175261Sobrien 316175261Sobrien bool is_uintx() const; 317175261Sobrien uintx get_uintx() const; 318175261Sobrien void set_uintx(uintx value); 319175261Sobrien 320175261Sobrien bool is_uint64_t() const; 321175261Sobrien uint64_t get_uint64_t() const; 322175261Sobrien void set_uint64_t(uint64_t value); 323175261Sobrien 324175261Sobrien bool is_size_t() const; 325175261Sobrien size_t get_size_t() const; 326175261Sobrien void set_size_t(size_t value); 327175261Sobrien 328175261Sobrien bool is_double() const; 329175261Sobrien double get_double() const; 330175261Sobrien void set_double(double value); 331175261Sobrien 332175261Sobrien bool is_ccstr() const; 333175261Sobrien bool ccstr_accumulates() const; 334175261Sobrien ccstr get_ccstr() const; 335175261Sobrien void set_ccstr(ccstr value); 336175261Sobrien 337175261Sobrien Flags get_origin(); 338175261Sobrien void set_origin(Flags origin); 339175261Sobrien 340175261Sobrien bool is_default(); 341175261Sobrien bool is_ergonomic(); 342175261Sobrien bool is_command_line(); 343175261Sobrien 344175261Sobrien bool is_product() const; 345175261Sobrien bool is_manageable() const; 346175261Sobrien bool is_diagnostic() const; 347175261Sobrien bool is_experimental() const; 348175261Sobrien bool is_notproduct() const; 349175261Sobrien bool is_develop() const; 350175261Sobrien bool is_read_write() const; 351175261Sobrien bool is_commercial() const; 352175261Sobrien 353175261Sobrien bool is_constant_in_binary() const; 354175261Sobrien 355175261Sobrien bool is_unlocker() const; 356175261Sobrien bool is_unlocked() const; 357175261Sobrien bool is_writeable() const; 358175261Sobrien bool is_external() const; 359175261Sobrien 360175261Sobrien bool is_unlocker_ext() const; 361175261Sobrien bool is_unlocked_ext() const; 362175261Sobrien bool is_writeable_ext() const; 363175261Sobrien bool is_external_ext() const; 364175261Sobrien 365175261Sobrien void unlock_diagnostic(); 366175261Sobrien 367175261Sobrien void get_locked_message(char*, int) const; 368175261Sobrien void get_locked_message_ext(char*, int) const; 369175261Sobrien 370175261Sobrien // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges 371175261Sobrien void print_on(outputStream* st, bool withComments = false, bool printRanges = false); 372130303Speter void print_kind(outputStream* st); 373130303Speter void print_as_flag(outputStream* st); 374130303Speter 375130303Speter static const char* flag_error_str(Flag::Error error) { 376130303Speter switch (error) { 377130303Speter case Flag::MISSING_NAME: return "MISSING_NAME"; 378130303Speter case Flag::MISSING_VALUE: return "MISSING_VALUE"; 379130303Speter case Flag::NON_WRITABLE: return "NON_WRITABLE"; 380130303Speter case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS"; 381130303Speter case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT"; 382130303Speter case Flag::INVALID_FLAG: return "INVALID_FLAG"; 383130303Speter case Flag::ERR_OTHER: return "ERR_OTHER"; 384130303Speter case Flag::SUCCESS: return "SUCCESS"; 385130303Speter default: return "NULL"; 386130303Speter } 387130303Speter } 388130303Speter}; 389130303Speter 390130303Speter// debug flags control various aspects of the VM and are global accessible 391130303Speter 392130303Speter// use FlagSetting to temporarily change some debug flag 393130303Speter// e.g. FlagSetting fs(DebugThisAndThat, true); 394130303Speter// restored to previous value upon leaving scope 395130303Speterclass FlagSetting { 396130303Speter bool val; 397130303Speter bool* flag; 398130303Speter public: 399130303Speter FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; } 400130303Speter ~FlagSetting() { *flag = val; } 401130303Speter}; 402130303Speter 403130303Speter 404130303Speterclass CounterSetting { 405130303Speter intx* counter; 406130303Speter public: 407130303Speter CounterSetting(intx* cnt) { counter = cnt; (*counter)++; } 408130303Speter ~CounterSetting() { (*counter)--; } 409130303Speter}; 410130303Speter 411130303Speterclass IntFlagSetting { 412130303Speter int val; 413130303Speter int* flag; 414130303Speter public: 415130303Speter IntFlagSetting(int& fl, int newValue) { flag = &fl; val = fl; fl = newValue; } 416130303Speter ~IntFlagSetting() { *flag = val; } 417130303Speter}; 418130303Speter 419130303Speterclass UIntFlagSetting { 420130303Speter uint val; 421130303Speter uint* flag; 422130303Speter public: 423130303Speter UIntFlagSetting(uint& fl, uint newValue) { flag = &fl; val = fl; fl = newValue; } 424130303Speter ~UIntFlagSetting() { *flag = val; } 425130303Speter}; 426130303Speter 427130303Speterclass UIntXFlagSetting { 428130303Speter uintx val; 429130303Speter uintx* flag; 430130303Speter public: 431130303Speter UIntXFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; } 432130303Speter ~UIntXFlagSetting() { *flag = val; } 433130303Speter}; 434130303Speter 435130303Speterclass DoubleFlagSetting { 436130303Speter double val; 437130303Speter double* flag; 438130303Speter public: 439130303Speter DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; } 440130303Speter ~DoubleFlagSetting() { *flag = val; } 441130303Speter}; 442130303Speter 443130303Speterclass SizeTFlagSetting { 444130303Speter size_t val; 445130303Speter size_t* flag; 446130303Speter public: 447130303Speter SizeTFlagSetting(size_t& fl, size_t newValue) { flag = &fl; val = fl; fl = newValue; } 448130303Speter ~SizeTFlagSetting() { *flag = val; } 449130303Speter}; 450130303Speter 451130303Speter 452128266Speterclass CommandLineFlags { 453128266Speter static bool _finished_initializing; 454128266Speterpublic: 455128266Speter static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false); 456128266Speter static Flag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false) { return boolAt(name, strlen(name), value, allow_locked, return_flag); } 457128266Speter static Flag::Error boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin); 458128266Speter static Flag::Error boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); } 459128266Speter 460128266Speter static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false); 461128266Speter static Flag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); } 462128266Speter static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin); 463128266Speter static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); } 464128266Speter 465128266Speter static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false); 466128266Speter static Flag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); } 467128266Speter static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin); 468128266Speter static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); } 469128266Speter 470128266Speter static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false); 471128266Speter static Flag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); } 472128266Speter static Flag::Error intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin); 473128266Speter static Flag::Error intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); } 474128266Speter 475128266Speter static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false); 476128266Speter static Flag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false) { return uintxAt(name, strlen(name), value, allow_locked, return_flag); } 477128266Speter static Flag::Error uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin); 478128266Speter static Flag::Error uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); } 479128266Speter 480128266Speter static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false); 481128266Speter static Flag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false) { return size_tAt(name, strlen(name), value, allow_locked, return_flag); } 482128266Speter static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin); 483128266Speter static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); } 484128266Speter 485128266Speter static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false); 486128266Speter static Flag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); } 487128266Speter static Flag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin); 488128266Speter static Flag::Error uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); } 489128266Speter 490128266Speter static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false); 491128266Speter static Flag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false) { return doubleAt(name, strlen(name), value, allow_locked, return_flag); } 492128266Speter static Flag::Error doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin); 493128266Speter static Flag::Error doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); } 494128266Speter 495128266Speter static Flag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false); 496128266Speter static Flag::Error ccstrAt(const char* name, ccstr* value, bool allow_locked = false, bool return_flag = false) { return ccstrAt(name, strlen(name), value, allow_locked, return_flag); } 497128266Speter // Contract: Flag will make private copy of the incoming value. 498128266Speter // Outgoing value is always malloc-ed, and caller MUST call free. 499128266Speter static Flag::Error ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin); 500128266Speter static Flag::Error ccstrAtPut(const char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); } 501128266Speter 502128266Speter // Returns false if name is not a command line flag. 503128266Speter static bool wasSetOnCmdline(const char* name, bool* value); 504128266Speter static void printSetFlags(outputStream* out); 505128266Speter 506128266Speter // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges 507128266Speter static void printFlags(outputStream* out, bool withComments, bool printRanges = false); 508128266Speter 509128266Speter // Returns true if all flags have their final values set (ready for ranges and constraint check) 510128266Speter static bool finishedInitializing() { return _finished_initializing; } 511128266Speter 512128266Speter // Check the final values of all flags for ranges and constraints 513128266Speter static bool check_all_ranges_and_constraints(); 514128266Speter 515128266Speter static void verify() PRODUCT_RETURN; 516128266Speter}; 517128266Speter 518128266Speter// use this for flags that are true by default in the debug version but 519128266Speter// false in the optimized version, and vice versa 520128266Speter#ifdef ASSERT 521128266Speter#define trueInDebug true 522128266Speter#define falseInDebug false 523128266Speter#else 524128266Speter#define trueInDebug false 525128266Speter#define falseInDebug true 526128266Speter#endif 527128266Speter 528128266Speter// use this for flags that are true per default in the product build 529128266Speter// but false in development builds, and vice versa 530128266Speter#ifdef PRODUCT 531128266Speter#define trueInProduct true 532128266Speter#define falseInProduct false 533128266Speter#else 534128266Speter#define trueInProduct false 535128266Speter#define falseInProduct true 536128266Speter#endif 537128266Speter 538128266Speter#ifdef JAVASE_EMBEDDED 539128266Speter#define falseInEmbedded false 540128266Speter#else 541128266Speter#define falseInEmbedded true 542128266Speter#endif 543128266Speter 544128266Speter// develop flags are settable / visible only during development and are constant in the PRODUCT version 545128266Speter// product flags are always settable / visible 546128266Speter// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version 547128266Speter 548128266Speter// A flag must be declared with one of the following types: 549128266Speter// bool, intx, uintx, size_t, ccstr, double, or uint64_t. 550128266Speter// The type "ccstr" is an alias for "const char*" and is used 551128266Speter// only in this file, because the macrology requires single-token type names. 552128266Speter 553128266Speter// Note: Diagnostic options not meant for VM tuning or for product modes. 554128266Speter// They are to be used for VM quality assurance or field diagnosis 555128266Speter// of VM bugs. They are hidden so that users will not be encouraged to 556128266Speter// try them as if they were VM ordinary execution options. However, they 557128266Speter// are available in the product version of the VM. Under instruction 558128266Speter// from support engineers, VM customers can turn them on to collect 559128266Speter// diagnostic information about VM problems. To use a VM diagnostic 560128266Speter// option, you must first specify +UnlockDiagnosticVMOptions. 561128266Speter// (This master switch also affects the behavior of -Xprintflags.) 562128266Speter// 563128266Speter// experimental flags are in support of features that are not 564128266Speter// part of the officially supported product, but are available 565128266Speter// for experimenting with. They could, for example, be performance 566128266Speter// features that may not have undergone full or rigorous QA, but which may 567128266Speter// help performance in some cases and released for experimentation 568128266Speter// by the community of users and developers. This flag also allows one to 569128266Speter// be able to build a fully supported product that nonetheless also 570128266Speter// ships with some unsupported, lightly tested, experimental features. 571128266Speter// Like the UnlockDiagnosticVMOptions flag above, there is a corresponding 572128266Speter// UnlockExperimentalVMOptions flag, which allows the control and 573128266Speter// modification of the experimental flags. 574128266Speter// 575128266Speter// Nota bene: neither diagnostic nor experimental options should be used casually, 576128266Speter// and they are not supported on production loads, except under explicit 577128266Speter// direction from support engineers. 578128266Speter// 579128266Speter// manageable flags are writeable external product flags. 580128266Speter// They are dynamically writeable through the JDK management interface 581128266Speter// (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole. 582128266Speter// These flags are external exported interface (see CCC). The list of 583128266Speter// manageable flags can be queried programmatically through the management 584128266Speter// interface. 585128266Speter// 586128266Speter// A flag can be made as "manageable" only if 587128266Speter// - the flag is defined in a CCC as an external exported interface. 588128266Speter// - the VM implementation supports dynamic setting of the flag. 589128266Speter// This implies that the VM must *always* query the flag variable 590128266Speter// and not reuse state related to the flag state at any given time. 591128266Speter// - you want the flag to be queried programmatically by the customers. 592128266Speter// 593128266Speter// product_rw flags are writeable internal product flags. 594128266Speter// They are like "manageable" flags but for internal/private use. 595128266Speter// The list of product_rw flags are internal/private flags which 596128266Speter// may be changed/removed in a future release. It can be set 597128266Speter// through the management interface to get/set value 598128266Speter// when the name of flag is supplied. 599128266Speter// 600128266Speter// A flag can be made as "product_rw" only if 601128266Speter// - the VM implementation supports dynamic setting of the flag. 602128266Speter// This implies that the VM must *always* query the flag variable 603128266Speter// and not reuse state related to the flag state at any given time. 604128266Speter// 605128266Speter// Note that when there is a need to support develop flags to be writeable, 606128266Speter// it can be done in the same way as product_rw. 607128266Speter// 608128266Speter// range is a macro that will expand to min and max arguments for range 609128266Speter// checking code if provided - see commandLineFlagRangeList.hpp 610128266Speter// 611128266Speter// constraint is a macro that will expand to custom function call 612128266Speter// for constraint checking if provided - see commandLineFlagConstraintList.hpp 613128266Speter// 614128266Speter 615128266Speter#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product, range, constraint) \ 616128266Speter \ 617128266Speter lp64_product(bool, UseCompressedOops, false, \ 618128266Speter "Use 32-bit object references in 64-bit VM. " \ 619128266Speter "lp64_product means flag is always constant in 32 bit VM") \ 620128266Speter \ 621128266Speter lp64_product(bool, UseCompressedClassPointers, false, \ 622128266Speter "Use 32-bit class pointers in 64-bit VM. " \ 623128266Speter "lp64_product means flag is always constant in 32 bit VM") \ 624128266Speter \ 625128266Speter notproduct(bool, CheckCompressedOops, true, \ 626128266Speter "Generate checks in encoding/decoding code in debug VM") \ 627128266Speter \ 628128266Speter product_pd(size_t, HeapBaseMinAddress, \ 629128266Speter "OS specific low limit for heap base address") \ 630128266Speter \ 631128266Speter product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \ 632128266Speter "Heap allocation steps through preferred address regions to find" \ 633128266Speter " where it can allocate the heap. Number of steps to take per " \ 634128266Speter "region.") \ 635128266Speter range(1, max_uintx) \ 636128266Speter \ 637128266Speter diagnostic(bool, PrintCompressedOopsMode, false, \ 638128266Speter "Print compressed oops base address and encoding mode") \ 639128266Speter \ 640128266Speter lp64_product(intx, ObjectAlignmentInBytes, 8, \ 641128266Speter "Default object alignment in bytes, 8 is minimum") \ 642128266Speter range(8, 256) \ 643128266Speter constraint(ObjectAlignmentInBytesConstraintFunc) \ 644128266Speter \ 645128266Speter product(bool, AssumeMP, false, \ 646128266Speter "Instruct the VM to assume multiple processors are available") \ 647128266Speter \ 648128266Speter /* UseMembar is theoretically a temp flag used for memory barrier */ \ 649128266Speter /* removal testing. It was supposed to be removed before FCS but has */ \ 650128266Speter /* been re-added (see 6401008) */ \ 651128266Speter product_pd(bool, UseMembar, \ 652128266Speter "(Unstable) Issues membars on thread state transitions") \ 653128266Speter \ 654128266Speter develop(bool, CleanChunkPoolAsync, falseInEmbedded, \ 655128266Speter "Clean the chunk pool asynchronously") \ 656128266Speter \ 657128266Speter experimental(bool, AlwaysSafeConstructors, false, \ 658128266Speter "Force safe construction, as if all fields are final.") \ 659128266Speter \ 660128266Speter /* Temporary: See 6948537 */ \ 661128266Speter experimental(bool, UseMemSetInBOT, true, \ 662128266Speter "(Unstable) uses memset in BOT updates in GC code") \ 663128266Speter \ 664128266Speter diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \ 665128266Speter "Enable normal processing of flags relating to field diagnostics")\ 666128266Speter \ 667128266Speter experimental(bool, UnlockExperimentalVMOptions, false, \ 668128266Speter "Enable normal processing of flags relating to experimental " \ 669128266Speter "features") \ 670128266Speter \ 671128266Speter product(bool, JavaMonitorsInStackTrace, true, \ 672128266Speter "Print information about Java monitor locks when the stacks are" \ 673128266Speter "dumped") \ 674128266Speter \ 675128266Speter product_pd(bool, UseLargePages, \ 676128266Speter "Use large page memory") \ 677128266Speter \ 678128266Speter product_pd(bool, UseLargePagesIndividualAllocation, \ 679128266Speter "Allocate large pages individually for better affinity") \ 680128266Speter \ 681128266Speter develop(bool, LargePagesIndividualAllocationInjectError, false, \ 682128266Speter "Fail large pages individual allocation") \ 683128266Speter \ 684128266Speter product(bool, UseLargePagesInMetaspace, false, \ 685128266Speter "Use large page memory in metaspace. " \ 686128266Speter "Only used if UseLargePages is enabled.") \ 687128266Speter \ 688128266Speter develop(bool, TracePageSizes, false, \ 689128266Speter "Trace page size selection and usage") \ 690128266Speter \ 691128266Speter product(bool, UseNUMA, false, \ 692128266Speter "Use NUMA if available") \ 693128266Speter \ 694128266Speter product(bool, UseNUMAInterleaving, false, \ 695128266Speter "Interleave memory across NUMA nodes if available") \ 696128266Speter \ 697128266Speter product(size_t, NUMAInterleaveGranularity, 2*M, \ 698128266Speter "Granularity to use for NUMA interleaving on Windows OS") \ 699128266Speter \ 700128266Speter product(bool, ForceNUMA, false, \ 701128266Speter "Force NUMA optimizations on single-node/UMA systems") \ 702128266Speter \ 703128266Speter product(uintx, NUMAChunkResizeWeight, 20, \ 704128266Speter "Percentage (0-100) used to weight the current sample when " \ 705128266Speter "computing exponentially decaying average for " \ 706128266Speter "AdaptiveNUMAChunkSizing") \ 707128266Speter range(0, 100) \ 708128266Speter \ 709128266Speter product(size_t, NUMASpaceResizeRate, 1*G, \ 710128266Speter "Do not reallocate more than this amount per collection") \ 711128266Speter \ 712128266Speter product(bool, UseAdaptiveNUMAChunkSizing, true, \ 713128266Speter "Enable adaptive chunk sizing for NUMA") \ 714128266Speter \ 715128266Speter product(bool, NUMAStats, false, \ 716128266Speter "Print NUMA stats in detailed heap information") \ 717128266Speter \ 718128266Speter product(uintx, NUMAPageScanRate, 256, \ 719128266Speter "Maximum number of pages to include in the page scan procedure") \ 720128266Speter \ 721128266Speter product_pd(bool, NeedsDeoptSuspend, \ 722128266Speter "True for register window machines (sparc/ia64)") \ 723128266Speter \ 724128266Speter product(intx, UseSSE, 99, \ 725128266Speter "Highest supported SSE instructions set on x86/x64") \ 726128266Speter \ 727128266Speter product(bool, UseAES, false, \ 728128266Speter "Control whether AES instructions can be used on x86/x64") \ 729128266Speter \ 730128266Speter product(bool, UseSHA, false, \ 731128266Speter "Control whether SHA instructions can be used " \ 732128266Speter "on SPARC and on ARM") \ 733128266Speter \ 734128266Speter product(bool, UseGHASHIntrinsics, false, \ 735128266Speter "Use intrinsics for GHASH versions of crypto") \ 736128266Speter \ 737128266Speter product(size_t, LargePageSizeInBytes, 0, \ 738128266Speter "Large page size (0 to let VM choose the page size)") \ 739128266Speter \ 740128266Speter product(size_t, LargePageHeapSizeThreshold, 128*M, \ 741128266Speter "Use large pages if maximum heap is at least this big") \ 742128266Speter \ 743128266Speter product(bool, ForceTimeHighResolution, false, \ 744128266Speter "Using high time resolution (for Win32 only)") \ 745128266Speter \ 746128266Speter develop(bool, TraceItables, false, \ 747128266Speter "Trace initialization and use of itables") \ 748128266Speter \ 749128266Speter develop(bool, TracePcPatching, false, \ 750128266Speter "Trace usage of frame::patch_pc") \ 751128266Speter \ 752128266Speter develop(bool, TraceJumps, false, \ 753128266Speter "Trace assembly jumps in thread ring buffer") \ 754128266Speter \ 755128266Speter develop(bool, TraceRelocator, false, \ 756128266Speter "Trace the bytecode relocator") \ 757128266Speter \ 758128266Speter develop(bool, TraceLongCompiles, false, \ 759128266Speter "Print out every time compilation is longer than " \ 760128266Speter "a given threshold") \ 761128266Speter \ 762128266Speter develop(bool, SafepointALot, false, \ 763128266Speter "Generate a lot of safepoints. This works with " \ 764128266Speter "GuaranteedSafepointInterval") \ 765128266Speter \ 766128266Speter product_pd(bool, BackgroundCompilation, \ 767128266Speter "A thread requesting compilation is not blocked during " \ 768128266Speter "compilation") \ 769128266Speter \ 770128266Speter product(bool, PrintVMQWaitTime, false, \ 771128266Speter "Print out the waiting time in VM operation queue") \ 772128266Speter \ 773128266Speter develop(bool, TraceOopMapGeneration, false, \ 774128266Speter "Show OopMapGeneration") \ 775128266Speter \ 776128266Speter product(bool, MethodFlushing, true, \ 777128266Speter "Reclamation of zombie and not-entrant methods") \ 778128266Speter \ 779128266Speter develop(bool, VerifyStack, false, \ 780128266Speter "Verify stack of each thread when it is entering a runtime call") \ 781128266Speter \ 782128266Speter diagnostic(bool, ForceUnreachable, false, \ 783128266Speter "Make all non code cache addresses to be unreachable by " \ 784128266Speter "forcing use of 64bit literal fixups") \ 785128266Speter \ 786128266Speter notproduct(bool, StressDerivedPointers, false, \ 787128266Speter "Force scavenge when a derived pointer is detected on stack " \ 788128266Speter "after rtm call") \ 789128266Speter \ 790128266Speter develop(bool, TraceDerivedPointers, false, \ 791128266Speter "Trace traversal of derived pointers on stack") \ 792128266Speter \ 793128266Speter notproduct(bool, TraceCodeBlobStacks, false, \ 794128266Speter "Trace stack-walk of codeblobs") \ 795128266Speter \ 796128266Speter product(bool, PrintJNIResolving, false, \ 797128266Speter "Used to implement -v:jni") \ 798128266Speter \ 799128266Speter notproduct(bool, PrintRewrites, false, \ 800128266Speter "Print methods that are being rewritten") \ 801128266Speter \ 802128266Speter product(bool, UseInlineCaches, true, \ 803128266Speter "Use Inline Caches for virtual calls ") \ 804128266Speter \ 805128266Speter develop(bool, InlineArrayCopy, true, \ 806128266Speter "Inline arraycopy native that is known to be part of " \ 807128266Speter "base library DLL") \ 808128266Speter \ 809128266Speter develop(bool, InlineObjectHash, true, \ 810128266Speter "Inline Object::hashCode() native that is known to be part " \ 811128266Speter "of base library DLL") \ 812128266Speter \ 813128266Speter develop(bool, InlineNatives, true, \ 814128266Speter "Inline natives that are known to be part of base library DLL") \ 815128266Speter \ 816128266Speter develop(bool, InlineMathNatives, true, \ 817128266Speter "Inline SinD, CosD, etc.") \ 818128266Speter \ 819128266Speter develop(bool, InlineClassNatives, true, \ 820128266Speter "Inline Class.isInstance, etc") \ 821128266Speter \ 822128266Speter develop(bool, InlineThreadNatives, true, \ 823128266Speter "Inline Thread.currentThread, etc") \ 824128266Speter \ 825128266Speter develop(bool, InlineUnsafeOps, true, \ 826128266Speter "Inline memory ops (native methods) from sun.misc.Unsafe") \ 827128266Speter \ 828128266Speter product(bool, CriticalJNINatives, true, \ 829128266Speter "Check for critical JNI entry points") \ 830128266Speter \ 831128266Speter notproduct(bool, StressCriticalJNINatives, false, \ 832128266Speter "Exercise register saving code in critical natives") \ 833128266Speter \ 834128266Speter product(bool, UseSSE42Intrinsics, false, \ 835128266Speter "SSE4.2 versions of intrinsics") \ 836128266Speter \ 837128266Speter product(bool, UseAESIntrinsics, false, \ 838128266Speter "Use intrinsics for AES versions of crypto") \ 839128266Speter \ 840128266Speter product(bool, UseSHA1Intrinsics, false, \ 841128266Speter "Use intrinsics for SHA-1 crypto hash function. " \ 842128266Speter "Requires that UseSHA is enabled.") \ 843128266Speter \ 844128266Speter product(bool, UseSHA256Intrinsics, false, \ 845128266Speter "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. " \ 846128266Speter "Requires that UseSHA is enabled.") \ 847128266Speter \ 848128266Speter product(bool, UseSHA512Intrinsics, false, \ 849128266Speter "Use intrinsics for SHA-384 and SHA-512 crypto hash functions. " \ 850128266Speter "Requires that UseSHA is enabled.") \ 851128266Speter \ 852128266Speter product(bool, UseCRC32Intrinsics, false, \ 853128266Speter "use intrinsics for java.util.zip.CRC32") \ 854128266Speter \ 855128266Speter product(bool, UseCRC32CIntrinsics, false, \ 856128266Speter "use intrinsics for java.util.zip.CRC32C") \ 857128266Speter \ 858128266Speter develop(bool, TraceCallFixup, false, \ 859128266Speter "Trace all call fixups") \ 860128266Speter \ 861128266Speter develop(bool, DeoptimizeALot, false, \ 862128266Speter "Deoptimize at every exit from the runtime system") \ 863128266Speter \ 864128266Speter notproduct(ccstrlist, DeoptimizeOnlyAt, "", \ 865128266Speter "A comma separated list of bcis to deoptimize at") \ 866128266Speter \ 867128266Speter product(bool, DeoptimizeRandom, false, \ 868128266Speter "Deoptimize random frames on random exit from the runtime system")\ 869128266Speter \ 870128266Speter notproduct(bool, ZombieALot, false, \ 871128266Speter "Create zombies (non-entrant) at exit from the runtime system") \ 872128266Speter \ 873128266Speter product(bool, UnlinkSymbolsALot, false, \ 874128266Speter "Unlink unreferenced symbols from the symbol table at safepoints")\ 875128266Speter \ 876128266Speter notproduct(bool, WalkStackALot, false, \ 877128266Speter "Trace stack (no print) at every exit from the runtime system") \ 878128266Speter \ 879128266Speter product(bool, Debugging, false, \ 880128266Speter "Set when executing debug methods in debug.cpp " \ 881128266Speter "(to prevent triggering assertions)") \ 882128266Speter \ 883128266Speter notproduct(bool, StrictSafepointChecks, trueInDebug, \ 884128266Speter "Enable strict checks that safepoints cannot happen for threads " \ 885128266Speter "that use No_Safepoint_Verifier") \ 886128266Speter \ 887128266Speter notproduct(bool, VerifyLastFrame, false, \ 888128266Speter "Verify oops on last frame on entry to VM") \ 889128266Speter \ 890128266Speter develop(bool, TraceHandleAllocation, false, \ 891128266Speter "Print out warnings when suspiciously many handles are allocated")\ 892128266Speter \ 893128266Speter product(bool, FailOverToOldVerifier, true, \ 894128266Speter "Fail over to old verifier when split verifier fails") \ 895128266Speter \ 896128266Speter develop(bool, ShowSafepointMsgs, false, \ 897128266Speter "Show message about safepoint synchronization") \ 898128266Speter \ 899128266Speter product(bool, SafepointTimeout, false, \ 900128266Speter "Time out and warn or fail after SafepointTimeoutDelay " \ 901128266Speter "milliseconds if failed to reach safepoint") \ 902128266Speter \ 903128266Speter develop(bool, DieOnSafepointTimeout, false, \ 904128266Speter "Die upon failure to reach safepoint (see SafepointTimeout)") \ 905128266Speter \ 906128266Speter /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */ \ 907128266Speter /* typically, at most a few retries are needed */ \ 908128266Speter product(intx, SuspendRetryCount, 50, \ 909128266Speter "Maximum retry count for an external suspend request") \ 910128266Speter \ 911128266Speter product(intx, SuspendRetryDelay, 5, \ 912128266Speter "Milliseconds to delay per retry (* current_retry_count)") \ 913128266Speter \ 914128266Speter product(bool, AssertOnSuspendWaitFailure, false, \ 915128266Speter "Assert/Guarantee on external suspend wait failure") \ 916128266Speter \ 917128266Speter product(bool, TraceSuspendWaitFailures, false, \ 918128266Speter "Trace external suspend wait failures") \ 919128266Speter \ 920128266Speter product(bool, MaxFDLimit, true, \ 921128266Speter "Bump the number of file descriptors to maximum in Solaris") \ 922128266Speter \ 923128266Speter diagnostic(bool, LogEvents, true, \ 924128266Speter "Enable the various ring buffer event logs") \ 925128266Speter \ 926128266Speter diagnostic(uintx, LogEventsBufferEntries, 10, \ 927128266Speter "Number of ring buffer event logs") \ 928128266Speter range(1, NOT_LP64(1*K) LP64_ONLY(1*M)) \ 929128266Speter \ 930128266Speter product(bool, BytecodeVerificationRemote, true, \ 931128266Speter "Enable the Java bytecode verifier for remote classes") \ 932128266Speter \ 933128266Speter product(bool, BytecodeVerificationLocal, false, \ 934128266Speter "Enable the Java bytecode verifier for local classes") \ 935128266Speter \ 936128266Speter develop(bool, ForceFloatExceptions, trueInDebug, \ 937128266Speter "Force exceptions on FP stack under/overflow") \ 938128266Speter \ 939128266Speter develop(bool, VerifyStackAtCalls, false, \ 940128266Speter "Verify that the stack pointer is unchanged after calls") \ 941128266Speter \ 942128266Speter develop(bool, TraceJavaAssertions, false, \ 943128266Speter "Trace java language assertions") \ 944128266Speter \ 945128266Speter notproduct(bool, CheckAssertionStatusDirectives, false, \ 946128266Speter "Temporary - see javaClasses.cpp") \ 947128266Speter \ 948128266Speter notproduct(bool, PrintMallocFree, false, \ 949128266Speter "Trace calls to C heap malloc/free allocation") \ 950128266Speter \ 951128266Speter product(bool, PrintOopAddress, false, \ 952128266Speter "Always print the location of the oop") \ 953128266Speter \ 954128266Speter notproduct(bool, VerifyCodeCache, false, \ 955128266Speter "Verify code cache on memory allocation/deallocation") \ 956128266Speter \ 957128266Speter develop(bool, ZapDeadCompiledLocals, false, \ 958128266Speter "Zap dead locals in compiler frames") \ 959128266Speter \ 960128266Speter notproduct(bool, ZapDeadLocalsOld, false, \ 961128266Speter "Zap dead locals (old version, zaps all frames when " \ 962128266Speter "entering the VM") \ 963128266Speter \ 964128266Speter notproduct(bool, CheckOopishValues, false, \ 965128266Speter "Warn if value contains oop (requires ZapDeadLocals)") \ 966128266Speter \ 967128266Speter develop(bool, UseMallocOnly, false, \ 968128266Speter "Use only malloc/free for allocation (no resource area/arena)") \ 969128266Speter \ 970128266Speter develop(bool, PrintMalloc, false, \ 971128266Speter "Print all malloc/free calls") \ 972128266Speter \ 973128266Speter develop(bool, PrintMallocStatistics, false, \ 974128266Speter "Print malloc/free statistics") \ 975128266Speter \ 976128266Speter develop(bool, ZapResourceArea, trueInDebug, \ 977128266Speter "Zap freed resource/arena space with 0xABABABAB") \ 978128266Speter \ 979128266Speter notproduct(bool, ZapVMHandleArea, trueInDebug, \ 980128266Speter "Zap freed VM handle space with 0xBCBCBCBC") \ 981128266Speter \ 982128266Speter develop(bool, ZapJNIHandleArea, trueInDebug, \ 983128266Speter "Zap freed JNI handle space with 0xFEFEFEFE") \ 984128266Speter \ 985128266Speter notproduct(bool, ZapStackSegments, trueInDebug, \ 986128266Speter "Zap allocated/freed stack segments with 0xFADFADED") \ 987128266Speter \ 988128266Speter develop(bool, ZapUnusedHeapArea, trueInDebug, \ 989128266Speter "Zap unused heap space with 0xBAADBABE") \ 990128266Speter \ 991128266Speter develop(bool, TraceZapUnusedHeapArea, false, \ 992128266Speter "Trace zapping of unused heap space") \ 993128266Speter \ 994128266Speter develop(bool, CheckZapUnusedHeapArea, false, \ 995128266Speter "Check zapping of unused heap space") \ 996128266Speter \ 997128266Speter develop(bool, ZapFillerObjects, trueInDebug, \ 998128266Speter "Zap filler objects with 0xDEAFBABE") \ 999128266Speter \ 1000128266Speter develop(bool, PrintVMMessages, true, \ 1001128266Speter "Print VM messages on console") \ 1002128266Speter \ 1003128266Speter product(bool, PrintGCApplicationConcurrentTime, false, \ 1004128266Speter "Print the time the application has been running") \ 1005128266Speter \ 1006128266Speter product(bool, PrintGCApplicationStoppedTime, false, \ 1007128266Speter "Print the time the application has been stopped") \ 1008128266Speter \ 1009128266Speter diagnostic(bool, VerboseVerification, false, \ 1010128266Speter "Display detailed verification details") \ 1011128266Speter \ 1012128266Speter notproduct(uintx, ErrorHandlerTest, 0, \ 1013128266Speter "If > 0, provokes an error after VM initialization; the value " \ 1014128266Speter "determines which error to provoke. See test_error_handler() " \ 1015128266Speter "in debug.cpp.") \ 1016128266Speter \ 1017128266Speter notproduct(uintx, TestCrashInErrorHandler, 0, \ 1018128266Speter "If > 0, provokes an error inside VM error handler (a secondary " \ 1019128266Speter "crash). see test_error_handler() in debug.cpp.") \ 1020128266Speter \ 1021128266Speter notproduct(bool, TestSafeFetchInErrorHandler, false, \ 1022128266Speter "If true, tests SafeFetch inside error handler.") \ 1023128266Speter \ 1024128266Speter develop(bool, Verbose, false, \ 1025128266Speter "Print additional debugging information from other modes") \ 1026128266Speter \ 1027128266Speter develop(bool, PrintMiscellaneous, false, \ 1028128266Speter "Print uncategorized debugging information (requires +Verbose)") \ 1029128266Speter \ 1030128266Speter develop(bool, WizardMode, false, \ 1031128266Speter "Print much more debugging information") \ 1032128266Speter \ 1033128266Speter product(bool, ShowMessageBoxOnError, false, \ 1034128266Speter "Keep process alive on VM fatal error") \ 1035128266Speter \ 1036128266Speter product(bool, CreateCoredumpOnCrash, true, \ 1037128266Speter "Create core/mini dump on VM fatal error") \ 1038128266Speter \ 1039128266Speter product(uintx, ErrorLogTimeout, 2 * 60, \ 1040128266Speter "Timeout, in seconds, to limit the time spent on writing an " \ 1041128266Speter "error log in case of a crash.") \ 1042128266Speter \ 1043128266Speter product_pd(bool, UseOSErrorReporting, \ 1044128266Speter "Let VM fatal error propagate to the OS (ie. WER on Windows)") \ 1045128266Speter \ 1046128266Speter product(bool, SuppressFatalErrorMessage, false, \ 1047128266Speter "Report NO fatal error message (avoid deadlock)") \ 1048128266Speter \ 1049128266Speter product(ccstrlist, OnError, "", \ 1050128266Speter "Run user-defined commands on fatal error; see VMError.cpp " \ 1051128266Speter "for examples") \ 1052128266Speter \ 1053128266Speter product(ccstrlist, OnOutOfMemoryError, "", \ 1054128266Speter "Run user-defined commands on first java.lang.OutOfMemoryError") \ 1055128266Speter \ 1056128266Speter manageable(bool, HeapDumpBeforeFullGC, false, \ 1057128266Speter "Dump heap to file before any major stop-the-world GC") \ 1058128266Speter \ 1059128266Speter manageable(bool, HeapDumpAfterFullGC, false, \ 1060128266Speter "Dump heap to file after any major stop-the-world GC") \ 1061128266Speter \ 1062128266Speter manageable(bool, HeapDumpOnOutOfMemoryError, false, \ 1063128266Speter "Dump heap to file when java.lang.OutOfMemoryError is thrown") \ 1064128266Speter \ 1065128266Speter manageable(ccstr, HeapDumpPath, NULL, \ 1066128266Speter "When HeapDumpOnOutOfMemoryError is on, the path (filename or " \ 1067128266Speter "directory) of the dump file (defaults to java_pid<pid>.hprof " \ 1068128266Speter "in the working directory)") \ 1069128266Speter \ 1070128266Speter develop(size_t, SegmentedHeapDumpThreshold, 2*G, \ 1071128266Speter "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) " \ 1072128266Speter "when the heap usage is larger than this") \ 1073128266Speter \ 1074128266Speter develop(size_t, HeapDumpSegmentSize, 1*G, \ 1075128266Speter "Approximate segment size when generating a segmented heap dump") \ 1076128266Speter \ 1077128266Speter develop(bool, BreakAtWarning, false, \ 1078128266Speter "Execute breakpoint upon encountering VM warning") \ 1079128266Speter \ 1080128266Speter develop(bool, TraceVMOperation, false, \ 1081128266Speter "Trace VM operations") \ 1082128266Speter \ 1083128266Speter develop(bool, UseFakeTimers, false, \ 1084128266Speter "Tell whether the VM should use system time or a fake timer") \ 1085128266Speter \ 1086128266Speter product(ccstr, NativeMemoryTracking, "off", \ 1087128266Speter "Native memory tracking options") \ 1088128266Speter \ 1089128266Speter diagnostic(bool, PrintNMTStatistics, false, \ 1090128266Speter "Print native memory tracking summary data if it is on") \ 1091128266Speter \ 1092128266Speter diagnostic(bool, LogCompilation, false, \ 1093128266Speter "Log compilation activity in detail to LogFile") \ 1094128266Speter \ 1095128266Speter product(bool, PrintCompilation, false, \ 1096128266Speter "Print compilations") \ 1097128266Speter \ 1098128266Speter diagnostic(bool, TraceNMethodInstalls, false, \ 1099128266Speter "Trace nmethod installation") \ 1100128266Speter \ 1101128266Speter diagnostic(intx, ScavengeRootsInCode, 2, \ 1102128266Speter "0: do not allow scavengable oops in the code cache; " \ 1103128266Speter "1: allow scavenging from the code cache; " \ 1104128266Speter "2: emit as many constants as the compiler can see") \ 1105128266Speter range(0, 2) \ 1106128266Speter \ 1107128266Speter product(bool, AlwaysRestoreFPU, false, \ 1108128266Speter "Restore the FPU control word after every JNI call (expensive)") \ 1109128266Speter \ 1110128266Speter product(bool, MemoryMapImage, false, \ 1111128266Speter "Memory map entire runtime image") \ 1112128266Speter \ 1113128266Speter diagnostic(bool, PrintCompilation2, false, \ 1114128266Speter "Print additional statistics per compilation") \ 1115128266Speter \ 1116128266Speter diagnostic(bool, PrintAdapterHandlers, false, \ 1117128266Speter "Print code generated for i2c/c2i adapters") \ 1118128266Speter \ 1119128266Speter diagnostic(bool, VerifyAdapterCalls, trueInDebug, \ 1120128266Speter "Verify that i2c/c2i adapters are called properly") \ 1121128266Speter \ 1122128266Speter develop(bool, VerifyAdapterSharing, false, \ 1123128266Speter "Verify that the code for shared adapters is the equivalent") \ 1124128266Speter \ 1125128266Speter diagnostic(bool, PrintAssembly, false, \ 1126128266Speter "Print assembly code (using external disassembler.so)") \ 1127128266Speter \ 1128128266Speter diagnostic(ccstr, PrintAssemblyOptions, NULL, \ 1129128266Speter "Print options string passed to disassembler.so") \ 1130128266Speter \ 1131128266Speter diagnostic(bool, PrintNMethods, false, \ 1132128266Speter "Print assembly code for nmethods when generated") \ 1133128266Speter \ 1134128266Speter diagnostic(bool, PrintNativeNMethods, false, \ 1135128266Speter "Print assembly code for native nmethods when generated") \ 1136128266Speter \ 1137128266Speter develop(bool, PrintDebugInfo, false, \ 1138128266Speter "Print debug information for all nmethods when generated") \ 1139128266Speter \ 1140128266Speter develop(bool, PrintRelocations, false, \ 1141128266Speter "Print relocation information for all nmethods when generated") \ 1142128266Speter \ 1143128266Speter develop(bool, PrintDependencies, false, \ 1144128266Speter "Print dependency information for all nmethods when generated") \ 1145128266Speter \ 1146128266Speter develop(bool, PrintExceptionHandlers, false, \ 1147128266Speter "Print exception handler tables for all nmethods when generated") \ 1148128266Speter \ 1149128266Speter develop(bool, StressCompiledExceptionHandlers, false, \ 1150128266Speter "Exercise compiled exception handlers") \ 1151128266Speter \ 1152128266Speter develop(bool, InterceptOSException, false, \ 1153128266Speter "Start debugger when an implicit OS (e.g. NULL) " \ 1154128266Speter "exception happens") \ 1155128266Speter \ 1156128266Speter product(bool, PrintCodeCache, false, \ 1157128266Speter "Print the code cache memory usage when exiting") \ 1158128266Speter \ 1159128266Speter develop(bool, PrintCodeCache2, false, \ 1160128266Speter "Print detailed usage information on the code cache when exiting")\ 1161128266Speter \ 1162128266Speter product(bool, PrintCodeCacheOnCompilation, false, \ 1163128266Speter "Print the code cache memory usage each time a method is " \ 1164128266Speter "compiled") \ 1165128266Speter \ 1166128266Speter diagnostic(bool, PrintStubCode, false, \ 1167128266Speter "Print generated stub code") \ 1168128266Speter \ 1169128266Speter product(bool, StackTraceInThrowable, true, \ 1170128266Speter "Collect backtrace in throwable when exception happens") \ 1171128266Speter \ 1172128266Speter product(bool, OmitStackTraceInFastThrow, true, \ 1173128266Speter "Omit backtraces for some 'hot' exceptions in optimized code") \ 1174128266Speter \ 1175128266Speter product(bool, ProfilerPrintByteCodeStatistics, false, \ 1176128266Speter "Print bytecode statistics when dumping profiler output") \ 1177128266Speter \ 1178128266Speter product(bool, ProfilerRecordPC, false, \ 1179128266Speter "Collect ticks for each 16 byte interval of compiled code") \ 1180128266Speter \ 1181128266Speter product(bool, ProfileVM, false, \ 1182128266Speter "Profile ticks that fall within VM (either in the VM Thread " \ 1183128266Speter "or VM code called through stubs)") \ 1184128266Speter \ 1185128266Speter product(bool, ProfileIntervals, false, \ 1186128266Speter "Print profiles for each interval (see ProfileIntervalsTicks)") \ 1187128266Speter \ 1188128266Speter notproduct(bool, ProfilerCheckIntervals, false, \ 1189128266Speter "Collect and print information on spacing of profiler ticks") \ 1190128266Speter \ 1191128266Speter product(bool, PrintWarnings, true, \ 1192128266Speter "Print JVM warnings to output stream") \ 1193128266Speter \ 1194128266Speter notproduct(uintx, WarnOnStalledSpinLock, 0, \ 1195128266Speter "Print warnings for stalled SpinLocks") \ 1196128266Speter \ 1197128266Speter product(bool, RegisterFinalizersAtInit, true, \ 1198128266Speter "Register finalizable objects at end of Object.<init> or " \ 1199128266Speter "after allocation") \ 1200128266Speter \ 1201128266Speter develop(bool, RegisterReferences, true, \ 1202128266Speter "Tell whether the VM should register soft/weak/final/phantom " \ 1203128266Speter "references") \ 1204128266Speter \ 1205128266Speter develop(bool, IgnoreRewrites, false, \ 1206128266Speter "Suppress rewrites of bytecodes in the oopmap generator. " \ 1207128266Speter "This is unsafe!") \ 1208128266Speter \ 1209128266Speter develop(bool, PrintCodeCacheExtension, false, \ 1210128266Speter "Print extension of code cache") \ 1211128266Speter \ 1212128266Speter develop(bool, UsePrivilegedStack, true, \ 1213128266Speter "Enable the security JVM functions") \ 1214128266Speter \ 1215128266Speter develop(bool, ProtectionDomainVerification, true, \ 1216128266Speter "Verify protection domain before resolution in system dictionary")\ 1217128266Speter \ 1218128266Speter product(bool, ClassUnloading, true, \ 1219128266Speter "Do unloading of classes") \ 1220128266Speter \ 1221128266Speter product(bool, ClassUnloadingWithConcurrentMark, true, \ 1222128266Speter "Do unloading of classes with a concurrent marking cycle") \ 1223128266Speter \ 1224128266Speter develop(bool, DisableStartThread, false, \ 1225128266Speter "Disable starting of additional Java threads " \ 1226128266Speter "(for debugging only)") \ 1227128266Speter \ 1228128266Speter develop(bool, MemProfiling, false, \ 1229128266Speter "Write memory usage profiling to log file") \ 1230128266Speter \ 1231128266Speter notproduct(bool, PrintSystemDictionaryAtExit, false, \ 1232128266Speter "Print the system dictionary at exit") \ 1233128266Speter \ 1234128266Speter experimental(intx, PredictedLoadedClassCount, 0, \ 1235128266Speter "Experimental: Tune loaded class cache starting size") \ 1236128266Speter \ 1237128266Speter diagnostic(bool, UnsyncloadClass, false, \ 1238128266Speter "Unstable: VM calls loadClass unsynchronized. Custom " \ 1239128266Speter "class loader must call VM synchronized for findClass " \ 1240128266Speter "and defineClass.") \ 1241128266Speter \ 1242128266Speter product(bool, AlwaysLockClassLoader, false, \ 1243128266Speter "Require the VM to acquire the class loader lock before calling " \ 1244128266Speter "loadClass() even for class loaders registering " \ 1245128266Speter "as parallel capable") \ 1246128266Speter \ 1247128266Speter product(bool, AllowParallelDefineClass, false, \ 1248128266Speter "Allow parallel defineClass requests for class loaders " \ 1249128266Speter "registering as parallel capable") \ 1250128266Speter \ 1251128266Speter product(bool, MustCallLoadClassInternal, false, \ 1252128266Speter "Call loadClassInternal() rather than loadClass()") \ 1253128266Speter \ 1254128266Speter product_pd(bool, DontYieldALot, \ 1255128266Speter "Throw away obvious excess yield calls") \ 1256128266Speter \ 1257128266Speter product_pd(bool, ConvertSleepToYield, \ 1258128266Speter "Convert sleep(0) to thread yield " \ 1259128266Speter "(may be off for Solaris to improve GUI)") \ 1260128266Speter \ 1261128266Speter product(bool, ConvertYieldToSleep, false, \ 1262128266Speter "Convert yield to a sleep of MinSleepInterval to simulate Win32 " \ 1263128266Speter "behavior") \ 1264128266Speter \ 1265128266Speter develop(bool, UseDetachedThreads, true, \ 1266128266Speter "Use detached threads that are recycled upon termination " \ 1267128266Speter "(for Solaris only)") \ 1268128266Speter \ 1269128266Speter product(bool, UseLWPSynchronization, true, \ 1270128266Speter "Use LWP-based instead of libthread-based synchronization " \ 1271128266Speter "(SPARC only)") \ 1272128266Speter \ 1273128266Speter experimental(ccstr, SyncKnobs, NULL, \ 1274109655Speter "(Unstable) Various monitor synchronization tunables") \ 1275109655Speter \ 1276109655Speter experimental(intx, EmitSync, 0, \ 1277109655Speter "(Unsafe, Unstable) " \ 1278109655Speter "Control emission of inline sync fast-path code") \ 1279109655Speter \ 1280109655Speter product(intx, MonitorBound, 0, "Bound Monitor population") \ 1281109655Speter \ 1282109655Speter product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \ 1283109655Speter \ 1284109655Speter experimental(intx, SyncFlags, 0, "(Unsafe, Unstable) " \ 1285109655Speter "Experimental Sync flags") \ 1286128266Speter \ 1287128266Speter experimental(intx, SyncVerbose, 0, "(Unstable)") \ 1288128266Speter \ 1289128266Speter product(bool, InlineNotify, true, "intrinsify subset of notify" ) \ 1290128266Speter \ 1291128266Speter experimental(intx, ClearFPUAtPark, 0, "(Unsafe, Unstable)") \ 1292128266Speter \ 1293109655Speter experimental(intx, hashCode, 5, \ 1294109655Speter "(Unstable) select hashCode generation algorithm") \ 1295109655Speter \ 1296109655Speter experimental(intx, WorkAroundNPTLTimedWaitHang, 0, \ 1297109655Speter "(Unstable, Linux-specific) " \ 1298109655Speter "avoid NPTL-FUTEX hang pthread_cond_timedwait") \ 1299109655Speter \ 1300109655Speter product(bool, FilterSpuriousWakeups, true, \ 1301109655Speter "When true prevents OS-level spurious, or premature, wakeups " \ 1302109655Speter "from Object.wait (Ignored for Windows)") \ 1303109655Speter \ 1304109655Speter experimental(intx, NativeMonitorTimeout, -1, "(Unstable)") \ 1305109655Speter \ 1306109655Speter experimental(intx, NativeMonitorFlags, 0, "(Unstable)") \ 1307109655Speter \ 1308109655Speter experimental(intx, NativeMonitorSpinLimit, 20, "(Unstable)") \ 1309109655Speter \ 1310109655Speter develop(bool, UsePthreads, false, \ 1311109655Speter "Use pthread-based instead of libthread-based synchronization " \ 1312109655Speter "(SPARC only)") \ 1313109655Speter \ 1314109655Speter product(bool, ReduceSignalUsage, false, \ 1315109655Speter "Reduce the use of OS signals in Java and/or the VM") \ 1316109655Speter \ 1317109655Speter develop_pd(bool, ShareVtableStubs, \ 1318109655Speter "Share vtable stubs (smaller code but worse branch prediction") \ 1319109655Speter \ 1320109655Speter develop(bool, LoadLineNumberTables, true, \ 1321109655Speter "Tell whether the class file parser loads line number tables") \ 1322109655Speter \ 1323109655Speter develop(bool, LoadLocalVariableTables, true, \ 1324109655Speter "Tell whether the class file parser loads local variable tables") \ 1325109655Speter \ 1326109655Speter develop(bool, LoadLocalVariableTypeTables, true, \ 1327109655Speter "Tell whether the class file parser loads local variable type" \ 1328109655Speter "tables") \ 1329109655Speter \ 1330109655Speter product(bool, AllowUserSignalHandlers, false, \ 1331109655Speter "Do not complain if the application installs signal handlers " \ 1332109655Speter "(Solaris & Linux only)") \ 1333109655Speter \ 1334109655Speter product(bool, UseSignalChaining, true, \ 1335109655Speter "Use signal-chaining to invoke signal handlers installed " \ 1336109655Speter "by the application (Solaris & Linux only)") \ 1337109655Speter \ 1338109655Speter product(bool, UseAltSigs, false, \ 1339109655Speter "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM " \ 1340109655Speter "internal signals (Solaris only)") \ 1341109655Speter \ 1342109655Speter product(bool, AllowJNIEnvProxy, false, \ 1343109655Speter "Allow JNIEnv proxies for jdbx") \ 1344109655Speter \ 1345109655Speter product(bool, JNIDetachReleasesMonitors, true, \ 1346109655Speter "JNI DetachCurrentThread releases monitors owned by thread") \ 1347109655Speter \ 1348109655Speter product(bool, RestoreMXCSROnJNICalls, false, \ 1349107484Speter "Restore MXCSR when returning from JNI calls") \ 1350107484Speter \ 1351107484Speter product(bool, CheckJNICalls, false, \ 1352107484Speter "Verify all arguments to JNI calls") \ 1353107484Speter \ 1354107484Speter product(bool, CheckEndorsedAndExtDirs, false, \ 1355107484Speter "Verify the endorsed and extension directories are not used") \ 1356107484Speter \ 1357107484Speter product(bool, UseFastJNIAccessors, true, \ 1358107484Speter "Use optimized versions of Get<Primitive>Field") \ 1359107484Speter \ 1360107484Speter product(intx, MaxJNILocalCapacity, 65536, \ 1361107484Speter "Maximum allowable local JNI handle capacity to " \ 1362107484Speter "EnsureLocalCapacity() and PushLocalFrame(), " \ 1363107484Speter "where <= 0 is unlimited, default: 65536") \ 1364107484Speter \ 1365107484Speter product(bool, EagerXrunInit, false, \ 1366107484Speter "Eagerly initialize -Xrun libraries; allows startup profiling, " \ 1367107484Speter "but not all -Xrun libraries may support the state of the VM " \ 1368107484Speter "at this time") \ 1369107484Speter \ 1370107484Speter product(bool, PreserveAllAnnotations, false, \ 1371107484Speter "Preserve RuntimeInvisibleAnnotations as well " \ 1372107484Speter "as RuntimeVisibleAnnotations") \ 1373107484Speter \ 1374107484Speter develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \ 1375107484Speter "Number of OutOfMemoryErrors preallocated with backtrace") \ 1376107484Speter \ 1377107484Speter product(bool, UseXMMForArrayCopy, false, \ 1378107484Speter "Use SSE2 MOVQ instruction for Arraycopy") \ 1379107484Speter \ 1380107484Speter product(intx, FieldsAllocationStyle, 1, \ 1381107484Speter "0 - type based with oops first, " \ 1382107484Speter "1 - with oops last, " \ 1383107484Speter "2 - oops in super and sub classes are together") \ 1384107484Speter range(0, 2) \ 1385107484Speter \ 1386107484Speter product(bool, CompactFields, true, \ 1387107484Speter "Allocate nonstatic fields in gaps between previous fields") \ 1388107484Speter \ 1389107484Speter notproduct(bool, PrintFieldLayout, false, \ 1390107484Speter "Print field layout for each class") \ 1391107484Speter \ 1392107484Speter /* Need to limit the extent of the padding to reasonable size. */\ 1393107484Speter /* 8K is well beyond the reasonable HW cache line size, even with */\ 1394107484Speter /* aggressive prefetching, while still leaving the room for segregating */\ 1395107484Speter /* among the distinct pages. */\ 1396107484Speter product(intx, ContendedPaddingWidth, 128, \ 1397107484Speter "How many bytes to pad the fields/classes marked @Contended with")\ 1398107484Speter range(0, 8192) \ 1399107484Speter constraint(ContendedPaddingWidthConstraintFunc) \ 1400107484Speter \ 1401107484Speter product(bool, EnableContended, true, \ 1402107484Speter "Enable @Contended annotation support") \ 1403107484Speter \ 1404107484Speter product(bool, RestrictContended, true, \ 1405107484Speter "Restrict @Contended to trusted classes") \ 1406107484Speter \ 1407107484Speter product(bool, UseBiasedLocking, true, \ 1408107484Speter "Enable biased locking in JVM") \ 1409107484Speter \ 1410107484Speter product(intx, BiasedLockingStartupDelay, 4000, \ 1411107484Speter "Number of milliseconds to wait before enabling biased locking") \ 1412107484Speter \ 1413107484Speter diagnostic(bool, PrintBiasedLockingStatistics, false, \ 1414107484Speter "Print statistics of biased locking in JVM") \ 1415107484Speter \ 1416107484Speter product(intx, BiasedLockingBulkRebiasThreshold, 20, \ 1417107484Speter "Threshold of number of revocations per type to try to " \ 1418107484Speter "rebias all objects in the heap of that type") \ 1419107484Speter \ 1420107484Speter product(intx, BiasedLockingBulkRevokeThreshold, 40, \ 1421107484Speter "Threshold of number of revocations per type to permanently " \ 1422107484Speter "revoke biases of all objects in the heap of that type") \ 1423107484Speter \ 1424107484Speter product(intx, BiasedLockingDecayTime, 25000, \ 1425107484Speter "Decay time (in milliseconds) to re-enable bulk rebiasing of a " \ 1426107484Speter "type after previous bulk rebias") \ 1427107484Speter \ 1428107484Speter /* tracing */ \ 1429107484Speter \ 1430107484Speter notproduct(bool, TraceRuntimeCalls, false, \ 1431107484Speter "Trace run-time calls") \ 1432107484Speter \ 1433107484Speter develop(bool, TraceJNICalls, false, \ 1434107484Speter "Trace JNI calls") \ 1435107484Speter \ 1436107484Speter develop(bool, StressRewriter, false, \ 1437107484Speter "Stress linktime bytecode rewriting") \ 1438107484Speter \ 1439107484Speter notproduct(bool, TraceJVMCalls, false, \ 1440107484Speter "Trace JVM calls") \ 1441107484Speter \ 1442107484Speter product(ccstr, TraceJVMTI, NULL, \ 1443107484Speter "Trace flags for JVMTI functions and events") \ 1444107484Speter \ 1445107484Speter /* This option can change an EMCP method into an obsolete method. */ \ 1446107484Speter /* This can affect tests that except specific methods to be EMCP. */ \ 1447107484Speter /* This option should be used with caution. */ \ 1448107484Speter product(bool, StressLdcRewrite, false, \ 1449107484Speter "Force ldc -> ldc_w rewrite during RedefineClasses") \ 1450107484Speter \ 1451107484Speter product(intx, TraceRedefineClasses, 0, \ 1452107484Speter "Trace level for JVMTI RedefineClasses") \ 1453107484Speter \ 1454107484Speter /* change to false by default sometime after Mustang */ \ 1455107484Speter product(bool, VerifyMergedCPBytecodes, true, \ 1456107484Speter "Verify bytecodes after RedefineClasses constant pool merging") \ 1457107484Speter \ 1458107484Speter develop(bool, TraceJNIHandleAllocation, false, \ 1459107484Speter "Trace allocation/deallocation of JNI handle blocks") \ 1460107484Speter \ 1461107484Speter develop(bool, TraceBytecodes, false, \ 1462107484Speter "Trace bytecode execution") \ 1463107484Speter \ 1464107484Speter develop(bool, TraceClassInitialization, false, \ 1465107484Speter "Trace class initialization") \ 1466107484Speter \ 1467107484Speter product(bool, TraceExceptions, false, \ 1468107484Speter "Trace exceptions") \ 1469107484Speter \ 1470107484Speter develop(bool, TraceICs, false, \ 1471107484Speter "Trace inline cache changes") \ 1472107484Speter \ 1473107484Speter notproduct(bool, TraceInvocationCounterOverflow, false, \ 1474107484Speter "Trace method invocation counter overflow") \ 1475107484Speter \ 1476107484Speter develop(bool, TraceInlineCacheClearing, false, \ 1477107484Speter "Trace clearing of inline caches in nmethods") \ 1478107484Speter \ 1479107484Speter develop(bool, TraceDependencies, false, \ 1480107484Speter "Trace dependencies") \ 1481107484Speter \ 1482107484Speter develop(bool, VerifyDependencies, trueInDebug, \ 1483107484Speter "Exercise and verify the compilation dependency mechanism") \ 1484107484Speter \ 1485107484Speter develop(bool, TraceNewOopMapGeneration, false, \ 1486107484Speter "Trace OopMapGeneration") \ 1487107484Speter \ 1488107484Speter develop(bool, TraceNewOopMapGenerationDetailed, false, \ 1489107484Speter "Trace OopMapGeneration: print detailed cell states") \ 1490107484Speter \ 1491107484Speter develop(bool, TimeOopMap, false, \ 1492107484Speter "Time calls to GenerateOopMap::compute_map() in sum") \ 1493107484Speter \ 1494107484Speter develop(bool, TimeOopMap2, false, \ 1495107484Speter "Time calls to GenerateOopMap::compute_map() individually") \ 1496107484Speter \ 1497107484Speter develop(bool, TraceMonitorMismatch, false, \ 1498107484Speter "Trace monitor matching failures during OopMapGeneration") \ 1499107484Speter \ 1500107484Speter develop(bool, TraceOopMapRewrites, false, \ 1501107484Speter "Trace rewriting of method oops during oop map generation") \ 1502107484Speter \ 1503107484Speter develop(bool, TraceSafepoint, false, \ 1504107484Speter "Trace safepoint operations") \ 1505107484Speter \ 1506107484Speter develop(bool, TraceICBuffer, false, \ 1507107484Speter "Trace usage of IC buffer") \ 1508107484Speter \ 1509107484Speter develop(bool, TraceCompiledIC, false, \ 1510107484Speter "Trace changes of compiled IC") \ 1511107484Speter \ 1512107484Speter notproduct(bool, TraceZapDeadLocals, false, \ 1513107484Speter "Trace zapping dead locals") \ 1514107484Speter \ 1515107484Speter develop(bool, TraceStartupTime, false, \ 1516107484Speter "Trace setup time") \ 1517107484Speter \ 1518107484Speter develop(bool, TraceProtectionDomainVerification, false, \ 1519107484Speter "Trace protection domain verification") \ 1520107484Speter \ 1521107484Speter develop(bool, TraceClearedExceptions, false, \ 1522107484Speter "Print when an exception is forcibly cleared") \ 1523107484Speter \ 1524107484Speter product(bool, TraceClassResolution, false, \ 1525107484Speter "Trace all constant pool resolutions (for debugging)") \ 1526107484Speter \ 1527107484Speter product(bool, TraceBiasedLocking, false, \ 1528107484Speter "Trace biased locking in JVM") \ 1529107484Speter \ 1530107484Speter product(bool, TraceMonitorInflation, false, \ 1531107484Speter "Trace monitor inflation in JVM") \ 1532107484Speter \ 1533107484Speter /* gc */ \ 1534107484Speter \ 1535107484Speter product(bool, UseSerialGC, false, \ 1536107484Speter "Use the Serial garbage collector") \ 1537107484Speter \ 1538107484Speter product(bool, UseG1GC, false, \ 1539107484Speter "Use the Garbage-First garbage collector") \ 1540107484Speter \ 1541107484Speter product(bool, UseParallelGC, false, \ 1542107484Speter "Use the Parallel Scavenge garbage collector") \ 1543107484Speter \ 1544107484Speter product(bool, UseParallelOldGC, false, \ 1545107484Speter "Use the Parallel Old garbage collector") \ 1546107484Speter \ 1547107484Speter product(uintx, HeapMaximumCompactionInterval, 20, \ 1548107484Speter "How often should we maximally compact the heap (not allowing " \ 1549107484Speter "any dead space)") \ 1550107484Speter \ 1551107484Speter product(uintx, HeapFirstMaximumCompactionCount, 3, \ 1552107484Speter "The collection count for the first maximum compaction") \ 1553107484Speter \ 1554107484Speter product(bool, UseMaximumCompactionOnSystemGC, true, \ 1555107484Speter "Use maximum compaction in the Parallel Old garbage collector " \ 1556107484Speter "for a system GC") \ 1557107484Speter \ 1558107484Speter product(uintx, ParallelOldDeadWoodLimiterMean, 50, \ 1559107484Speter "The mean used by the parallel compact dead wood " \ 1560107484Speter "limiter (a number between 0-100)") \ 1561107484Speter range(0, 100) \ 1562107484Speter \ 1563107484Speter product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \ 1564107484Speter "The standard deviation used by the parallel compact dead wood " \ 1565107484Speter "limiter (a number between 0-100)") \ 1566107484Speter range(0, 100) \ 1567107484Speter \ 1568107484Speter product(uint, ParallelGCThreads, 0, \ 1569107484Speter "Number of parallel threads parallel gc will use") \ 1570107484Speter \ 1571107484Speter product(bool, UseDynamicNumberOfGCThreads, false, \ 1572107484Speter "Dynamically choose the number of parallel threads " \ 1573107484Speter "parallel gc will use") \ 1574107484Speter \ 1575107484Speter diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \ 1576107484Speter "Force dynamic selection of the number of " \ 1577107484Speter "parallel threads parallel gc will use to aid debugging") \ 1578107484Speter \ 1579107484Speter product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \ 1580107484Speter "Size of heap (bytes) per GC thread used in calculating the " \ 1581107484Speter "number of GC threads") \ 1582107484Speter range((uintx)os::vm_page_size(), max_uintx) \ 1583107484Speter \ 1584107484Speter product(bool, TraceDynamicGCThreads, false, \ 1585107484Speter "Trace the dynamic GC thread usage") \ 1586107484Speter \ 1587107484Speter develop(bool, ParallelOldGCSplitALot, false, \ 1588107484Speter "Provoke splitting (copying data from a young gen space to " \ 1589107484Speter "multiple destination spaces)") \ 1590107484Speter \ 1591107484Speter develop(uintx, ParallelOldGCSplitInterval, 3, \ 1592107484Speter "How often to provoke splitting a young gen space") \ 1593107484Speter range(0, max_uintx) \ 1594107484Speter \ 1595107484Speter product(uint, ConcGCThreads, 0, \ 1596107484Speter "Number of threads concurrent gc will use") \ 1597107484Speter \ 1598107484Speter product(size_t, YoungPLABSize, 4096, \ 1599107484Speter "Size of young gen promotion LAB's (in HeapWords)") \ 1600107484Speter \ 1601107484Speter product(size_t, OldPLABSize, 1024, \ 1602107484Speter "Size of old gen promotion LAB's (in HeapWords), or Number \ 1603107484Speter of blocks to attempt to claim when refilling CMS LAB's") \ 1604107484Speter \ 1605107484Speter product(uintx, GCTaskTimeStampEntries, 200, \ 1606107484Speter "Number of time stamp entries per gc worker thread") \ 1607107484Speter range(1, max_uintx) \ 1608107484Speter \ 1609107484Speter product(bool, AlwaysTenure, false, \ 1610107484Speter "Always tenure objects in eden (ParallelGC only)") \ 1611107484Speter \ 1612107484Speter product(bool, NeverTenure, false, \ 1613107484Speter "Never tenure objects in eden, may tenure on overflow " \ 1614107484Speter "(ParallelGC only)") \ 1615107484Speter \ 1616107484Speter product(bool, ScavengeBeforeFullGC, true, \ 1617107484Speter "Scavenge youngest generation before each full GC.") \ 1618107484Speter \ 1619107484Speter develop(bool, ScavengeWithObjectsInToSpace, false, \ 1620107484Speter "Allow scavenges to occur when to-space contains objects") \ 1621107484Speter \ 1622107484Speter product(bool, UseConcMarkSweepGC, false, \ 1623102840Speter "Use Concurrent Mark-Sweep GC in the old generation") \ 1624102840Speter \ 1625102840Speter product(bool, ExplicitGCInvokesConcurrent, false, \ 1626102840Speter "A System.gc() request invokes a concurrent collection; " \ 1627102840Speter "(effective only when using concurrent collectors)") \ 1628102840Speter \ 1629102840Speter product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \ 1630102840Speter "A System.gc() request invokes a concurrent collection and " \ 1631102840Speter "also unloads classes during such a concurrent gc cycle " \ 1632102840Speter "(effective only when UseConcMarkSweepGC)") \ 1633102840Speter \ 1634102840Speter product(bool, GCLockerInvokesConcurrent, false, \ 1635102840Speter "The exit of a JNI critical section necessitating a scavenge, " \ 1636102840Speter "also kicks off a background concurrent collection") \ 1637102840Speter \ 1638102840Speter product(uintx, GCLockerEdenExpansionPercent, 5, \ 1639102840Speter "How much the GC can expand the eden by while the GC locker " \ 1640102840Speter "is active (as a percentage)") \ 1641102840Speter range(0, 100) \ 1642102840Speter \ 1643102840Speter diagnostic(uintx, GCLockerRetryAllocationCount, 2, \ 1644102840Speter "Number of times to retry allocations when " \ 1645102840Speter "blocked by the GC locker") \ 1646102840Speter \ 1647102840Speter develop(bool, UseCMSAdaptiveFreeLists, true, \ 1648102840Speter "Use adaptive free lists in the CMS generation") \ 1649102840Speter \ 1650102840Speter develop(bool, UseAsyncConcMarkSweepGC, true, \ 1651102840Speter "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\ 1652102840Speter \ 1653102840Speter product(bool, UseCMSBestFit, true, \ 1654102840Speter "Use CMS best fit allocation strategy") \ 1655102840Speter \ 1656102840Speter product(bool, UseParNewGC, false, \ 1657102840Speter "Use parallel threads in the new generation") \ 1658102840Speter \ 1659102840Speter product(bool, PrintTaskqueue, false, \ 1660102840Speter "Print taskqueue statistics for parallel collectors") \ 1661102840Speter \ 1662102840Speter product(bool, PrintTerminationStats, false, \ 1663102840Speter "Print termination statistics for parallel collectors") \ 1664102840Speter \ 1665102840Speter product(uintx, ParallelGCBufferWastePct, 10, \ 1666102840Speter "Wasted fraction of parallel allocation buffer") \ 1667102840Speter range(0, 100) \ 1668102840Speter \ 1669102840Speter product(uintx, TargetPLABWastePct, 10, \ 1670102840Speter "Target wasted space in last buffer as percent of overall " \ 1671102840Speter "allocation") \ 1672102840Speter range(1, 100) \ 1673102840Speter \ 1674102840Speter product(uintx, PLABWeight, 75, \ 1675102840Speter "Percentage (0-100) used to weight the current sample when " \ 1676102840Speter "computing exponentially decaying average for ResizePLAB") \ 1677102840Speter range(0, 100) \ 1678102840Speter \ 1679102840Speter product(bool, ResizePLAB, true, \ 1680102840Speter "Dynamically resize (survivor space) promotion LAB's") \ 1681102840Speter \ 1682102840Speter product(bool, PrintPLAB, false, \ 1683102840Speter "Print (survivor space) promotion LAB's sizing decisions") \ 1684102840Speter \ 1685102840Speter product(intx, ParGCArrayScanChunk, 50, \ 1686102840Speter "Scan a subset of object array and push remainder, if array is " \ 1687102840Speter "bigger than this") \ 1688102840Speter range(1, max_intx) \ 1689102840Speter \ 1690102840Speter product(bool, ParGCUseLocalOverflow, false, \ 1691102840Speter "Instead of a global overflow list, use local overflow stacks") \ 1692102840Speter \ 1693102840Speter product(bool, ParGCTrimOverflow, true, \ 1694102840Speter "Eagerly trim the local overflow lists " \ 1695102840Speter "(when ParGCUseLocalOverflow)") \ 1696102840Speter \ 1697102840Speter notproduct(bool, ParGCWorkQueueOverflowALot, false, \ 1698102840Speter "Simulate work queue overflow in ParNew") \ 1699102840Speter \ 1700102840Speter notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \ 1701102840Speter "An `interval' counter that determines how frequently " \ 1702102840Speter "we simulate overflow; a smaller number increases frequency") \ 1703102840Speter \ 1704102840Speter product(uintx, ParGCDesiredObjsFromOverflowList, 20, \ 1705102840Speter "The desired number of objects to claim from the overflow list") \ 1706102840Speter \ 1707102840Speter diagnostic(uintx, ParGCStridesPerThread, 2, \ 1708102840Speter "The number of strides per worker thread that we divide up the " \ 1709102840Speter "card table scanning work into") \ 1710102840Speter range(1, max_uintx) \ 1711102840Speter \ 1712102840Speter diagnostic(intx, ParGCCardsPerStrideChunk, 256, \ 1713102840Speter "The number of cards in each chunk of the parallel chunks used " \ 1714102840Speter "during card table scanning") \ 1715102840Speter range(1, max_intx) \ 1716102840Speter \ 1717102840Speter product(uintx, OldPLABWeight, 50, \ 1718102840Speter "Percentage (0-100) used to weight the current sample when " \ 1719102840Speter "computing exponentially decaying average for resizing " \ 1720102840Speter "OldPLABSize") \ 1721102840Speter range(0, 100) \ 1722102840Speter \ 1723102840Speter product(bool, ResizeOldPLAB, true, \ 1724102840Speter "Dynamically resize (old gen) promotion LAB's") \ 1725102840Speter \ 1726102840Speter product(bool, PrintOldPLAB, false, \ 1727102840Speter "Print (old gen) promotion LAB's sizing decisions") \ 1728102840Speter \ 1729102840Speter product(size_t, CMSOldPLABMax, 1024, \ 1730102840Speter "Maximum size of CMS gen promotion LAB caches per worker " \ 1731102840Speter "per block size") \ 1732102840Speter range(1, max_uintx) \ 1733102840Speter \ 1734102840Speter product(size_t, CMSOldPLABMin, 16, \ 1735102840Speter "Minimum size of CMS gen promotion LAB caches per worker " \ 1736102840Speter "per block size") \ 1737102840Speter range(1, max_uintx) \ 1738102840Speter constraint(CMSOldPLABMinConstraintFunc) \ 1739102840Speter \ 1740102840Speter product(uintx, CMSOldPLABNumRefills, 4, \ 1741102840Speter "Nominal number of refills of CMS gen promotion LAB cache " \ 1742102840Speter "per worker per block size") \ 1743102840Speter range(1, max_uintx) \ 1744102840Speter \ 1745102840Speter product(bool, CMSOldPLABResizeQuicker, false, \ 1746102840Speter "React on-the-fly during a scavenge to a sudden " \ 1747102840Speter "change in block demand rate") \ 1748102840Speter \ 1749102840Speter product(uintx, CMSOldPLABToleranceFactor, 4, \ 1750102840Speter "The tolerance of the phase-change detector for on-the-fly " \ 1751102840Speter "PLAB resizing during a scavenge") \ 1752102840Speter range(1, max_uintx) \ 1753102840Speter \ 1754102840Speter product(uintx, CMSOldPLABReactivityFactor, 2, \ 1755102840Speter "The gain in the feedback loop for on-the-fly PLAB resizing " \ 1756102840Speter "during a scavenge") \ 1757102840Speter \ 1758102840Speter product(bool, AlwaysPreTouch, false, \ 1759102840Speter "Force all freshly committed pages to be pre-touched") \ 1760102840Speter \ 1761102840Speter product_pd(size_t, CMSYoungGenPerWorker, \ 1762102840Speter "The maximum size of young gen chosen by default per GC worker " \ 1763102840Speter "thread available") \ 1764102840Speter range(1, max_uintx) \ 1765102840Speter \ 1766102840Speter product(uintx, CMSIncrementalSafetyFactor, 10, \ 1767102840Speter "Percentage (0-100) used to add conservatism when computing the " \ 1768102840Speter "duty cycle") \ 1769102840Speter range(0, 100) \ 1770102840Speter \ 1771102840Speter product(uintx, CMSExpAvgFactor, 50, \ 1772102840Speter "Percentage (0-100) used to weight the current sample when " \ 1773102840Speter "computing exponential averages for CMS statistics") \ 1774102840Speter range(0, 100) \ 1775102840Speter \ 1776102840Speter product(uintx, CMS_FLSWeight, 75, \ 1777102840Speter "Percentage (0-100) used to weight the current sample when " \ 1778102840Speter "computing exponentially decaying averages for CMS FLS " \ 1779102840Speter "statistics") \ 1780102840Speter range(0, 100) \ 1781102840Speter \ 1782102840Speter product(uintx, CMS_FLSPadding, 1, \ 1783102840Speter "The multiple of deviation from mean to use for buffering " \ 1784102840Speter "against volatility in free list demand") \ 1785102840Speter \ 1786102840Speter product(uintx, FLSCoalescePolicy, 2, \ 1787102840Speter "CMS: aggressiveness level for coalescing, increasing " \ 1788102840Speter "from 0 to 4") \ 1789102840Speter range(0, 4) \ 1790102840Speter \ 1791102840Speter product(bool, FLSAlwaysCoalesceLarge, false, \ 1792102840Speter "CMS: larger free blocks are always available for coalescing") \ 1793102840Speter \ 1794102840Speter product(double, FLSLargestBlockCoalesceProximity, 0.99, \ 1795102840Speter "CMS: the smaller the percentage the greater the coalescing " \ 1796102840Speter "force") \ 1797102840Speter \ 1798102840Speter product(double, CMSSmallCoalSurplusPercent, 1.05, \ 1799102840Speter "CMS: the factor by which to inflate estimated demand of small " \ 1800102840Speter "block sizes to prevent coalescing with an adjoining block") \ 1801102840Speter \ 1802102840Speter product(double, CMSLargeCoalSurplusPercent, 0.95, \ 1803102840Speter "CMS: the factor by which to inflate estimated demand of large " \ 1804102840Speter "block sizes to prevent coalescing with an adjoining block") \ 1805102840Speter \ 1806102840Speter product(double, CMSSmallSplitSurplusPercent, 1.10, \ 1807102840Speter "CMS: the factor by which to inflate estimated demand of small " \ 1808102840Speter "block sizes to prevent splitting to supply demand for smaller " \ 1809102840Speter "blocks") \ 1810102840Speter \ 1811102840Speter product(double, CMSLargeSplitSurplusPercent, 1.00, \ 1812102840Speter "CMS: the factor by which to inflate estimated demand of large " \ 1813102840Speter "block sizes to prevent splitting to supply demand for smaller " \ 1814102840Speter "blocks") \ 1815102840Speter \ 1816102840Speter product(bool, CMSExtrapolateSweep, false, \ 1817102840Speter "CMS: cushion for block demand during sweep") \ 1818102840Speter \ 1819102840Speter product(uintx, CMS_SweepWeight, 75, \ 1820102840Speter "Percentage (0-100) used to weight the current sample when " \ 1821102840Speter "computing exponentially decaying average for inter-sweep " \ 1822102840Speter "duration") \ 1823102840Speter range(0, 100) \ 1824102840Speter \ 1825102840Speter product(uintx, CMS_SweepPadding, 1, \ 1826102840Speter "The multiple of deviation from mean to use for buffering " \ 1827102840Speter "against volatility in inter-sweep duration") \ 1828102840Speter \ 1829102840Speter product(uintx, CMS_SweepTimerThresholdMillis, 10, \ 1830102840Speter "Skip block flux-rate sampling for an epoch unless inter-sweep " \ 1831102840Speter "duration exceeds this threshold in milliseconds") \ 1832102840Speter \ 1833102840Speter product(bool, CMSClassUnloadingEnabled, true, \ 1834102840Speter "Whether class unloading enabled when using CMS GC") \ 1835102840Speter \ 1836102840Speter product(uintx, CMSClassUnloadingMaxInterval, 0, \ 1837102840Speter "When CMS class unloading is enabled, the maximum CMS cycle " \ 1838102840Speter "count for which classes may not be unloaded") \ 1839102840Speter \ 1840102840Speter develop(intx, CMSDictionaryChoice, 0, \ 1841102840Speter "Use BinaryTreeDictionary as default in the CMS generation") \ 1842102840Speter \ 1843102840Speter product(uintx, CMSIndexedFreeListReplenish, 4, \ 1844102840Speter "Replenish an indexed free list with this number of chunks") \ 1845102840Speter \ 1846102840Speter product(bool, CMSReplenishIntermediate, true, \ 1847102840Speter "Replenish all intermediate free-list caches") \ 1848102840Speter \ 1849102840Speter product(bool, CMSSplitIndexedFreeListBlocks, true, \ 1850102840Speter "When satisfying batched demand, split blocks from the " \ 1851102840Speter "IndexedFreeList whose size is a multiple of requested size") \ 1852102840Speter \ 1853102840Speter product(bool, CMSLoopWarn, false, \ 1854102840Speter "Warn in case of excessive CMS looping") \ 1855102840Speter \ 1856102840Speter develop(bool, CMSOverflowEarlyRestoration, false, \ 1857102840Speter "Restore preserved marks early") \ 1858102840Speter \ 1859102840Speter product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \ 1860102840Speter "Size of marking stack") \ 1861102840Speter \ 1862102840Speter product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \ 1863102840Speter "Maximum size of marking stack") \ 1864102840Speter range(1, (max_jint - 1)) \ 1865102840Speter \ 1866102840Speter notproduct(bool, CMSMarkStackOverflowALot, false, \ 1867102840Speter "Simulate frequent marking stack / work queue overflow") \ 1868102840Speter \ 1869102840Speter notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \ 1870102840Speter "An \"interval\" counter that determines how frequently " \ 1871102840Speter "to simulate overflow; a smaller number increases frequency") \ 1872102840Speter \ 1873102840Speter product(uintx, CMSMaxAbortablePrecleanLoops, 0, \ 1874102840Speter "Maximum number of abortable preclean iterations, if > 0") \ 1875102840Speter \ 1876102840Speter product(intx, CMSMaxAbortablePrecleanTime, 5000, \ 1877102840Speter "Maximum time in abortable preclean (in milliseconds)") \ 1878102840Speter \ 1879102840Speter product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \ 1880102840Speter "Nominal minimum work per abortable preclean iteration") \ 1881102840Speter \ 1882102840Speter manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \ 1883102840Speter "Time that we sleep between iterations when not given " \ 1884102840Speter "enough work per iteration") \ 1885102840Speter \ 1886102840Speter product(size_t, CMSRescanMultiple, 32, \ 1887102840Speter "Size (in cards) of CMS parallel rescan task") \ 1888102840Speter range(1, max_uintx) \ 1889102840Speter \ 1890102840Speter product(size_t, CMSConcMarkMultiple, 32, \ 1891102840Speter "Size (in cards) of CMS concurrent MT marking task") \ 1892102840Speter range(1, max_uintx) \ 1893102840Speter \ 1894102840Speter product(bool, CMSAbortSemantics, false, \ 1895102840Speter "Whether abort-on-overflow semantics is implemented") \ 1896102840Speter \ 1897102840Speter product(bool, CMSParallelInitialMarkEnabled, true, \ 1898102840Speter "Use the parallel initial mark.") \ 1899102840Speter \ 1900102840Speter product(bool, CMSParallelRemarkEnabled, true, \ 1901102840Speter "Whether parallel remark enabled (only if ParNewGC)") \ 1902102840Speter \ 1903102840Speter product(bool, CMSParallelSurvivorRemarkEnabled, true, \ 1904102840Speter "Whether parallel remark of survivor space " \ 1905102840Speter "enabled (effective only if CMSParallelRemarkEnabled)") \ 1906102840Speter \ 1907102840Speter product(bool, CMSPLABRecordAlways, true, \ 1908102840Speter "Always record survivor space PLAB boundaries (effective only " \ 1909102840Speter "if CMSParallelSurvivorRemarkEnabled)") \ 1910102840Speter \ 1911102840Speter product(bool, CMSEdenChunksRecordAlways, true, \ 1912102840Speter "Always record eden chunks used for the parallel initial mark " \ 1913102840Speter "or remark of eden") \ 1914102840Speter \ 1915102840Speter product(bool, CMSPrintEdenSurvivorChunks, false, \ 191681404Speter "Print the eden and the survivor chunks used for the parallel " \ 191781404Speter "initial mark or remark of the eden/survivor spaces") \ 191881404Speter \ 191981404Speter product(bool, CMSConcurrentMTEnabled, true, \ 192081404Speter "Whether multi-threaded concurrent work enabled " \ 192181404Speter "(effective only if ParNewGC)") \ 192281404Speter \ 192381404Speter product(bool, CMSPrecleaningEnabled, true, \ 192481404Speter "Whether concurrent precleaning enabled") \ 192581404Speter \ 192681404Speter product(uintx, CMSPrecleanIter, 3, \ 192781404Speter "Maximum number of precleaning iteration passes") \ 192881404Speter range(0, 9) \ 192981404Speter \ 193081404Speter product(uintx, CMSPrecleanDenominator, 3, \ 193181404Speter "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ 193281404Speter "ratio") \ 193381404Speter range(1, max_uintx) \ 193481404Speter constraint(CMSPrecleanDenominatorConstraintFunc) \ 193581404Speter \ 1936102840Speter product(uintx, CMSPrecleanNumerator, 2, \ 193781404Speter "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ 193881404Speter "ratio") \ 193981404Speter range(0, max_uintx-1) \ 1940102840Speter constraint(CMSPrecleanNumeratorConstraintFunc) \ 194181404Speter \ 194281404Speter product(bool, CMSPrecleanRefLists1, true, \ 194381404Speter "Preclean ref lists during (initial) preclean phase") \ 194481404Speter \ 194581404Speter product(bool, CMSPrecleanRefLists2, false, \ 194681404Speter "Preclean ref lists during abortable preclean phase") \ 194781404Speter \ 194881404Speter product(bool, CMSPrecleanSurvivors1, false, \ 194981404Speter "Preclean survivors during (initial) preclean phase") \ 1950102840Speter \ 195181404Speter product(bool, CMSPrecleanSurvivors2, true, \ 195281404Speter "Preclean survivors during abortable preclean phase") \ 195381404Speter \ 1954102840Speter product(uintx, CMSPrecleanThreshold, 1000, \ 195581404Speter "Do not iterate again if number of dirty cards is less than this")\ 195681404Speter range(100, max_uintx) \ 195781404Speter \ 1958102840Speter product(bool, CMSCleanOnEnter, true, \ 195981404Speter "Clean-on-enter optimization for reducing number of dirty cards") \ 196081404Speter \ 196181404Speter product(uintx, CMSRemarkVerifyVariant, 1, \ 1962102840Speter "Choose variant (1,2) of verification following remark") \ 196381404Speter range(1, 2) \ 196481404Speter \ 196581404Speter product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \ 1966102840Speter "If Eden size is below this, do not try to schedule remark") \ 196781404Speter \ 196881404Speter product(uintx, CMSScheduleRemarkEdenPenetration, 50, \ 196981404Speter "The Eden occupancy percentage (0-100) at which " \ 197081404Speter "to try and schedule remark pause") \ 197181404Speter range(0, 100) \ 197281404Speter \ 197381404Speter product(uintx, CMSScheduleRemarkSamplingRatio, 5, \ 197481404Speter "Start sampling eden top at least before young gen " \ 197581404Speter "occupancy reaches 1/<ratio> of the size at which " \ 197681404Speter "we plan to schedule remark") \ 197781404Speter range(1, max_uintx) \ 197881404Speter \ 197981404Speter product(uintx, CMSSamplingGrain, 16*K, \ 198081404Speter "The minimum distance between eden samples for CMS (see above)") \ 198181404Speter range(1, max_uintx) \ 198281404Speter \ 198381404Speter product(bool, CMSScavengeBeforeRemark, false, \ 198481404Speter "Attempt scavenge before the CMS remark step") \ 198581404Speter \ 198681404Speter develop(bool, CMSTraceSweeper, false, \ 198781404Speter "Trace some actions of the CMS sweeper") \ 198881404Speter \ 198981404Speter product(uintx, CMSWorkQueueDrainThreshold, 10, \ 199081404Speter "Don't drain below this size per parallel worker/thief") \ 199181404Speter \ 199281404Speter manageable(intx, CMSWaitDuration, 2000, \ 199381404Speter "Time in milliseconds that CMS thread waits for young GC") \ 199481404Speter \ 199581404Speter develop(uintx, CMSCheckInterval, 1000, \ 199681404Speter "Interval in milliseconds that CMS thread checks if it " \ 199781404Speter "should start a collection cycle") \ 199881404Speter \ 199981404Speter product(bool, CMSYield, true, \ 200081404Speter "Yield between steps of CMS") \ 200181404Speter \ 200281404Speter product(size_t, CMSBitMapYieldQuantum, 10*M, \ 200381404Speter "Bitmap operations should process at most this many bits " \ 200481404Speter "between yields") \ 200581404Speter range(1, max_uintx) \ 200681404Speter \ 200781404Speter product(bool, CMSDumpAtPromotionFailure, false, \ 200881404Speter "Dump useful information about the state of the CMS old " \ 200981404Speter "generation upon a promotion failure") \ 201081404Speter \ 201181404Speter product(bool, CMSPrintChunksInDump, false, \ 201281404Speter "In a dump enabled by CMSDumpAtPromotionFailure, include " \ 201381404Speter "more detailed information about the free chunks") \ 201481404Speter \ 201581404Speter product(bool, CMSPrintObjectsInDump, false, \ 201681404Speter "In a dump enabled by CMSDumpAtPromotionFailure, include " \ 201781404Speter "more detailed information about the allocated objects") \ 201881404Speter \ 201981404Speter diagnostic(bool, FLSVerifyAllHeapReferences, false, \ 202081404Speter "Verify that all references across the FLS boundary " \ 202181404Speter "are to valid objects") \ 202281404Speter \ 202381404Speter diagnostic(bool, FLSVerifyLists, false, \ 202481404Speter "Do lots of (expensive) FreeListSpace verification") \ 202581404Speter \ 202681404Speter diagnostic(bool, FLSVerifyIndexTable, false, \ 202781404Speter "Do lots of (expensive) FLS index table verification") \ 202881404Speter \ 202981404Speter develop(bool, FLSVerifyDictionary, false, \ 203081404Speter "Do lots of (expensive) FLS dictionary verification") \ 203181404Speter \ 203281404Speter develop(bool, VerifyBlockOffsetArray, false, \ 203381404Speter "Do (expensive) block offset array verification") \ 203481404Speter \ 203581404Speter diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \ 203681404Speter "Maintain _unallocated_block in BlockOffsetArray " \ 203781404Speter "(currently applicable only to CMS collector)") \ 203881404Speter \ 203981404Speter develop(bool, TraceCMSState, false, \ 204081404Speter "Trace the state of the CMS collection") \ 204181404Speter \ 204281404Speter product(intx, RefDiscoveryPolicy, 0, \ 204381404Speter "Select type of reference discovery policy: " \ 204481404Speter "reference-based(0) or referent-based(1)") \ 204581404Speter range(ReferenceProcessor::DiscoveryPolicyMin, \ 204681404Speter ReferenceProcessor::DiscoveryPolicyMax) \ 204781404Speter \ 204881404Speter product(bool, ParallelRefProcEnabled, false, \ 204981404Speter "Enable parallel reference processing whenever possible") \ 205081404Speter \ 205181404Speter product(bool, ParallelRefProcBalancingEnabled, true, \ 205281404Speter "Enable balancing of reference processing queues") \ 205381404Speter \ 205481404Speter product(uintx, CMSTriggerRatio, 80, \ 205581404Speter "Percentage of MinHeapFreeRatio in CMS generation that is " \ 205681404Speter "allocated before a CMS collection cycle commences") \ 205781404Speter range(0, 100) \ 205881404Speter \ 205981404Speter product(uintx, CMSBootstrapOccupancy, 50, \ 206081404Speter "Percentage CMS generation occupancy at which to " \ 206181404Speter "initiate CMS collection for bootstrapping collection stats") \ 206281404Speter range(0, 100) \ 206381404Speter \ 206481404Speter product(intx, CMSInitiatingOccupancyFraction, -1, \ 206581404Speter "Percentage CMS generation occupancy to start a CMS collection " \ 206681404Speter "cycle. A negative value means that CMSTriggerRatio is used") \ 206781404Speter range(min_intx, 100) \ 206881404Speter \ 206981404Speter product(uintx, InitiatingHeapOccupancyPercent, 45, \ 207081404Speter "Percentage of the (entire) heap occupancy to start a " \ 207181404Speter "concurrent GC cycle. It is used by GCs that trigger a " \ 207281404Speter "concurrent GC cycle based on the occupancy of the entire heap, " \ 207381404Speter "not just one of the generations (e.g., G1). A value of 0 " \ 207481404Speter "denotes 'do constant GC cycles'.") \ 207581404Speter range(0, 100) \ 207681404Speter \ 207781404Speter manageable(intx, CMSTriggerInterval, -1, \ 207881404Speter "Commence a CMS collection cycle (at least) every so many " \ 207981404Speter "milliseconds (0 permanently, -1 disabled)") \ 208081404Speter range(-1, max_intx) \ 208181404Speter \ 208281404Speter product(bool, UseCMSInitiatingOccupancyOnly, false, \ 208381404Speter "Only use occupancy as a criterion for starting a CMS collection")\ 208481404Speter \ 208581404Speter product(uintx, CMSIsTooFullPercentage, 98, \ 208681404Speter "An absolute ceiling above which CMS will always consider the " \ 208781404Speter "unloading of classes when class unloading is enabled") \ 208881404Speter range(0, 100) \ 208981404Speter \ 209081404Speter develop(bool, CMSTestInFreeList, false, \ 209181404Speter "Check if the coalesced range is already in the " \ 209281404Speter "free lists as claimed") \ 209381404Speter \ 209481404Speter notproduct(bool, CMSVerifyReturnedBytes, false, \ 209581404Speter "Check that all the garbage collected was returned to the " \ 209681404Speter "free lists") \ 209781404Speter \ 209881404Speter notproduct(bool, ScavengeALot, false, \ 209981404Speter "Force scavenge at every Nth exit from the runtime system " \ 210081404Speter "(N=ScavengeALotInterval)") \ 210181404Speter \ 210281404Speter develop(bool, FullGCALot, false, \ 210381404Speter "Force full gc at every Nth exit from the runtime system " \ 210481404Speter "(N=FullGCALotInterval)") \ 210581404Speter \ 210681404Speter notproduct(bool, GCALotAtAllSafepoints, false, \ 210781404Speter "Enforce ScavengeALot/GCALot at all potential safepoints") \ 210881404Speter \ 210981404Speter product(bool, PrintPromotionFailure, false, \ 211081404Speter "Print additional diagnostic information following " \ 211181404Speter "promotion failure") \ 211281404Speter \ 211381404Speter notproduct(bool, PromotionFailureALot, false, \ 211481404Speter "Use promotion failure handling on every youngest generation " \ 211581404Speter "collection") \ 211681404Speter \ 211781404Speter develop(uintx, PromotionFailureALotCount, 1000, \ 211881404Speter "Number of promotion failures occurring at PLAB " \ 211981404Speter "refill attempts (ParNew) or promotion attempts " \ 212081404Speter "(other young collectors)") \ 212181404Speter \ 212281404Speter develop(uintx, PromotionFailureALotInterval, 5, \ 212381404Speter "Total collections between promotion failures a lot") \ 212481404Speter \ 212581404Speter experimental(uintx, WorkStealingSleepMillis, 1, \ 212681404Speter "Sleep time when sleep is used for yields") \ 212781404Speter \ 212881404Speter experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \ 212981404Speter "Number of yields before a sleep is done during work stealing") \ 213081404Speter \ 213181404Speter experimental(uintx, WorkStealingHardSpins, 4096, \ 213281404Speter "Number of iterations in a spin loop between checks on " \ 213381404Speter "time out of hard spin") \ 213481404Speter \ 213581404Speter experimental(uintx, WorkStealingSpinToYieldRatio, 10, \ 213681404Speter "Ratio of hard spins to calls to yield") \ 213781404Speter \ 213881404Speter develop(uintx, ObjArrayMarkingStride, 512, \ 213981404Speter "Number of object array elements to push onto the marking stack " \ 214081404Speter "before pushing a continuation entry") \ 214181404Speter \ 214281404Speter develop(bool, MetadataAllocationFailALot, false, \ 214381404Speter "Fail metadata allocations at intervals controlled by " \ 214481404Speter "MetadataAllocationFailALotInterval") \ 214581404Speter \ 214681404Speter develop(uintx, MetadataAllocationFailALotInterval, 1000, \ 214781404Speter "Metadata allocation failure a lot interval") \ 214881404Speter \ 214981404Speter develop(bool, TraceMetadataChunkAllocation, false, \ 215081404Speter "Trace chunk metadata allocations") \ 215181404Speter \ 215281404Speter product(bool, TraceMetadataHumongousAllocation, false, \ 215381404Speter "Trace humongous metadata allocations") \ 215481404Speter \ 215581404Speter develop(bool, TraceMetavirtualspaceAllocation, false, \ 215681404Speter "Trace virtual space metadata allocations") \ 215781404Speter \ 215881404Speter notproduct(bool, ExecuteInternalVMTests, false, \ 215981404Speter "Enable execution of internal VM tests") \ 216081404Speter \ 216181404Speter notproduct(bool, VerboseInternalVMTests, false, \ 216281404Speter "Turn on logging for internal VM tests.") \ 216381404Speter \ 216481404Speter product_pd(bool, UseTLAB, "Use thread-local object allocation") \ 216581404Speter \ 216681404Speter product_pd(bool, ResizeTLAB, \ 216781404Speter "Dynamically resize TLAB size for threads") \ 216881404Speter \ 216981404Speter product(bool, ZeroTLAB, false, \ 217081404Speter "Zero out the newly created TLAB") \ 217181404Speter \ 217281404Speter product(bool, FastTLABRefill, true, \ 217381404Speter "Use fast TLAB refill code") \ 217481404Speter \ 217581404Speter product(bool, PrintTLAB, false, \ 217681404Speter "Print various TLAB related information") \ 217781404Speter \ 217881404Speter product(bool, TLABStats, true, \ 217981404Speter "Provide more detailed and expensive TLAB statistics " \ 218081404Speter "(with PrintTLAB)") \ 218181404Speter \ 218281404Speter product_pd(bool, NeverActAsServerClassMachine, \ 218381404Speter "Never act like a server-class machine") \ 218481404Speter \ 218581404Speter product(bool, AlwaysActAsServerClassMachine, false, \ 218681404Speter "Always act like a server-class machine") \ 218781404Speter \ 218881404Speter product_pd(uint64_t, MaxRAM, \ 218981404Speter "Real memory size (in bytes) used to set maximum heap size") \ 219081404Speter \ 219181404Speter product(size_t, ErgoHeapSizeLimit, 0, \ 219281404Speter "Maximum ergonomically set heap size (in bytes); zero means use " \ 219381404Speter "MaxRAM / MaxRAMFraction") \ 219481404Speter \ 219581404Speter product(uintx, MaxRAMFraction, 4, \ 219681404Speter "Maximum fraction (1/n) of real memory used for maximum heap " \ 219781404Speter "size") \ 219881404Speter range(1, max_uintx) \ 219981404Speter \ 220081404Speter product(uintx, DefaultMaxRAMFraction, 4, \ 220181404Speter "Maximum fraction (1/n) of real memory used for maximum heap " \ 220281404Speter "size; deprecated: to be renamed to MaxRAMFraction") \ 220381404Speter range(1, max_uintx) \ 220481404Speter \ 220581404Speter product(uintx, MinRAMFraction, 2, \ 220681404Speter "Minimum fraction (1/n) of real memory used for maximum heap " \ 220781404Speter "size on systems with small physical memory size") \ 220881404Speter range(1, max_uintx) \ 220981404Speter \ 221081404Speter product(uintx, InitialRAMFraction, 64, \ 221181404Speter "Fraction (1/n) of real memory used for initial heap size") \ 221281404Speter range(1, max_uintx) \ 221381404Speter \ 221481404Speter develop(uintx, MaxVirtMemFraction, 2, \ 221581404Speter "Maximum fraction (1/n) of virtual memory used for ergonomically "\ 221681404Speter "determining maximum heap size") \ 221781404Speter \ 221881404Speter product(bool, UseAutoGCSelectPolicy, false, \ 221981404Speter "Use automatic collection selection policy") \ 222081404Speter \ 222181404Speter product(uintx, AutoGCSelectPauseMillis, 5000, \ 222281404Speter "Automatic GC selection pause threshold in milliseconds") \ 222381404Speter \ 222481404Speter product(bool, UseAdaptiveSizePolicy, true, \ 222581404Speter "Use adaptive generation sizing policies") \ 222681404Speter \ 222781404Speter product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \ 222881404Speter "Use adaptive survivor sizing policies") \ 222981404Speter \ 223081404Speter product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \ 223181404Speter "Use adaptive young-old sizing policies at minor collections") \ 223281404Speter \ 223381404Speter product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \ 223481404Speter "Use adaptive young-old sizing policies at major collections") \ 223581404Speter \ 223681404Speter product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \ 223781404Speter "Include statistics from System.gc() for adaptive size policy") \ 223881404Speter \ 223981404Speter product(bool, UseAdaptiveGCBoundary, false, \ 224081404Speter "Allow young-old boundary to move") \ 224181404Speter \ 224281404Speter develop(bool, TraceAdaptiveGCBoundary, false, \ 224381404Speter "Trace young-old boundary moves") \ 224481404Speter \ 224581404Speter develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \ 224681404Speter "Resize the virtual spaces of the young or old generations") \ 224781404Speter \ 224881404Speter product(uintx, AdaptiveSizeThroughPutPolicy, 0, \ 224981404Speter "Policy for changing generation size for throughput goals") \ 225081404Speter \ 225181404Speter develop(bool, PSAdjustTenuredGenForMinorPause, false, \ 225281404Speter "Adjust tenured generation to achieve a minor pause goal") \ 225381404Speter \ 225481404Speter develop(bool, PSAdjustYoungGenForMajorPause, false, \ 225581404Speter "Adjust young generation to achieve a major pause goal") \ 225681404Speter \ 225781404Speter product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \ 225881404Speter "Number of steps where heuristics is used before data is used") \ 225981404Speter \ 226081404Speter develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \ 226181404Speter "Number of collections before the adaptive sizing is started") \ 226281404Speter \ 226381404Speter product(uintx, AdaptiveSizePolicyOutputInterval, 0, \ 226481404Speter "Collection interval for printing information; zero means never") \ 226581404Speter \ 226681404Speter product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \ 226781404Speter "Use adaptive minimum footprint as a goal") \ 226881404Speter \ 226981404Speter product(uintx, AdaptiveSizePolicyWeight, 10, \ 227081404Speter "Weight given to exponential resizing, between 0 and 100") \ 227181404Speter range(0, 100) \ 227281404Speter \ 227381404Speter product(uintx, AdaptiveTimeWeight, 25, \ 227481404Speter "Weight given to time in adaptive policy, between 0 and 100") \ 227581404Speter range(0, 100) \ 227681404Speter \ 227781404Speter product(uintx, PausePadding, 1, \ 227881404Speter "How much buffer to keep for pause time") \ 227981404Speter \ 228081404Speter product(uintx, PromotedPadding, 3, \ 228181404Speter "How much buffer to keep for promotion failure") \ 228281404Speter \ 228381404Speter product(uintx, SurvivorPadding, 3, \ 228481404Speter "How much buffer to keep for survivor overflow") \ 228581404Speter \ 228681404Speter product(uintx, ThresholdTolerance, 10, \ 228781404Speter "Allowed collection cost difference between generations") \ 228881404Speter range(0, 100) \ 228981404Speter \ 229081404Speter product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \ 229181404Speter "If collection costs are within margin, reduce both by full " \ 229281404Speter "delta") \ 229381404Speter \ 229481404Speter product(uintx, YoungGenerationSizeIncrement, 20, \ 229581404Speter "Adaptive size percentage change in young generation") \ 229681404Speter range(0, 100) \ 229781404Speter \ 229881404Speter product(uintx, YoungGenerationSizeSupplement, 80, \ 229981404Speter "Supplement to YoungedGenerationSizeIncrement used at startup") \ 230081404Speter range(0, 100) \ 230181404Speter \ 230281404Speter product(uintx, YoungGenerationSizeSupplementDecay, 8, \ 230381404Speter "Decay factor to YoungedGenerationSizeSupplement") \ 230481404Speter range(1, max_uintx) \ 230581404Speter \ 230681404Speter product(uintx, TenuredGenerationSizeIncrement, 20, \ 230781404Speter "Adaptive size percentage change in tenured generation") \ 230881404Speter range(0, 100) \ 230981404Speter \ 231081404Speter product(uintx, TenuredGenerationSizeSupplement, 80, \ 231181404Speter "Supplement to TenuredGenerationSizeIncrement used at startup") \ 231281404Speter range(0, 100) \ 231381404Speter \ 231481404Speter product(uintx, TenuredGenerationSizeSupplementDecay, 2, \ 231581404Speter "Decay factor to TenuredGenerationSizeIncrement") \ 231681404Speter range(1, max_uintx) \ 231781404Speter \ 231881404Speter product(uintx, MaxGCPauseMillis, max_uintx, \ 231981404Speter "Adaptive size policy maximum GC pause time goal in millisecond, "\ 232081404Speter "or (G1 Only) the maximum GC time per MMU time slice") \ 232181404Speter \ 232266525Speter product(uintx, GCPauseIntervalMillis, 0, \ 232366525Speter "Time slice for MMU specification") \ 232466525Speter \ 232566525Speter product(uintx, MaxGCMinorPauseMillis, max_uintx, \ 232666525Speter "Adaptive size policy maximum GC minor pause time goal " \ 232766525Speter "in millisecond") \ 232866525Speter \ 232966525Speter product(uintx, GCTimeRatio, 99, \ 233066525Speter "Adaptive size policy application time to GC time ratio") \ 233166525Speter \ 233266525Speter product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \ 233366525Speter "Adaptive size scale down factor for shrinking") \ 233466525Speter range(1, max_uintx) \ 233566525Speter \ 233666525Speter product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \ 233766525Speter "Adaptive size decays the major cost for long major intervals") \ 233866525Speter \ 233966525Speter product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \ 234066525Speter "Time scale over which major costs decay") \ 234166525Speter \ 234266525Speter product(uintx, MinSurvivorRatio, 3, \ 234366525Speter "Minimum ratio of young generation/survivor space size") \ 234466525Speter \ 234566525Speter product(uintx, InitialSurvivorRatio, 8, \ 234666525Speter "Initial ratio of young generation/survivor space size") \ 234766525Speter \ 234866525Speter product(size_t, BaseFootPrintEstimate, 256*M, \ 234966525Speter "Estimate of footprint other than Java Heap") \ 235066525Speter \ 235166525Speter product(bool, UseGCOverheadLimit, true, \ 235266525Speter "Use policy to limit of proportion of time spent in GC " \ 235366525Speter "before an OutOfMemory error is thrown") \ 235466525Speter \ 235566525Speter product(uintx, GCTimeLimit, 98, \ 235666525Speter "Limit of the proportion of time spent in GC before " \ 235766525Speter "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \ 235866525Speter range(0, 100) \ 235966525Speter \ 236066525Speter product(uintx, GCHeapFreeLimit, 2, \ 236166525Speter "Minimum percentage of free space after a full GC before an " \ 236266525Speter "OutOfMemoryError is thrown (used with GCTimeLimit)") \ 236366525Speter range(0, 100) \ 236466525Speter \ 236566525Speter develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \ 236666525Speter "Number of consecutive collections before gc time limit fires") \ 236766525Speter \ 236866525Speter product(bool, PrintAdaptiveSizePolicy, false, \ 236966525Speter "Print information about AdaptiveSizePolicy") \ 237066525Speter \ 237166525Speter product(intx, PrefetchCopyIntervalInBytes, -1, \ 237266525Speter "How far ahead to prefetch destination area (<= 0 means off)") \ 237366525Speter \ 237466525Speter product(intx, PrefetchScanIntervalInBytes, -1, \ 237566525Speter "How far ahead to prefetch scan area (<= 0 means off)") \ 237666525Speter \ 237766525Speter product(intx, PrefetchFieldsAhead, -1, \ 237866525Speter "How many fields ahead to prefetch in oop scan (<= 0 means off)") \ 237966525Speter \ 238066525Speter diagnostic(bool, VerifySilently, false, \ 238166525Speter "Do not print the verification progress") \ 238266525Speter \ 238366525Speter diagnostic(bool, VerifyDuringStartup, false, \ 238466525Speter "Verify memory system before executing any Java code " \ 238566525Speter "during VM initialization") \ 238666525Speter \ 238766525Speter diagnostic(bool, VerifyBeforeExit, trueInDebug, \ 238866525Speter "Verify system before exiting") \ 238966525Speter \ 239066525Speter diagnostic(bool, VerifyBeforeGC, false, \ 239166525Speter "Verify memory system before GC") \ 239266525Speter \ 239366525Speter diagnostic(bool, VerifyAfterGC, false, \ 239466525Speter "Verify memory system after GC") \ 239566525Speter \ 239666525Speter diagnostic(bool, VerifyDuringGC, false, \ 239766525Speter "Verify memory system during GC (between phases)") \ 239866525Speter \ 239966525Speter diagnostic(bool, GCParallelVerificationEnabled, true, \ 240066525Speter "Enable parallel memory system verification") \ 240166525Speter \ 240266525Speter diagnostic(bool, DeferInitialCardMark, false, \ 240366525Speter "When +ReduceInitialCardMarks, explicitly defer any that " \ 240466525Speter "may arise from new_pre_store_barrier") \ 240566525Speter \ 240666525Speter product(bool, UseCondCardMark, false, \ 240766525Speter "Check for already marked card before updating card table") \ 240866525Speter \ 240966525Speter diagnostic(bool, VerifyRememberedSets, false, \ 241066525Speter "Verify GC remembered sets") \ 241166525Speter \ 241266525Speter diagnostic(bool, VerifyObjectStartArray, true, \ 241366525Speter "Verify GC object start array if verify before/after") \ 241466525Speter \ 241566525Speter product(bool, DisableExplicitGC, false, \ 241666525Speter "Ignore calls to System.gc()") \ 241766525Speter \ 241866525Speter notproduct(bool, CheckMemoryInitialization, false, \ 241966525Speter "Check memory initialization") \ 242066525Speter \ 242166525Speter diagnostic(bool, BindCMSThreadToCPU, false, \ 242254427Speter "Bind CMS Thread to CPU if possible") \ 242354427Speter \ 242454427Speter diagnostic(uintx, CPUForCMSThread, 0, \ 242554427Speter "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \ 242654427Speter \ 242754427Speter product(bool, BindGCTaskThreadsToCPUs, false, \ 242854427Speter "Bind GCTaskThreads to CPUs if possible") \ 242954427Speter \ 243054427Speter product(bool, UseGCTaskAffinity, false, \ 243154427Speter "Use worker affinity when asking for GCTasks") \ 243254427Speter \ 243354427Speter product(uintx, ProcessDistributionStride, 4, \ 243454427Speter "Stride through processors when distributing processes") \ 243554427Speter \ 243654427Speter product(uintx, CMSCoordinatorYieldSleepCount, 10, \ 243754427Speter "Number of times the coordinator GC thread will sleep while " \ 243854427Speter "yielding before giving up and resuming GC") \ 243954427Speter \ 244054427Speter product(uintx, CMSYieldSleepCount, 0, \ 244154427Speter "Number of times a GC thread (minus the coordinator) " \ 244254427Speter "will sleep while yielding before giving up and resuming GC") \ 244354427Speter \ 244454427Speter /* gc tracing */ \ 244554427Speter manageable(bool, PrintGC, false, \ 244654427Speter "Print message at garbage collection") \ 244754427Speter \ 244854427Speter manageable(bool, PrintGCDetails, false, \ 244954427Speter "Print more details at garbage collection") \ 245054427Speter \ 245154427Speter manageable(bool, PrintGCDateStamps, false, \ 245254427Speter "Print date stamps at garbage collection") \ 245354427Speter \ 245454427Speter manageable(bool, PrintGCTimeStamps, false, \ 245554427Speter "Print timestamps at garbage collection") \ 245654427Speter \ 245754427Speter manageable(bool, PrintGCID, true, \ 245854427Speter "Print an identifier for each garbage collection") \ 245954427Speter \ 246054427Speter product(bool, PrintGCTaskTimeStamps, false, \ 246154427Speter "Print timestamps for individual gc worker thread tasks") \ 246254427Speter \ 246354427Speter develop(intx, ConcGCYieldTimeout, 0, \ 246454427Speter "If non-zero, assert that GC threads yield within this " \ 246554427Speter "number of milliseconds") \ 246654427Speter \ 246754427Speter product(bool, PrintReferenceGC, false, \ 246854427Speter "Print times spent handling reference objects during GC " \ 246954427Speter "(enabled only when PrintGCDetails)") \ 247054427Speter \ 247154427Speter develop(bool, TraceReferenceGC, false, \ 247254427Speter "Trace handling of soft/weak/final/phantom references") \ 247354427Speter \ 247454427Speter develop(bool, TraceFinalizerRegistration, false, \ 247554427Speter "Trace registration of final references") \ 247654427Speter \ 247754427Speter notproduct(bool, TraceScavenge, false, \ 247854427Speter "Trace scavenge") \ 247954427Speter \ 248054427Speter product(bool, IgnoreEmptyClassPaths, false, \ 248154427Speter "Ignore empty path elements in -classpath") \ 248254427Speter \ 248354427Speter product(bool, TraceClassPaths, false, \ 248454427Speter "Trace processing of class paths") \ 248554427Speter \ 248654427Speter product_rw(bool, TraceClassLoading, false, \ 248754427Speter "Trace all classes loaded") \ 248854427Speter \ 248954427Speter product(bool, TraceClassLoadingPreorder, false, \ 249054427Speter "Trace all classes loaded in order referenced (not loaded)") \ 249154427Speter \ 249254427Speter product_rw(bool, TraceClassUnloading, false, \ 249354427Speter "Trace unloading of classes") \ 249454427Speter \ 249554427Speter product_rw(bool, TraceLoaderConstraints, false, \ 249654427Speter "Trace loader constraints") \ 249754427Speter \ 249854427Speter develop(bool, TraceClassLoaderData, false, \ 249954427Speter "Trace class loader loader_data lifetime") \ 250054427Speter \ 250154427Speter product(size_t, InitialBootClassLoaderMetaspaceSize, \ 250254427Speter NOT_LP64(2200*K) LP64_ONLY(4*M), \ 250354427Speter "Initial size of the boot class loader data metaspace") \ 250454427Speter \ 250554427Speter product(bool, TraceYoungGenTime, false, \ 250654427Speter "Trace accumulated time for young collection") \ 250754427Speter \ 250854427Speter product(bool, TraceOldGenTime, false, \ 250954427Speter "Trace accumulated time for old collection") \ 251054427Speter \ 251154427Speter product(bool, PrintTenuringDistribution, false, \ 251254427Speter "Print tenuring age information") \ 251354427Speter \ 251454427Speter product_rw(bool, PrintHeapAtGC, false, \ 251554427Speter "Print heap layout before and after each GC") \ 251654427Speter \ 251754427Speter product_rw(bool, PrintHeapAtGCExtended, false, \ 251854427Speter "Print extended information about the layout of the heap " \ 251954427Speter "when -XX:+PrintHeapAtGC is set") \ 252054427Speter \ 252154427Speter product(bool, PrintHeapAtSIGBREAK, true, \ 252254427Speter "Print heap layout in response to SIGBREAK") \ 252354427Speter \ 252454427Speter manageable(bool, PrintClassHistogramBeforeFullGC, false, \ 252554427Speter "Print a class histogram before any major stop-world GC") \ 252654427Speter \ 252754427Speter manageable(bool, PrintClassHistogramAfterFullGC, false, \ 252854427Speter "Print a class histogram after any major stop-world GC") \ 252954427Speter \ 253054427Speter manageable(bool, PrintClassHistogram, false, \ 253154427Speter "Print a histogram of class instances") \ 253254427Speter \ 253354427Speter develop(bool, TraceWorkGang, false, \ 253454427Speter "Trace activities of work gangs") \ 253554427Speter \ 253654427Speter product(bool, TraceParallelOldGCTasks, false, \ 253754427Speter "Trace multithreaded GC activity") \ 253854427Speter \ 253954427Speter develop(bool, TraceBlockOffsetTable, false, \ 254054427Speter "Print BlockOffsetTable maps") \ 254154427Speter \ 254254427Speter develop(bool, TraceCardTableModRefBS, false, \ 254354427Speter "Print CardTableModRefBS maps") \ 254454427Speter \ 254554427Speter develop(bool, TraceGCTaskManager, false, \ 254654427Speter "Trace actions of the GC task manager") \ 254754427Speter \ 254854427Speter develop(bool, TraceGCTaskQueue, false, \ 254954427Speter "Trace actions of the GC task queues") \ 255054427Speter \ 255154427Speter diagnostic(bool, TraceGCTaskThread, false, \ 255254427Speter "Trace actions of the GC task threads") \ 255354427Speter \ 255454427Speter product(bool, PrintParallelOldGCPhaseTimes, false, \ 255554427Speter "Print the time taken by each phase in ParallelOldGC " \ 255654427Speter "(PrintGCDetails must also be enabled)") \ 255754427Speter \ 255854427Speter develop(bool, TraceParallelOldGCMarkingPhase, false, \ 255954427Speter "Trace marking phase in ParallelOldGC") \ 256054427Speter \ 256154427Speter develop(bool, TraceParallelOldGCSummaryPhase, false, \ 256254427Speter "Trace summary phase in ParallelOldGC") \ 256354427Speter \ 256454427Speter develop(bool, TraceParallelOldGCCompactionPhase, false, \ 256554427Speter "Trace compaction phase in ParallelOldGC") \ 256654427Speter \ 256754427Speter develop(bool, TraceParallelOldGCDensePrefix, false, \ 256854427Speter "Trace dense prefix computation for ParallelOldGC") \ 256954427Speter \ 257054427Speter develop(bool, IgnoreLibthreadGPFault, false, \ 257154427Speter "Suppress workaround for libthread GP fault") \ 257254427Speter \ 257354427Speter product(bool, PrintJNIGCStalls, false, \ 257454427Speter "Print diagnostic message when GC is stalled " \ 257554427Speter "by JNI critical section") \ 257654427Speter \ 257754427Speter experimental(double, ObjectCountCutOffPercent, 0.5, \ 257854427Speter "The percentage of the used heap that the instances of a class " \ 257954427Speter "must occupy for the class to generate a trace event") \ 258054427Speter \ 258154427Speter /* GC log rotation setting */ \ 258254427Speter \ 258354427Speter product(bool, UseGCLogFileRotation, false, \ 258454427Speter "Rotate gclog files (for long running applications). It requires "\ 258554427Speter "-Xloggc:<filename>") \ 258654427Speter \ 258754427Speter product(uintx, NumberOfGCLogFiles, 0, \ 258854427Speter "Number of gclog files in rotation " \ 258954427Speter "(default: 0, no rotation)") \ 259054427Speter \ 259154427Speter product(size_t, GCLogFileSize, 8*K, \ 259254427Speter "GC log file size, requires UseGCLogFileRotation. " \ 259354427Speter "Set to 0 to only trigger rotation via jcmd") \ 259454427Speter \ 259554427Speter /* JVMTI heap profiling */ \ 259654427Speter \ 259754427Speter diagnostic(bool, TraceJVMTIObjectTagging, false, \ 259854427Speter "Trace JVMTI object tagging calls") \ 259954427Speter \ 260054427Speter diagnostic(bool, VerifyBeforeIteration, false, \ 260154427Speter "Verify memory system before JVMTI iteration") \ 260254427Speter \ 260354427Speter /* compiler interface */ \ 260454427Speter \ 260554427Speter develop(bool, CIPrintCompilerName, false, \ 260654427Speter "when CIPrint is active, print the name of the active compiler") \ 260754427Speter \ 260854427Speter diagnostic(bool, CIPrintCompileQueue, false, \ 260954427Speter "display the contents of the compile queue whenever a " \ 261054427Speter "compilation is enqueued") \ 261154427Speter \ 261254427Speter develop(bool, CIPrintRequests, false, \ 261354427Speter "display every request for compilation") \ 261454427Speter \ 261554427Speter product(bool, CITime, false, \ 261654427Speter "collect timing information for compilation") \ 261754427Speter \ 261854427Speter develop(bool, CITimeVerbose, false, \ 261954427Speter "be more verbose in compilation timings") \ 262054427Speter \ 262154427Speter develop(bool, CITimeEach, false, \ 262244852Speter "display timing information after each successful compilation") \ 262344852Speter \ 262444852Speter develop(bool, CICountOSR, false, \ 262544852Speter "use a separate counter when assigning ids to osr compilations") \ 262644852Speter \ 262744852Speter develop(bool, CICompileNatives, true, \ 262844852Speter "compile native methods if supported by the compiler") \ 262944852Speter \ 263044852Speter develop_pd(bool, CICompileOSR, \ 263144852Speter "compile on stack replacement methods if supported by the " \ 263244852Speter "compiler") \ 263344852Speter \ 263444852Speter develop(bool, CIPrintMethodCodes, false, \ 263544852Speter "print method bytecodes of the compiled code") \ 263644852Speter \ 263744852Speter develop(bool, CIPrintTypeFlow, false, \ 263844852Speter "print the results of ciTypeFlow analysis") \ 263944852Speter \ 264044852Speter develop(bool, CITraceTypeFlow, false, \ 264144852Speter "detailed per-bytecode tracing of ciTypeFlow analysis") \ 264244852Speter \ 264344852Speter develop(intx, OSROnlyBCI, -1, \ 264444852Speter "OSR only at this bci. Negative values mean exclude that bci") \ 264544852Speter \ 264644852Speter /* compiler */ \ 264744852Speter \ 264844852Speter /* notice: the max range value here is max_jint, not max_intx */ \ 264944852Speter /* because of overflow issue */ \ 265044852Speter product(intx, CICompilerCount, CI_COMPILER_COUNT, \ 265144852Speter "Number of compiler threads to run") \ 265244852Speter range((intx)Arguments::get_min_number_of_compiler_threads(), \ 265344852Speter max_jint) \ 265444852Speter \ 265544852Speter product(intx, CompilationPolicyChoice, 0, \ 265644852Speter "which compilation policy (0-3)") \ 265744852Speter range(0, 3) \ 265844852Speter \ 265944852Speter develop(bool, UseStackBanging, true, \ 266044852Speter "use stack banging for stack overflow checks (required for " \ 266144852Speter "proper StackOverflow handling; disable only to measure cost " \ 266244852Speter "of stackbanging)") \ 266344852Speter \ 266444852Speter develop(bool, UseStrictFP, true, \ 266544852Speter "use strict fp if modifier strictfp is set") \ 266644852Speter \ 266744852Speter develop(bool, GenerateSynchronizationCode, true, \ 266844852Speter "generate locking/unlocking code for synchronized methods and " \ 266944852Speter "monitors") \ 267044852Speter \ 267144852Speter develop(bool, GenerateCompilerNullChecks, true, \ 267244852Speter "Generate explicit null checks for loads/stores/calls") \ 267344852Speter \ 267444852Speter develop(bool, GenerateRangeChecks, true, \ 267544852Speter "Generate range checks for array accesses") \ 267644852Speter \ 267744852Speter develop_pd(bool, ImplicitNullChecks, \ 267844852Speter "Generate code for implicit null checks") \ 267944852Speter \ 268044852Speter product_pd(bool, TrapBasedNullChecks, \ 268144852Speter "Generate code for null checks that uses a cmp and trap " \ 268244852Speter "instruction raising SIGTRAP. This is only used if an access to" \ 268344852Speter "null (+offset) will not raise a SIGSEGV, i.e.," \ 268444852Speter "ImplicitNullChecks don't work (PPC64).") \ 268544852Speter \ 268644852Speter product(bool, PrintSafepointStatistics, false, \ 268744852Speter "Print statistics about safepoint synchronization") \ 268844852Speter \ 268944852Speter product(intx, PrintSafepointStatisticsCount, 300, \ 269044852Speter "Total number of safepoint statistics collected " \ 269144852Speter "before printing them out") \ 269244852Speter \ 269344852Speter product(intx, PrintSafepointStatisticsTimeout, -1, \ 269444852Speter "Print safepoint statistics only when safepoint takes " \ 269544852Speter "more than PrintSafepointSatisticsTimeout in millis") \ 269644852Speter \ 269744852Speter product(bool, TraceSafepointCleanupTime, false, \ 269844852Speter "Print the break down of clean up tasks performed during " \ 269944852Speter "safepoint") \ 270044852Speter \ 270144852Speter product(bool, Inline, true, \ 270244852Speter "Enable inlining") \ 270344852Speter \ 270444852Speter product(bool, ClipInlining, true, \ 270534461Speter "Clip inlining if aggregate method exceeds DesiredMethodLimit") \ 270634461Speter \ 270734461Speter develop(bool, UseCHA, true, \ 270834461Speter "Enable CHA") \ 270934461Speter \ 271034461Speter product(bool, UseTypeProfile, true, \ 271134461Speter "Check interpreter profile for historically monomorphic calls") \ 271234461Speter \ 271334461Speter diagnostic(bool, PrintInlining, false, \ 271434461Speter "Print inlining optimizations") \ 271534461Speter \ 271634461Speter product(bool, UsePopCountInstruction, false, \ 271734461Speter "Use population count instruction") \ 271834461Speter \ 271934461Speter develop(bool, EagerInitialization, false, \ 272034461Speter "Eagerly initialize classes if possible") \ 272134461Speter \ 272234461Speter diagnostic(bool, LogTouchedMethods, false, \ 272334461Speter "Log methods which have been ever touched in runtime") \ 272434461Speter \ 272534461Speter diagnostic(bool, PrintTouchedMethodsAtExit, false, \ 272634461Speter "Print all methods that have been ever touched in runtime") \ 272734461Speter \ 272834461Speter develop(bool, TraceMethodReplacement, false, \ 272934461Speter "Print when methods are replaced do to recompilation") \ 273034461Speter \ 273132785Speter develop(bool, PrintMethodFlushing, false, \ 273232785Speter "Print the nmethods being flushed") \ 273332785Speter \ 273432785Speter diagnostic(bool, PrintMethodFlushingStatistics, false, \ 273532785Speter "print statistics about method flushing") \ 273632785Speter \ 273732785Speter diagnostic(intx, HotMethodDetectionLimit, 100000, \ 273832785Speter "Number of compiled code invocations after which " \ 273932785Speter "the method is considered as hot by the flusher") \ 274032785Speter \ 274132785Speter diagnostic(intx, MinPassesBeforeFlush, 10, \ 274232785Speter "Minimum number of sweeper passes before an nmethod " \ 274332785Speter "can be flushed") \ 274432785Speter \ 274532785Speter product(bool, UseCodeAging, true, \ 274632785Speter "Insert counter to detect warm methods") \ 274732785Speter \ 274832785Speter diagnostic(bool, StressCodeAging, false, \ 274932785Speter "Start with counters compiled in") \ 275032785Speter \ 275132785Speter develop(bool, UseRelocIndex, false, \ 275232785Speter "Use an index to speed random access to relocations") \ 275332785Speter \ 275432785Speter develop(bool, StressCodeBuffers, false, \ 275532785Speter "Exercise code buffer expansion and other rare state changes") \ 275632785Speter \ 275732785Speter diagnostic(bool, DebugNonSafepoints, trueInDebug, \ 275832785Speter "Generate extra debugging information for non-safepoints in " \ 275932785Speter "nmethods") \ 276032785Speter \ 276132785Speter product(bool, PrintVMOptions, false, \ 276232785Speter "Print flags that appeared on the command line") \ 276332785Speter \ 276432785Speter product(bool, IgnoreUnrecognizedVMOptions, false, \ 276532785Speter "Ignore unrecognized VM options") \ 276632785Speter \ 276732785Speter product(bool, PrintCommandLineFlags, false, \ 276832785Speter "Print flags specified on command line or set by ergonomics") \ 276932785Speter \ 277032785Speter product(bool, PrintFlagsInitial, false, \ 277132785Speter "Print all VM flags before argument processing and exit VM") \ 277232785Speter \ 277332785Speter product(bool, PrintFlagsFinal, false, \ 277432785Speter "Print all VM flags after argument and ergonomic processing") \ 277532785Speter \ 277632785Speter notproduct(bool, PrintFlagsWithComments, false, \ 277732785Speter "Print all VM flags with default values and descriptions and " \ 277832785Speter "exit") \ 277932785Speter \ 278032785Speter product(bool, PrintFlagsRanges, false, \ 278132785Speter "Print VM flags and their ranges and exit VM") \ 278232785Speter \ 278332785Speter diagnostic(bool, SerializeVMOutput, true, \ 278432785Speter "Use a mutex to serialize output to tty and LogFile") \ 278532785Speter \ 278632785Speter diagnostic(bool, DisplayVMOutput, true, \ 278732785Speter "Display all VM output on the tty, independently of LogVMOutput") \ 278832785Speter \ 278932785Speter diagnostic(bool, LogVMOutput, false, \ 279032785Speter "Save VM output to LogFile") \ 279132785Speter \ 279232785Speter diagnostic(ccstr, LogFile, NULL, \ 279332785Speter "If LogVMOutput or LogCompilation is on, save VM output to " \ 279432785Speter "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)")\ 279532785Speter \ 279632785Speter product(ccstr, ErrorFile, NULL, \ 279732785Speter "If an error occurs, save the error data to this file " \ 279832785Speter "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \ 279932785Speter \ 280032785Speter product(bool, DisplayVMOutputToStderr, false, \ 280132785Speter "If DisplayVMOutput is true, display all VM output to stderr") \ 280232785Speter \ 280332785Speter product(bool, DisplayVMOutputToStdout, false, \ 280432785Speter "If DisplayVMOutput is true, display all VM output to stdout") \ 280532785Speter \ 280632785Speter product(bool, UseHeavyMonitors, false, \ 280732785Speter "use heavyweight instead of lightweight Java monitors") \ 280832785Speter \ 280932785Speter product(bool, PrintStringTableStatistics, false, \ 281032785Speter "print statistics about the StringTable and SymbolTable") \ 281132785Speter \ 281232785Speter diagnostic(bool, VerifyStringTableAtExit, false, \ 281332785Speter "verify StringTable contents at exit") \ 281432785Speter \ 281532785Speter notproduct(bool, PrintSymbolTableSizeHistogram, false, \ 281632785Speter "print histogram of the symbol table") \ 281732785Speter \ 281832785Speter notproduct(bool, ExitVMOnVerifyError, false, \ 281932785Speter "standard exit from VM if bytecode verify error " \ 282032785Speter "(only in debug mode)") \ 282132785Speter \ 282232785Speter notproduct(ccstr, AbortVMOnException, NULL, \ 282332785Speter "Call fatal if this exception is thrown. Example: " \ 282432785Speter "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \ 282532785Speter \ 282632785Speter notproduct(ccstr, AbortVMOnExceptionMessage, NULL, \ 282732785Speter "Call fatal if the exception pointed by AbortVMOnException " \ 282832785Speter "has this message") \ 282932785Speter \ 283032785Speter develop(bool, DebugVtables, false, \ 283132785Speter "add debugging code to vtable dispatch") \ 283232785Speter \ 283332785Speter develop(bool, PrintVtables, false, \ 283432785Speter "print vtables when printing klass") \ 283532785Speter \ 283632785Speter notproduct(bool, PrintVtableStats, false, \ 283732785Speter "print vtables stats at end of run") \ 283832785Speter \ 283932785Speter develop(bool, TraceCreateZombies, false, \ 284032785Speter "trace creation of zombie nmethods") \ 284132785Speter \ 284232785Speter notproduct(bool, IgnoreLockingAssertions, false, \ 284332785Speter "disable locking assertions (for speed)") \ 284432785Speter \ 284532785Speter product(bool, RangeCheckElimination, true, \ 284632785Speter "Eliminate range checks") \ 284732785Speter \ 284832785Speter develop_pd(bool, UncommonNullCast, \ 284932785Speter "track occurrences of null in casts; adjust compiler tactics") \ 285032785Speter \ 285132785Speter develop(bool, TypeProfileCasts, true, \ 285232785Speter "treat casts like calls for purposes of type profiling") \ 285332785Speter \ 285432785Speter develop(bool, DelayCompilationDuringStartup, true, \ 285532785Speter "Delay invoking the compiler until main application class is " \ 285632785Speter "loaded") \ 285732785Speter \ 285832785Speter develop(bool, CompileTheWorld, false, \ 285932785Speter "Compile all methods in all classes in bootstrap class path " \ 286032785Speter "(stress test)") \ 286132785Speter \ 286232785Speter develop(bool, CompileTheWorldPreloadClasses, true, \ 286332785Speter "Preload all classes used by a class before start loading") \ 286432785Speter \ 286532785Speter notproduct(intx, CompileTheWorldSafepointInterval, 100, \ 286632785Speter "Force a safepoint every n compiles so sweeper can keep up") \ 286732785Speter \ 286832785Speter develop(bool, FillDelaySlots, true, \ 286932785Speter "Fill delay slots (on SPARC only)") \ 287032785Speter \ 287132785Speter develop(bool, TimeLivenessAnalysis, false, \ 287232785Speter "Time computation of bytecode liveness analysis") \ 287332785Speter \ 287432785Speter develop(bool, TraceLivenessGen, false, \ 287532785Speter "Trace the generation of liveness analysis information") \ 287632785Speter \ 287732785Speter notproduct(bool, TraceLivenessQuery, false, \ 287832785Speter "Trace queries of liveness analysis information") \ 287932785Speter \ 288032785Speter notproduct(bool, CollectIndexSetStatistics, false, \ 288132785Speter "Collect information about IndexSets") \ 288232785Speter \ 288332785Speter develop(bool, UseLoopSafepoints, true, \ 288432785Speter "Generate Safepoint nodes in every loop") \ 288532785Speter \ 288632785Speter develop(intx, FastAllocateSizeLimit, 128*K, \ 288732785Speter /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ \ 288832785Speter "Inline allocations larger than this in doublewords must go slow")\ 288932785Speter \ 289032785Speter product(bool, AggressiveOpts, false, \ 289132785Speter "Enable aggressive optimizations - see arguments.cpp") \ 289232785Speter \ 289332785Speter product_pd(uintx, TypeProfileLevel, \ 289432785Speter "=XYZ, with Z: Type profiling of arguments at call; " \ 289532785Speter "Y: Type profiling of return value at call; " \ 289632785Speter "X: Type profiling of parameters to methods; " \ 289732785Speter "X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods") \ 289832785Speter \ 289932785Speter product(intx, TypeProfileArgsLimit, 2, \ 290032785Speter "max number of call arguments to consider for type profiling") \ 290132785Speter \ 290232785Speter product(intx, TypeProfileParmsLimit, 2, \ 290332785Speter "max number of incoming parameters to consider for type profiling"\ 290432785Speter ", -1 for all") \ 290532785Speter \ 290632785Speter /* statistics */ \ 290732785Speter develop(bool, CountCompiledCalls, false, \ 290832785Speter "Count method invocations") \ 290932785Speter \ 291032785Speter notproduct(bool, CountRuntimeCalls, false, \ 291132785Speter "Count VM runtime calls") \ 291232785Speter \ 291332785Speter develop(bool, CountJNICalls, false, \ 291432785Speter "Count jni method invocations") \ 291532785Speter \ 291632785Speter notproduct(bool, CountJVMCalls, false, \ 291732785Speter "Count jvm method invocations") \ 291832785Speter \ 291932785Speter notproduct(bool, CountRemovableExceptions, false, \ 292032785Speter "Count exceptions that could be replaced by branches due to " \ 292132785Speter "inlining") \ 292232785Speter \ 292332785Speter notproduct(bool, ICMissHistogram, false, \ 292432785Speter "Produce histogram of IC misses") \ 292532785Speter \ 292632785Speter notproduct(bool, PrintClassStatistics, false, \ 292732785Speter "Print class statistics at end of run") \ 292832785Speter \ 292932785Speter notproduct(bool, PrintMethodStatistics, false, \ 293032785Speter "Print method statistics at end of run") \ 293132785Speter \ 293232785Speter /* interpreter */ \ 293332785Speter develop(bool, ClearInterpreterLocals, false, \ 293432785Speter "Always clear local variables of interpreter activations upon " \ 293532785Speter "entry") \ 293632785Speter \ 293732785Speter product_pd(bool, RewriteBytecodes, \ 293832785Speter "Allow rewriting of bytecodes (bytecodes are not immutable)") \ 293932785Speter \ 294032785Speter product_pd(bool, RewriteFrequentPairs, \ 294132785Speter "Rewrite frequently used bytecode pairs into a single bytecode") \ 294232785Speter \ 294332785Speter diagnostic(bool, PrintInterpreter, false, \ 294432785Speter "Print the generated interpreter code") \ 294532785Speter \ 294632785Speter product(bool, UseInterpreter, true, \ 294732785Speter "Use interpreter for non-compiled methods") \ 294832785Speter \ 294932785Speter develop(bool, UseFastSignatureHandlers, true, \ 295032785Speter "Use fast signature handlers for native calls") \ 295132785Speter \ 295232785Speter product(bool, UseLoopCounter, true, \ 295332785Speter "Increment invocation counter on backward branch") \ 295432785Speter \ 295532785Speter product_pd(bool, UseOnStackReplacement, \ 295632785Speter "Use on stack replacement, calls runtime if invoc. counter " \ 295732785Speter "overflows in loop") \ 295832785Speter \ 295932785Speter notproduct(bool, TraceOnStackReplacement, false, \ 296032785Speter "Trace on stack replacement") \ 296132785Speter \ 296232785Speter product_pd(bool, PreferInterpreterNativeStubs, \ 296332785Speter "Use always interpreter stubs for native methods invoked via " \ 296432785Speter "interpreter") \ 296532785Speter \ 296632785Speter develop(bool, CountBytecodes, false, \ 296732785Speter "Count number of bytecodes executed") \ 296832785Speter \ 296932785Speter develop(bool, PrintBytecodeHistogram, false, \ 297032785Speter "Print histogram of the executed bytecodes") \ 297132785Speter \ 297232785Speter develop(bool, PrintBytecodePairHistogram, false, \ 297332785Speter "Print histogram of the executed bytecode pairs") \ 297432785Speter \ 297532785Speter diagnostic(bool, PrintSignatureHandlers, false, \ 297632785Speter "Print code generated for native method signature handlers") \ 297732785Speter \ 297832785Speter develop(bool, VerifyOops, false, \ 297932785Speter "Do plausibility checks for oops") \ 298032785Speter \ 298132785Speter develop(bool, CheckUnhandledOops, false, \ 298232785Speter "Check for unhandled oops in VM code") \ 298332785Speter \ 298432785Speter develop(bool, VerifyJNIFields, trueInDebug, \ 298532785Speter "Verify jfieldIDs for instance fields") \ 298632785Speter \ 298732785Speter notproduct(bool, VerifyJNIEnvThread, false, \ 298832785Speter "Verify JNIEnv.thread == Thread::current() when entering VM " \ 298932785Speter "from JNI") \ 299032785Speter \ 299132785Speter develop(bool, VerifyFPU, false, \ 299232785Speter "Verify FPU state (check for NaN's, etc.)") \ 299332785Speter \ 299432785Speter develop(bool, VerifyThread, false, \ 299532785Speter "Watch the thread register for corruption (SPARC only)") \ 299632785Speter \ 299732785Speter develop(bool, VerifyActivationFrameSize, false, \ 299832785Speter "Verify that activation frame didn't become smaller than its " \ 299932785Speter "minimal size") \ 300032785Speter \ 300132785Speter develop(bool, TraceFrequencyInlining, false, \ 300232785Speter "Trace frequency based inlining") \ 300332785Speter \ 300432785Speter develop_pd(bool, InlineIntrinsics, \ 300532785Speter "Inline intrinsics that can be statically resolved") \ 300632785Speter \ 300732785Speter product_pd(bool, ProfileInterpreter, \ 300832785Speter "Profile at the bytecode level during interpretation") \ 300932785Speter \ 301032785Speter develop(bool, TraceProfileInterpreter, false, \ 301132785Speter "Trace profiling at the bytecode level during interpretation. " \ 301232785Speter "This outputs the profiling information collected to improve " \ 301332785Speter "jit compilation.") \ 301432785Speter \ 301532785Speter develop_pd(bool, ProfileTraps, \ 301632785Speter "Profile deoptimization traps at the bytecode level") \ 301732785Speter \ 301832785Speter product(intx, ProfileMaturityPercentage, 20, \ 301932785Speter "number of method invocations/branches (expressed as % of " \ 302032785Speter "CompileThreshold) before using the method's profile") \ 302132785Speter range(0, 100) \ 302232785Speter \ 302332785Speter diagnostic(bool, PrintMethodData, false, \ 302432785Speter "Print the results of +ProfileInterpreter at end of run") \ 302532785Speter \ 302632785Speter develop(bool, VerifyDataPointer, trueInDebug, \ 302732785Speter "Verify the method data pointer during interpreter profiling") \ 302832785Speter \ 302932785Speter develop(bool, VerifyCompiledCode, false, \ 303032785Speter "Include miscellaneous runtime verifications in nmethod code; " \ 303132785Speter "default off because it disturbs nmethod size heuristics") \ 303232785Speter \ 303332785Speter notproduct(bool, CrashGCForDumpingJavaThread, false, \ 303432785Speter "Manually make GC thread crash then dump java stack trace; " \ 303532785Speter "Test only") \ 303632785Speter \ 303732785Speter /* compilation */ \ 303832785Speter product(bool, UseCompiler, true, \ 303932785Speter "Use Just-In-Time compilation") \ 304032785Speter \ 304132785Speter develop(bool, TraceCompilationPolicy, false, \ 304232785Speter "Trace compilation policy") \ 304332785Speter \ 304432785Speter develop(bool, TimeCompilationPolicy, false, \ 304532785Speter "Time the compilation policy") \ 304632785Speter \ 304732785Speter product(bool, UseCounterDecay, true, \ 304832785Speter "Adjust recompilation counters") \ 304932785Speter \ 305032785Speter develop(intx, CounterHalfLifeTime, 30, \ 305132785Speter "Half-life time of invocation counters (in seconds)") \ 305232785Speter \ 305332785Speter develop(intx, CounterDecayMinIntervalLength, 500, \ 305432785Speter "The minimum interval (in milliseconds) between invocation of " \ 305532785Speter "CounterDecay") \ 305632785Speter \ 305732785Speter product(bool, AlwaysCompileLoopMethods, false, \ 305832785Speter "When using recompilation, never interpret methods " \ 305932785Speter "containing loops") \ 306032785Speter \ 306132785Speter product(bool, DontCompileHugeMethods, true, \ 306232785Speter "Do not compile methods > HugeMethodLimit") \ 306332785Speter \ 306432785Speter /* Bytecode escape analysis estimation. */ \ 306532785Speter product(bool, EstimateArgEscape, true, \ 306632785Speter "Analyze bytecodes to estimate escape state of arguments") \ 306732785Speter \ 306832785Speter product(intx, BCEATraceLevel, 0, \ 306932785Speter "How much tracing to do of bytecode escape analysis estimates") \ 307032785Speter \ 307132785Speter product(intx, MaxBCEAEstimateLevel, 5, \ 307232785Speter "Maximum number of nested calls that are analyzed by BC EA") \ 307332785Speter \ 307432785Speter product(intx, MaxBCEAEstimateSize, 150, \ 307532785Speter "Maximum bytecode size of a method to be analyzed by BC EA") \ 307632785Speter \ 307732785Speter product(intx, AllocatePrefetchStyle, 1, \ 307832785Speter "0 = no prefetch, " \ 307932785Speter "1 = prefetch instructions for each allocation, " \ 308032785Speter "2 = use TLAB watermark to gate allocation prefetch, " \ 308132785Speter "3 = use BIS instruction on Sparc for allocation prefetch") \ 308232785Speter range(0, 3) \ 308332785Speter \ 308432785Speter product(intx, AllocatePrefetchDistance, -1, \ 308532785Speter "Distance to prefetch ahead of allocation pointer") \ 308632785Speter \ 308732785Speter product(intx, AllocatePrefetchLines, 3, \ 308832785Speter "Number of lines to prefetch ahead of array allocation pointer") \ 308932785Speter \ 309032785Speter product(intx, AllocateInstancePrefetchLines, 1, \ 309132785Speter "Number of lines to prefetch ahead of instance allocation " \ 309232785Speter "pointer") \ 309332785Speter \ 309432785Speter product(intx, AllocatePrefetchStepSize, 16, \ 309532785Speter "Step size in bytes of sequential prefetch instructions") \ 309632785Speter \ 309732785Speter product(intx, AllocatePrefetchInstr, 0, \ 309832785Speter "Prefetch instruction to prefetch ahead of allocation pointer") \ 309932785Speter \ 310032785Speter /* deoptimization */ \ 310132785Speter develop(bool, TraceDeoptimization, false, \ 310232785Speter "Trace deoptimization") \ 310332785Speter \ 310432785Speter develop(bool, DebugDeoptimization, false, \ 310532785Speter "Tracing various information while debugging deoptimization") \ 310632785Speter \ 310732785Speter product(intx, SelfDestructTimer, 0, \ 310832785Speter "Will cause VM to terminate after a given time (in minutes) " \ 310932785Speter "(0 means off)") \ 311032785Speter \ 311132785Speter product(intx, MaxJavaStackTraceDepth, 1024, \ 311232785Speter "The maximum number of lines in the stack trace for Java " \ 311332785Speter "exceptions (0 means all)") \ 311432785Speter \ 311532785Speter NOT_EMBEDDED(diagnostic(intx, GuaranteedSafepointInterval, 1000, \ 311632785Speter "Guarantee a safepoint (at least) every so many milliseconds " \ 311732785Speter "(0 means none)")) \ 311832785Speter \ 311932785Speter EMBEDDED_ONLY(product(intx, GuaranteedSafepointInterval, 0, \ 312032785Speter "Guarantee a safepoint (at least) every so many milliseconds " \ 312132785Speter "(0 means none)")) \ 312232785Speter \ 312332785Speter product(intx, SafepointTimeoutDelay, 10000, \ 312432785Speter "Delay in milliseconds for option SafepointTimeout") \ 312532785Speter \ 312632785Speter product(intx, NmethodSweepActivity, 10, \ 312732785Speter "Removes cold nmethods from code cache if > 0. Higher values " \ 312832785Speter "result in more aggressive sweeping") \ 312932785Speter range(0, 2000) \ 313032785Speter \ 313132785Speter notproduct(bool, LogSweeper, false, \ 313232785Speter "Keep a ring buffer of sweeper activity") \ 313332785Speter \ 313432785Speter notproduct(intx, SweeperLogEntries, 1024, \ 313532785Speter "Number of records in the ring buffer of sweeper activity") \ 313632785Speter \ 313732785Speter notproduct(intx, MemProfilingInterval, 500, \ 313832785Speter "Time between each invocation of the MemProfiler") \ 313932785Speter \ 314032785Speter develop(intx, MallocCatchPtr, -1, \ 314132785Speter "Hit breakpoint when mallocing/freeing this pointer") \ 314232785Speter \ 314332785Speter notproduct(ccstrlist, SuppressErrorAt, "", \ 314432785Speter "List of assertions (file:line) to muzzle") \ 314532785Speter \ 314632785Speter notproduct(size_t, HandleAllocationLimit, 1024, \ 314732785Speter "Threshold for HandleMark allocation when +TraceHandleAllocation "\ 314832785Speter "is used") \ 314932785Speter \ 315032785Speter develop(size_t, TotalHandleAllocationLimit, 1024, \ 315132785Speter "Threshold for total handle allocation when " \ 315232785Speter "+TraceHandleAllocation is used") \ 315332785Speter \ 315432785Speter develop(intx, StackPrintLimit, 100, \ 315532785Speter "number of stack frames to print in VM-level stack dump") \ 315632785Speter \ 315732785Speter notproduct(intx, MaxElementPrintSize, 256, \ 315832785Speter "maximum number of elements to print") \ 315932785Speter \ 316032785Speter notproduct(intx, MaxSubklassPrintSize, 4, \ 316132785Speter "maximum number of subklasses to print when printing klass") \ 316232785Speter \ 316332785Speter product(intx, MaxInlineLevel, 9, \ 316432785Speter "maximum number of nested calls that are inlined") \ 316532785Speter \ 316632785Speter product(intx, MaxRecursiveInlineLevel, 1, \ 316732785Speter "maximum number of nested recursive calls that are inlined") \ 316832785Speter \ 316932785Speter develop(intx, MaxForceInlineLevel, 100, \ 317032785Speter "maximum number of nested calls that are forced for inlining " \ 317132785Speter "(using CompilerOracle or marked w/ @ForceInline)") \ 317232785Speter \ 317332785Speter product_pd(intx, InlineSmallCode, \ 317432785Speter "Only inline already compiled methods if their code size is " \ 317532785Speter "less than this") \ 317632785Speter \ 317732785Speter product(intx, MaxInlineSize, 35, \ 317832785Speter "The maximum bytecode size of a method to be inlined") \ 317932785Speter \ 318032785Speter product_pd(intx, FreqInlineSize, \ 318132785Speter "The maximum bytecode size of a frequent method to be inlined") \ 318232785Speter \ 318332785Speter product(intx, MaxTrivialSize, 6, \ 318432785Speter "The maximum bytecode size of a trivial method to be inlined") \ 318532785Speter \ 318632785Speter product(intx, MinInliningThreshold, 250, \ 318732785Speter "The minimum invocation count a method needs to have to be " \ 318832785Speter "inlined") \ 318932785Speter \ 319032785Speter develop(intx, MethodHistogramCutoff, 100, \ 319132785Speter "The cutoff value for method invocation histogram (+CountCalls)") \ 319232785Speter \ 319332785Speter develop(intx, ProfilerNumberOfInterpretedMethods, 25, \ 319432785Speter "Number of interpreted methods to show in profile") \ 319532785Speter \ 319632785Speter develop(intx, ProfilerNumberOfCompiledMethods, 25, \ 319732785Speter "Number of compiled methods to show in profile") \ 319832785Speter \ 319932785Speter develop(intx, ProfilerNumberOfStubMethods, 25, \ 320032785Speter "Number of stub methods to show in profile") \ 320132785Speter \ 320232785Speter develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \ 320332785Speter "Number of runtime stub nodes to show in profile") \ 320432785Speter \ 320532785Speter product(intx, ProfileIntervalsTicks, 100, \ 320632785Speter "Number of ticks between printing of interval profile " \ 320732785Speter "(+ProfileIntervals)") \ 320832785Speter \ 320932785Speter notproduct(intx, ScavengeALotInterval, 1, \ 321032785Speter "Interval between which scavenge will occur with +ScavengeALot") \ 321132785Speter \ 321232785Speter notproduct(intx, FullGCALotInterval, 1, \ 321332785Speter "Interval between which full gc will occur with +FullGCALot") \ 321432785Speter \ 321532785Speter notproduct(intx, FullGCALotStart, 0, \ 321632785Speter "For which invocation to start FullGCAlot") \ 321732785Speter \ 321832785Speter notproduct(intx, FullGCALotDummies, 32*K, \ 321932785Speter "Dummy object allocated with +FullGCALot, forcing all objects " \ 322032785Speter "to move") \ 322132785Speter \ 322232785Speter develop(intx, DontYieldALotInterval, 10, \ 322332785Speter "Interval between which yields will be dropped (milliseconds)") \ 322432785Speter \ 322532785Speter develop(intx, MinSleepInterval, 1, \ 322632785Speter "Minimum sleep() interval (milliseconds) when " \ 322732785Speter "ConvertSleepToYield is off (used for Solaris)") \ 322826801Speter \ 322926801Speter develop(intx, ProfilerPCTickThreshold, 15, \ 323026801Speter "Number of ticks in a PC buckets to be a hotspot") \ 323126801Speter \ 323226801Speter notproduct(intx, DeoptimizeALotInterval, 5, \ 323326801Speter "Number of exits until DeoptimizeALot kicks in") \ 323426801Speter \ 323526801Speter notproduct(intx, ZombieALotInterval, 5, \ 323626801Speter "Number of exits until ZombieALot kicks in") \ 323726801Speter \ 323826801Speter diagnostic(intx, MallocVerifyInterval, 0, \ 323926801Speter "If non-zero, verify C heap after every N calls to " \ 324026801Speter "malloc/realloc/free") \ 324126801Speter \ 324226801Speter diagnostic(intx, MallocVerifyStart, 0, \ 324326801Speter "If non-zero, start verifying C heap after Nth call to " \ 324426801Speter "malloc/realloc/free") \ 324526801Speter \ 324626801Speter diagnostic(uintx, MallocMaxTestWords, 0, \ 324726801Speter "If non-zero, maximum number of words that malloc/realloc can " \ 324826801Speter "allocate (for testing only)") \ 324926065Speter \ 325026065Speter product(intx, TypeProfileWidth, 2, \ 325126065Speter "Number of receiver types to record in call/cast profile") \ 325226065Speter \ 325326065Speter develop(intx, BciProfileWidth, 2, \ 325426065Speter "Number of return bci's to record in ret profile") \ 325526065Speter \ 325626065Speter product(intx, PerMethodRecompilationCutoff, 400, \ 325725839Speter "After recompiling N times, stay in the interpreter (-1=>'Inf')") \ 325825839Speter range(-1, max_intx) \ 325925839Speter \ 326025839Speter product(intx, PerBytecodeRecompilationCutoff, 200, \ 326125839Speter "Per-BCI limit on repeated recompilation (-1=>'Inf')") \ 326225839Speter range(-1, max_intx) \ 326325839Speter \ 326425839Speter product(intx, PerMethodTrapLimit, 100, \ 326525839Speter "Limit on traps (of one kind) in a method (includes inlines)") \ 326625839Speter \ 326725839Speter experimental(intx, PerMethodSpecTrapLimit, 5000, \ 326825839Speter "Limit on speculative traps (of one kind) in a method " \ 326925839Speter "(includes inlines)") \ 327025839Speter \ 327125839Speter product(intx, PerBytecodeTrapLimit, 4, \ 327225839Speter "Limit on traps (of one kind) at a particular BCI") \ 327325839Speter \ 327425839Speter experimental(intx, SpecTrapLimitExtraEntries, 3, \ 327525839Speter "Extra method data trap entries for speculation") \ 327625839Speter \ 327725839Speter develop(intx, InlineFrequencyRatio, 20, \ 327825839Speter "Ratio of call site execution to caller method invocation") \ 327925839Speter \ 328025839Speter develop_pd(intx, InlineFrequencyCount, \ 328125839Speter "Count of call site execution necessary to trigger frequent " \ 328225839Speter "inlining") \ 328325839Speter \ 328425839Speter develop(intx, InlineThrowCount, 50, \ 328525839Speter "Force inlining of interpreted methods that throw this often") \ 328625839Speter \ 328725839Speter develop(intx, InlineThrowMaxSize, 200, \ 328825839Speter "Force inlining of throwing methods smaller than this") \ 328925839Speter \ 329025839Speter develop(intx, ProfilerNodeSize, 1024, \ 329125839Speter "Size in K to allocate for the Profile Nodes of each thread") \ 329225839Speter \ 329325839Speter /* gc parameters */ \ 329425839Speter product(size_t, InitialHeapSize, 0, \ 329525839Speter "Initial heap size (in bytes); zero means use ergonomics") \ 329625839Speter \ 329725839Speter product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \ 329825839Speter "Maximum heap size (in bytes)") \ 329925839Speter \ 330025839Speter product(size_t, OldSize, ScaleForWordSize(4*M), \ 330125839Speter "Initial tenured generation size (in bytes)") \ 330225839Speter \ 330325839Speter product(size_t, NewSize, ScaleForWordSize(1*M), \ 330425839Speter "Initial new generation size (in bytes)") \ 330525839Speter \ 330625839Speter product(size_t, MaxNewSize, max_uintx, \ 330725839Speter "Maximum new generation size (in bytes), max_uintx means set " \ 330825839Speter "ergonomically") \ 330925839Speter \ 331025839Speter product(size_t, PretenureSizeThreshold, 0, \ 331125839Speter "Maximum size in bytes of objects allocated in DefNew " \ 331225839Speter "generation; zero means no maximum") \ 331325839Speter \ 331425839Speter product(size_t, TLABSize, 0, \ 331525839Speter "Starting TLAB size (in bytes); zero means set ergonomically") \ 331625839Speter \ 331725839Speter product(size_t, MinTLABSize, 2*K, \ 331825839Speter "Minimum allowed TLAB size (in bytes)") \ 331925839Speter range(1, max_uintx) \ 332025839Speter \ 332125839Speter product(uintx, TLABAllocationWeight, 35, \ 332225839Speter "Allocation averaging weight") \ 332325839Speter range(0, 100) \ 332425839Speter \ 332525839Speter /* Limit the lower bound of this flag to 1 as it is used */ \ 332625839Speter /* in a division expression. */ \ 332725839Speter product(uintx, TLABWasteTargetPercent, 1, \ 332825839Speter "Percentage of Eden that can be wasted") \ 332925839Speter range(1, 100) \ 333025839Speter \ 333125839Speter product(uintx, TLABRefillWasteFraction, 64, \ 333225839Speter "Maximum TLAB waste at a refill (internal fragmentation)") \ 333325839Speter range(1, max_uintx) \ 333425839Speter \ 333525839Speter product(uintx, TLABWasteIncrement, 4, \ 333625839Speter "Increment allowed waste at slow allocation") \ 333725839Speter \ 333825839Speter product(uintx, SurvivorRatio, 8, \ 333925839Speter "Ratio of eden/survivor space size") \ 334025839Speter \ 334125839Speter product(uintx, NewRatio, 2, \ 334225839Speter "Ratio of old/new generation sizes") \ 334325839Speter \ 334425839Speter product_pd(size_t, NewSizeThreadIncrease, \ 334525839Speter "Additional size added to desired new generation size per " \ 334625839Speter "non-daemon thread (in bytes)") \ 334725839Speter \ 334825839Speter product_pd(size_t, MetaspaceSize, \ 334925839Speter "Initial size of Metaspaces (in bytes)") \ 335025839Speter \ 335125839Speter product(size_t, MaxMetaspaceSize, max_uintx, \ 335225839Speter "Maximum size of Metaspaces (in bytes)") \ 335325839Speter \ 335425839Speter product(size_t, CompressedClassSpaceSize, 1*G, \ 335525839Speter "Maximum size of class area in Metaspace when compressed " \ 335625839Speter "class pointers are used") \ 335725839Speter range(1*M, 3*G) \ 335825839Speter \ 335925839Speter manageable(uintx, MinHeapFreeRatio, 40, \ 336025839Speter "The minimum percentage of heap free after GC to avoid expansion."\ 336125839Speter " For most GCs this applies to the old generation. In G1 and" \ 336225839Speter " ParallelGC it applies to the whole heap.") \ 336325839Speter range(0, 100) \ 336425839Speter constraint(MinHeapFreeRatioConstraintFunc) \ 336525839Speter \ 336625839Speter manageable(uintx, MaxHeapFreeRatio, 70, \ 336725839Speter "The maximum percentage of heap free after GC to avoid shrinking."\ 336825839Speter " For most GCs this applies to the old generation. In G1 and" \ 336925839Speter " ParallelGC it applies to the whole heap.") \ 337025839Speter range(0, 100) \ 337125839Speter constraint(MaxHeapFreeRatioConstraintFunc) \ 337225839Speter \ 337325839Speter product(intx, SoftRefLRUPolicyMSPerMB, 1000, \ 337425839Speter "Number of milliseconds per MB of free space in the heap") \ 337525839Speter \ 337625839Speter product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \ 337725839Speter "The minimum change in heap space due to GC (in bytes)") \ 337825839Speter \ 337925839Speter product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \ 338025839Speter "The minimum expansion of Metaspace (in bytes)") \ 338125839Speter \ 338225839Speter product(uintx, MaxMetaspaceFreeRatio, 70, \ 338325839Speter "The maximum percentage of Metaspace free after GC to avoid " \ 338425839Speter "shrinking") \ 338525839Speter range(0, 100) \ 338625839Speter constraint(MaxMetaspaceFreeRatioConstraintFunc) \ 338725839Speter \ 338825839Speter product(uintx, MinMetaspaceFreeRatio, 40, \ 338925839Speter "The minimum percentage of Metaspace free after GC to avoid " \ 339025839Speter "expansion") \ 339125839Speter range(0, 99) \ 339225839Speter constraint(MinMetaspaceFreeRatioConstraintFunc) \ 339325839Speter \ 339425839Speter product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \ 339525839Speter "The maximum expansion of Metaspace without full GC (in bytes)") \ 339625839Speter \ 339725839Speter product(uintx, QueuedAllocationWarningCount, 0, \ 339825839Speter "Number of times an allocation that queues behind a GC " \ 339925839Speter "will retry before printing a warning") \ 340025839Speter \ 340125839Speter diagnostic(uintx, VerifyGCStartAt, 0, \ 340225839Speter "GC invoke count where +VerifyBefore/AfterGC kicks in") \ 340325839Speter \ 340425839Speter diagnostic(intx, VerifyGCLevel, 0, \ 340525839Speter "Generation level at which to start +VerifyBefore/AfterGC") \ 340625839Speter \ 340725839Speter product(uintx, MaxTenuringThreshold, 15, \ 340825839Speter "Maximum value for tenuring threshold") \ 340925839Speter range(0, markOopDesc::max_age + 1) \ 341025839Speter constraint(MaxTenuringThresholdConstraintFunc) \ 341125839Speter \ 341225839Speter product(uintx, InitialTenuringThreshold, 7, \ 341325839Speter "Initial value for tenuring threshold") \ 341425839Speter range(0, markOopDesc::max_age + 1) \ 341525839Speter constraint(InitialTenuringThresholdConstraintFunc) \ 341625839Speter \ 341725839Speter product(uintx, TargetSurvivorRatio, 50, \ 341825839Speter "Desired percentage of survivor space used after scavenge") \ 341925839Speter range(0, 100) \ 342025839Speter \ 342125839Speter product(uintx, MarkSweepDeadRatio, 5, \ 342225839Speter "Percentage (0-100) of the old gen allowed as dead wood. " \ 342325839Speter "Serial mark sweep treats this as both the minimum and maximum " \ 342425839Speter "value. " \ 342525839Speter "CMS uses this value only if it falls back to mark sweep. " \ 342625839Speter "Par compact uses a variable scale based on the density of the " \ 342725839Speter "generation and treats this as the maximum value when the heap " \ 342825839Speter "is either completely full or completely empty. Par compact " \ 342925839Speter "also has a smaller default value; see arguments.cpp.") \ 343025839Speter range(0, 100) \ 343125839Speter \ 343225839Speter product(uintx, MarkSweepAlwaysCompactCount, 4, \ 343325839Speter "How often should we fully compact the heap (ignoring the dead " \ 343425839Speter "space parameters)") \ 343525839Speter range(1, max_uintx) \ 343625839Speter \ 343725839Speter product(intx, PrintCMSStatistics, 0, \ 343825839Speter "Statistics for CMS") \ 343925839Speter \ 344025839Speter product(bool, PrintCMSInitiationStatistics, false, \ 344125839Speter "Statistics for initiating a CMS collection") \ 344225839Speter \ 344325839Speter product(intx, PrintFLSStatistics, 0, \ 344425839Speter "Statistics for CMS' FreeListSpace") \ 344525839Speter \ 344625839Speter product(intx, PrintFLSCensus, 0, \ 344725839Speter "Census for CMS' FreeListSpace") \ 344825839Speter \ 344925839Speter develop(uintx, GCExpandToAllocateDelayMillis, 0, \ 345025839Speter "Delay between expansion and allocation (in milliseconds)") \ 345125839Speter \ 345225839Speter develop(uintx, GCWorkerDelayMillis, 0, \ 345325839Speter "Delay in scheduling GC workers (in milliseconds)") \ 345425839Speter \ 345525839Speter product(intx, DeferThrSuspendLoopCount, 4000, \ 345625839Speter "(Unstable) Number of times to iterate in safepoint loop " \ 345725839Speter "before blocking VM threads ") \ 345825839Speter \ 345925839Speter product(intx, DeferPollingPageLoopCount, -1, \ 346025839Speter "(Unsafe,Unstable) Number of iterations in safepoint loop " \ 346125839Speter "before changing safepoint polling page to RO ") \ 346225839Speter \ 346325839Speter product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \ 346425839Speter \ 346525839Speter product(bool, PSChunkLargeArrays, true, \ 346625839Speter "Process large arrays in chunks") \ 346725839Speter \ 346825839Speter product(uintx, GCDrainStackTargetSize, 64, \ 346925839Speter "Number of entries we will try to leave on the stack " \ 347025839Speter "during parallel gc") \ 347125839Speter \ 347225839Speter /* stack parameters */ \ 347325839Speter product_pd(intx, StackYellowPages, \ 347425839Speter "Number of yellow zone (recoverable overflows) pages") \ 347525839Speter range(1, max_intx) \ 347625839Speter \ 347725839Speter product_pd(intx, StackRedPages, \ 347825839Speter "Number of red zone (unrecoverable overflows) pages") \ 347925839Speter range(1, max_intx) \ 348025839Speter \ 348125839Speter /* greater stack shadow pages can't generate instruction to bang stack */ \ 348225839Speter product_pd(intx, StackShadowPages, \ 348325839Speter "Number of shadow zone (for overflow checking) pages " \ 348425839Speter "this should exceed the depth of the VM and native call stack") \ 348525839Speter range(1, 50) \ 348625839Speter \ 348725839Speter product_pd(intx, ThreadStackSize, \ 348825839Speter "Thread Stack Size (in Kbytes)") \ 348925839Speter \ 349025839Speter product_pd(intx, VMThreadStackSize, \ 349125839Speter "Non-Java Thread Stack Size (in Kbytes)") \ 349225839Speter \ 349325839Speter product_pd(intx, CompilerThreadStackSize, \ 349425839Speter "Compiler Thread Stack Size (in Kbytes)") \ 349525839Speter \ 349625839Speter develop_pd(size_t, JVMInvokeMethodSlack, \ 349725839Speter "Stack space (bytes) required for JVM_InvokeMethod to complete") \ 349825839Speter \ 349925839Speter /* code cache parameters */ \ 350025839Speter /* ppc64/tiered compilation has large code-entry alignment. */ \ 350125839Speter develop(uintx, CodeCacheSegmentSize, 64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),\ 350225839Speter "Code cache segment size (in bytes) - smallest unit of " \ 350325839Speter "allocation") \ 350425839Speter range(1, 1024) \ 350525839Speter \ 350625839Speter develop_pd(intx, CodeEntryAlignment, \ 350725839Speter "Code entry alignment for generated code (in bytes)") \ 350825839Speter \ 350925839Speter product_pd(intx, OptoLoopAlignment, \ 351025839Speter "Align inner loops to zero relative to this modulus") \ 351125839Speter \ 351225839Speter product_pd(uintx, InitialCodeCacheSize, \ 351325839Speter "Initial code cache size (in bytes)") \ 351425839Speter \ 351525839Speter develop_pd(uintx, CodeCacheMinimumUseSpace, \ 351625839Speter "Minimum code cache size (in bytes) required to start VM.") \ 351725839Speter \ 351825839Speter product(bool, SegmentedCodeCache, false, \ 351925839Speter "Use a segmented code cache") \ 352025839Speter \ 352125839Speter product_pd(uintx, ReservedCodeCacheSize, \ 352225839Speter "Reserved code cache size (in bytes) - maximum code cache size") \ 352325839Speter \ 352425839Speter product_pd(uintx, NonProfiledCodeHeapSize, \ 352525839Speter "Size of code heap with non-profiled methods (in bytes)") \ 352625839Speter \ 352725839Speter product_pd(uintx, ProfiledCodeHeapSize, \ 352825839Speter "Size of code heap with profiled methods (in bytes)") \ 352925839Speter \ 353025839Speter product_pd(uintx, NonNMethodCodeHeapSize, \ 353125839Speter "Size of code heap with non-nmethods (in bytes)") \ 353225839Speter \ 353325839Speter product_pd(uintx, CodeCacheExpansionSize, \ 353425839Speter "Code cache expansion size (in bytes)") \ 353525839Speter \ 353625839Speter develop_pd(uintx, CodeCacheMinBlockLength, \ 353725839Speter "Minimum number of segments in a code cache block") \ 353825839Speter range(1, 100) \ 353925839Speter \ 354025839Speter notproduct(bool, ExitOnFullCodeCache, false, \ 354125839Speter "Exit the VM if we fill the code cache") \ 354225839Speter \ 354325839Speter product(bool, UseCodeCacheFlushing, true, \ 354425839Speter "Remove cold/old nmethods from the code cache") \ 354525839Speter \ 354625839Speter product(uintx, StartAggressiveSweepingAt, 10, \ 354725839Speter "Start aggressive sweeping if X[%] of the code cache is free." \ 354825839Speter "Segmented code cache: X[%] of the non-profiled heap." \ 354925839Speter "Non-segmented code cache: X[%] of the total code cache") \ 355025839Speter range(0, 100) \ 355125839Speter \ 355225839Speter /* interpreter debugging */ \ 355325839Speter develop(intx, BinarySwitchThreshold, 5, \ 355425839Speter "Minimal number of lookupswitch entries for rewriting to binary " \ 355525839Speter "switch") \ 355625839Speter \ 355725839Speter develop(intx, StopInterpreterAt, 0, \ 355825839Speter "Stop interpreter execution at specified bytecode number") \ 355925839Speter \ 356025839Speter develop(intx, TraceBytecodesAt, 0, \ 356125839Speter "Trace bytecodes starting with specified bytecode number") \ 356225839Speter \ 356325839Speter /* compiler interface */ \ 356425839Speter develop(intx, CIStart, 0, \ 356525839Speter "The id of the first compilation to permit") \ 356625839Speter \ 356725839Speter develop(intx, CIStop, max_jint, \ 356825839Speter "The id of the last compilation to permit") \ 356925839Speter \ 357025839Speter develop(intx, CIStartOSR, 0, \ 357125839Speter "The id of the first osr compilation to permit " \ 357225839Speter "(CICountOSR must be on)") \ 357325839Speter \ 357425839Speter develop(intx, CIStopOSR, max_jint, \ 357525839Speter "The id of the last osr compilation to permit " \ 357625839Speter "(CICountOSR must be on)") \ 357725839Speter \ 357825839Speter develop(intx, CIBreakAtOSR, -1, \ 357925839Speter "The id of osr compilation to break at") \ 358025839Speter \ 358125839Speter develop(intx, CIBreakAt, -1, \ 358225839Speter "The id of compilation to break at") \ 358325839Speter \ 358425839Speter product(ccstrlist, CompileOnly, "", \ 358525839Speter "List of methods (pkg/class.name) to restrict compilation to") \ 358625839Speter \ 358725839Speter product(ccstr, CompileCommandFile, NULL, \ 358825839Speter "Read compiler commands from this file [.hotspot_compiler]") \ 358925839Speter \ 359025839Speter product(ccstrlist, CompileCommand, "", \ 359125839Speter "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \ 359225839Speter \ 359325839Speter develop(bool, ReplayCompiles, false, \ 359425839Speter "Enable replay of compilations from ReplayDataFile") \ 359525839Speter \ 359625839Speter product(ccstr, ReplayDataFile, NULL, \ 359725839Speter "File containing compilation replay information" \ 359825839Speter "[default: ./replay_pid%p.log] (%p replaced with pid)") \ 359925839Speter \ 360025839Speter product(ccstr, InlineDataFile, NULL, \ 360125839Speter "File containing inlining replay information" \ 360225839Speter "[default: ./inline_pid%p.log] (%p replaced with pid)") \ 360325839Speter \ 360425839Speter develop(intx, ReplaySuppressInitializers, 2, \ 360525839Speter "Control handling of class initialization during replay: " \ 360625839Speter "0 - don't do anything special; " \ 360725839Speter "1 - treat all class initializers as empty; " \ 360825839Speter "2 - treat class initializers for application classes as empty; " \ 360925839Speter "3 - allow all class initializers to run during bootstrap but " \ 361025839Speter " pretend they are empty after starting replay") \ 361125839Speter range(0, 3) \ 361225839Speter \ 361325839Speter develop(bool, ReplayIgnoreInitErrors, false, \ 361425839Speter "Ignore exceptions thrown during initialization for replay") \ 361525839Speter \ 361625839Speter product(bool, DumpReplayDataOnError, true, \ 361725839Speter "Record replay data for crashing compiler threads") \ 361825839Speter \ 361925839Speter product(bool, CICompilerCountPerCPU, false, \ 362025839Speter "1 compiler thread for log(N CPUs)") \ 362125839Speter \ 362225839Speter develop(intx, CIFireOOMAt, -1, \ 362325839Speter "Fire OutOfMemoryErrors throughout CI for testing the compiler " \ 362425839Speter "(non-negative value throws OOM after this many CI accesses " \ 362525839Speter "in each compile)") \ 362625839Speter notproduct(intx, CICrashAt, -1, \ 362725839Speter "id of compilation to trigger assert in compiler thread for " \ 362825839Speter "the purpose of testing, e.g. generation of replay data") \ 362925839Speter notproduct(bool, CIObjectFactoryVerify, false, \ 363025839Speter "enable potentially expensive verification in ciObjectFactory") \ 363125839Speter \ 363225839Speter /* Priorities */ \ 363325839Speter product_pd(bool, UseThreadPriorities, "Use native thread priorities") \ 363425839Speter \ 363525839Speter product(intx, ThreadPriorityPolicy, 0, \ 363625839Speter "0 : Normal. "\ 363725839Speter " VM chooses priorities that are appropriate for normal "\ 363825839Speter " applications. On Solaris NORM_PRIORITY and above are mapped "\ 363925839Speter " to normal native priority. Java priorities below " \ 364025839Speter " NORM_PRIORITY map to lower native priority values. On "\ 364125839Speter " Windows applications are allowed to use higher native "\ 364225839Speter " priorities. However, with ThreadPriorityPolicy=0, VM will "\ 364325839Speter " not use the highest possible native priority, "\ 364425839Speter " THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with "\ 364525839Speter " system threads. On Linux thread priorities are ignored "\ 364625839Speter " because the OS does not support static priority in "\ 364725839Speter " SCHED_OTHER scheduling class which is the only choice for "\ 364825839Speter " non-root, non-realtime applications. "\ 364925839Speter "1 : Aggressive. "\ 365025839Speter " Java thread priorities map over to the entire range of "\ 365125839Speter " native thread priorities. Higher Java thread priorities map "\ 365225839Speter " to higher native thread priorities. This policy should be "\ 365325839Speter " used with care, as sometimes it can cause performance "\ 365425839Speter " degradation in the application and/or the entire system. On "\ 365525839Speter " Linux this policy requires root privilege.") \ 365625839Speter range(0, 1) \ 365725839Speter \ 365825839Speter product(bool, ThreadPriorityVerbose, false, \ 365925839Speter "Print priority changes") \ 366025839Speter \ 366125839Speter product(intx, CompilerThreadPriority, -1, \ 366225839Speter "The native priority at which compiler threads should run " \ 366325839Speter "(-1 means no change)") \ 366425839Speter \ 366525839Speter product(intx, VMThreadPriority, -1, \ 366625839Speter "The native priority at which the VM thread should run " \ 366725839Speter "(-1 means no change)") \ 366825839Speter \ 366925839Speter product(bool, CompilerThreadHintNoPreempt, true, \ 367025839Speter "(Solaris only) Give compiler threads an extra quanta") \ 367125839Speter \ 367225839Speter product(bool, VMThreadHintNoPreempt, false, \ 367325839Speter "(Solaris only) Give VM thread an extra quanta") \ 367425839Speter \ 367525839Speter product(intx, JavaPriority1_To_OSPriority, -1, \ 367625839Speter "Map Java priorities to OS priorities") \ 367725839Speter \ 367825839Speter product(intx, JavaPriority2_To_OSPriority, -1, \ 367925839Speter "Map Java priorities to OS priorities") \ 368025839Speter \ 368125839Speter product(intx, JavaPriority3_To_OSPriority, -1, \ 368225839Speter "Map Java priorities to OS priorities") \ 368325839Speter \ 368425839Speter product(intx, JavaPriority4_To_OSPriority, -1, \ 368525839Speter "Map Java priorities to OS priorities") \ 368625839Speter \ 368725839Speter product(intx, JavaPriority5_To_OSPriority, -1, \ 368825839Speter "Map Java priorities to OS priorities") \ 368925839Speter \ 369025839Speter product(intx, JavaPriority6_To_OSPriority, -1, \ 369125839Speter "Map Java priorities to OS priorities") \ 369225839Speter \ 369325839Speter product(intx, JavaPriority7_To_OSPriority, -1, \ 369425839Speter "Map Java priorities to OS priorities") \ 369525839Speter \ 369625839Speter product(intx, JavaPriority8_To_OSPriority, -1, \ 369725839Speter "Map Java priorities to OS priorities") \ 369825839Speter \ 369925839Speter product(intx, JavaPriority9_To_OSPriority, -1, \ 370025839Speter "Map Java priorities to OS priorities") \ 370125839Speter \ 370225839Speter product(intx, JavaPriority10_To_OSPriority,-1, \ 370325839Speter "Map Java priorities to OS priorities") \ 370425839Speter \ 370525839Speter experimental(bool, UseCriticalJavaThreadPriority, false, \ 370625839Speter "Java thread priority 10 maps to critical scheduling priority") \ 370725839Speter \ 370825839Speter experimental(bool, UseCriticalCompilerThreadPriority, false, \ 370925839Speter "Compiler thread(s) run at critical scheduling priority") \ 371025839Speter \ 371125839Speter experimental(bool, UseCriticalCMSThreadPriority, false, \ 371225839Speter "ConcurrentMarkSweep thread runs at critical scheduling priority")\ 371325839Speter \ 371425839Speter /* compiler debugging */ \ 371525839Speter notproduct(intx, CompileTheWorldStartAt, 1, \ 371625839Speter "First class to consider when using +CompileTheWorld") \ 371725839Speter \ 371825839Speter notproduct(intx, CompileTheWorldStopAt, max_jint, \ 371925839Speter "Last class to consider when using +CompileTheWorld") \ 372025839Speter \ 372125839Speter develop(intx, NewCodeParameter, 0, \ 372225839Speter "Testing Only: Create a dedicated integer parameter before " \ 372325839Speter "putback") \ 372425839Speter \ 372525839Speter /* new oopmap storage allocation */ \ 372625839Speter develop(intx, MinOopMapAllocation, 8, \ 372725839Speter "Minimum number of OopMap entries in an OopMapSet") \ 372825839Speter \ 372925839Speter /* Background Compilation */ \ 373025839Speter develop(intx, LongCompileThreshold, 50, \ 373125839Speter "Used with +TraceLongCompiles") \ 373225839Speter \ 373325839Speter /* recompilation */ \ 373425839Speter product_pd(intx, CompileThreshold, \ 373525839Speter "number of interpreted method invocations before (re-)compiling") \ 373625839Speter \ 373725839Speter product(double, CompileThresholdScaling, 1.0, \ 373825839Speter "Factor to control when first compilation happens " \ 373925839Speter "(both with and without tiered compilation): " \ 374025839Speter "values greater than 1.0 delay counter overflow, " \ 374125839Speter "values between 0 and 1.0 rush counter overflow, " \ 374225839Speter "value of 1.0 leaves compilation thresholds unchanged " \ 374325839Speter "value of 0.0 is equivalent to -Xint. " \ 374425839Speter "" \ 374525839Speter "Flag can be set as per-method option. " \ 374625839Speter "If a value is specified for a method, compilation thresholds " \ 374725839Speter "for that method are scaled by both the value of the global flag "\ 374825839Speter "and the value of the per-method flag.") \ 374925839Speter \ 375025839Speter product(intx, Tier0InvokeNotifyFreqLog, 7, \ 375125839Speter "Interpreter (tier 0) invocation notification frequency") \ 375225839Speter \ 375325839Speter product(intx, Tier2InvokeNotifyFreqLog, 11, \ 375425839Speter "C1 without MDO (tier 2) invocation notification frequency") \ 375525839Speter \ 375625839Speter product(intx, Tier3InvokeNotifyFreqLog, 10, \ 375725839Speter "C1 with MDO profiling (tier 3) invocation notification " \ 375825839Speter "frequency") \ 375925839Speter \ 376025839Speter product(intx, Tier23InlineeNotifyFreqLog, 20, \ 376125839Speter "Inlinee invocation (tiers 2 and 3) notification frequency") \ 376225839Speter \ 376325839Speter product(intx, Tier0BackedgeNotifyFreqLog, 10, \ 376425839Speter "Interpreter (tier 0) invocation notification frequency") \ 376525839Speter \ 376625839Speter product(intx, Tier2BackedgeNotifyFreqLog, 14, \ 376725839Speter "C1 without MDO (tier 2) invocation notification frequency") \ 376825839Speter \ 376925839Speter product(intx, Tier3BackedgeNotifyFreqLog, 13, \ 377025839Speter "C1 with MDO profiling (tier 3) invocation notification " \ 377125839Speter "frequency") \ 377225839Speter \ 377325839Speter product(intx, Tier2CompileThreshold, 0, \ 377425839Speter "threshold at which tier 2 compilation is invoked") \ 377525839Speter \ 377625839Speter product(intx, Tier2BackEdgeThreshold, 0, \ 377725839Speter "Back edge threshold at which tier 2 compilation is invoked") \ 377825839Speter \ 377925839Speter product(intx, Tier3InvocationThreshold, 200, \ 378025839Speter "Compile if number of method invocations crosses this " \ 378125839Speter "threshold") \ 378225839Speter \ 378325839Speter product(intx, Tier3MinInvocationThreshold, 100, \ 378425839Speter "Minimum invocation to compile at tier 3") \ 378525839Speter \ 378625839Speter product(intx, Tier3CompileThreshold, 2000, \ 378725839Speter "Threshold at which tier 3 compilation is invoked (invocation " \ 378825839Speter "minimum must be satisfied") \ 378925839Speter \ 379025839Speter product(intx, Tier3BackEdgeThreshold, 60000, \ 379125839Speter "Back edge threshold at which tier 3 OSR compilation is invoked") \ 379225839Speter \ 379325839Speter product(intx, Tier4InvocationThreshold, 5000, \ 379425839Speter "Compile if number of method invocations crosses this " \ 379525839Speter "threshold") \ 379625839Speter \ 379725839Speter product(intx, Tier4MinInvocationThreshold, 600, \ 379825839Speter "Minimum invocation to compile at tier 4") \ 379925839Speter \ 380025839Speter product(intx, Tier4CompileThreshold, 15000, \ 380125839Speter "Threshold at which tier 4 compilation is invoked (invocation " \ 380225839Speter "minimum must be satisfied") \ 380325839Speter \ 380425839Speter product(intx, Tier4BackEdgeThreshold, 40000, \ 380525839Speter "Back edge threshold at which tier 4 OSR compilation is invoked") \ 380625839Speter \ 380725839Speter product(intx, Tier3DelayOn, 5, \ 380825839Speter "If C2 queue size grows over this amount per compiler thread " \ 380925839Speter "stop compiling at tier 3 and start compiling at tier 2") \ 381025839Speter \ 381125839Speter product(intx, Tier3DelayOff, 2, \ 381225839Speter "If C2 queue size is less than this amount per compiler thread " \ 381325839Speter "allow methods compiled at tier 2 transition to tier 3") \ 381425839Speter \ 381525839Speter product(intx, Tier3LoadFeedback, 5, \ 381625839Speter "Tier 3 thresholds will increase twofold when C1 queue size " \ 381725839Speter "reaches this amount per compiler thread") \ 381825839Speter \ 381925839Speter product(intx, Tier4LoadFeedback, 3, \ 382025839Speter "Tier 4 thresholds will increase twofold when C2 queue size " \ 382125839Speter "reaches this amount per compiler thread") \ 382225839Speter \ 382325839Speter product(intx, TieredCompileTaskTimeout, 50, \ 382425839Speter "Kill compile task if method was not used within " \ 382525839Speter "given timeout in milliseconds") \ 382625839Speter \ 382725839Speter product(intx, TieredStopAtLevel, 4, \ 382825839Speter "Stop at given compilation level") \ 382925839Speter \ 383025839Speter product(intx, Tier0ProfilingStartPercentage, 200, \ 383125839Speter "Start profiling in interpreter if the counters exceed tier 3 " \ 383225839Speter "thresholds by the specified percentage") \ 383325839Speter \ 383425839Speter product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \ 383525839Speter "Increase the compile threshold for C1 compilation if the code " \ 383625839Speter "cache is filled by the specified percentage") \ 383725839Speter range(0, 99) \ 383825839Speter \ 383925839Speter product(intx, TieredRateUpdateMinTime, 1, \ 384025839Speter "Minimum rate sampling interval (in milliseconds)") \ 384125839Speter \ 384225839Speter product(intx, TieredRateUpdateMaxTime, 25, \ 384325839Speter "Maximum rate sampling interval (in milliseconds)") \ 384425839Speter \ 384525839Speter product_pd(bool, TieredCompilation, \ 384625839Speter "Enable tiered compilation") \ 384725839Speter \ 384825839Speter product(bool, PrintTieredEvents, false, \ 384925839Speter "Print tiered events notifications") \ 385025839Speter \ 385125839Speter product_pd(intx, OnStackReplacePercentage, \ 385225839Speter "NON_TIERED number of method invocations/branches (expressed as " \ 385325839Speter "% of CompileThreshold) before (re-)compiling OSR code") \ 385425839Speter \ 385525839Speter product(intx, InterpreterProfilePercentage, 33, \ 385625839Speter "NON_TIERED number of method invocations/branches (expressed as " \ 385725839Speter "% of CompileThreshold) before profiling in the interpreter") \ 385825839Speter range(0, 100) \ 385925839Speter \ 386025839Speter develop(intx, MaxRecompilationSearchLength, 10, \ 386125839Speter "The maximum number of frames to inspect when searching for " \ 386225839Speter "recompilee") \ 386325839Speter \ 386425839Speter develop(intx, MaxInterpretedSearchLength, 3, \ 386525839Speter "The maximum number of interpreted frames to skip when searching "\ 386625839Speter "for recompilee") \ 386725839Speter \ 386825839Speter develop(intx, DesiredMethodLimit, 8000, \ 386925839Speter "The desired maximum method size (in bytecodes) after inlining") \ 387025839Speter \ 387125839Speter develop(intx, HugeMethodLimit, 8000, \ 387225839Speter "Don't compile methods larger than this if " \ 387325839Speter "+DontCompileHugeMethods") \ 387425839Speter \ 387525839Speter /* New JDK 1.4 reflection implementation */ \ 387625839Speter \ 387725839Speter develop(intx, FastSuperclassLimit, 8, \ 387825839Speter "Depth of hardwired instanceof accelerator array") \ 387925839Speter \ 388025839Speter /* Properties for Java libraries */ \ 388125839Speter \ 388225839Speter product(size_t, MaxDirectMemorySize, 0, \ 388325839Speter "Maximum total size of NIO direct-buffer allocations") \ 388425839Speter \ 388525839Speter /* Flags used for temporary code during development */ \ 388625839Speter \ 388725839Speter diagnostic(bool, UseNewCode, false, \ 388825839Speter "Testing Only: Use the new version while testing") \ 388925839Speter \ 389025839Speter diagnostic(bool, UseNewCode2, false, \ 389125839Speter "Testing Only: Use the new version while testing") \ 389225839Speter \ 389325839Speter diagnostic(bool, UseNewCode3, false, \ 389425839Speter "Testing Only: Use the new version while testing") \ 389525839Speter \ 389625839Speter /* flags for performance data collection */ \ 389725839Speter \ 389825839Speter product(bool, UsePerfData, falseInEmbedded, \ 389925839Speter "Flag to disable jvmstat instrumentation for performance testing "\ 390025839Speter "and problem isolation purposes") \ 390125839Speter \ 390225839Speter product(bool, PerfDataSaveToFile, false, \ 390325839Speter "Save PerfData memory to hsperfdata_<pid> file on exit") \ 390425839Speter \ 390525839Speter product(ccstr, PerfDataSaveFile, NULL, \ 390625839Speter "Save PerfData memory to the specified absolute pathname. " \ 390725839Speter "The string %p in the file name (if present) " \ 390825839Speter "will be replaced by pid") \ 390925839Speter \ 391025839Speter product(intx, PerfDataSamplingInterval, 50, \ 391125839Speter "Data sampling interval (in milliseconds)") \ 391225839Speter \ 391325839Speter develop(bool, PerfTraceDataCreation, false, \ 391425839Speter "Trace creation of Performance Data Entries") \ 391525839Speter \ 391625839Speter develop(bool, PerfTraceMemOps, false, \ 391725839Speter "Trace PerfMemory create/attach/detach calls") \ 391825839Speter \ 391925839Speter product(bool, PerfDisableSharedMem, false, \ 392025839Speter "Store performance data in standard memory") \ 392125839Speter \ 392225839Speter product(intx, PerfDataMemorySize, 32*K, \ 392325839Speter "Size of performance data memory region. Will be rounded " \ 392425839Speter "up to a multiple of the native os page size.") \ 392525839Speter \ 392625839Speter product(intx, PerfMaxStringConstLength, 1024, \ 392725839Speter "Maximum PerfStringConstant string length before truncation") \ 392825839Speter \ 392925839Speter product(bool, PerfAllowAtExitRegistration, false, \ 393025839Speter "Allow registration of atexit() methods") \ 393125839Speter \ 393225839Speter product(bool, PerfBypassFileSystemCheck, false, \ 393325839Speter "Bypass Win32 file system criteria checks (Windows Only)") \ 393425839Speter \ 393525839Speter product(intx, UnguardOnExecutionViolation, 0, \ 393625839Speter "Unguard page and retry on no-execute fault (Win32 only) " \ 393725839Speter "0=off, 1=conservative, 2=aggressive") \ 393825839Speter range(0, 2) \ 393925839Speter \ 394025839Speter /* Serviceability Support */ \ 394125839Speter \ 394225839Speter product(bool, ManagementServer, false, \ 394325839Speter "Create JMX Management Server") \ 394425839Speter \ 394525839Speter product(bool, DisableAttachMechanism, false, \ 394625839Speter "Disable mechanism that allows tools to attach to this VM") \ 394725839Speter \ 394825839Speter product(bool, StartAttachListener, false, \ 394925839Speter "Always start Attach Listener at VM startup") \ 395025839Speter \ 395125839Speter manageable(bool, PrintConcurrentLocks, false, \ 395225839Speter "Print java.util.concurrent locks in thread dump") \ 395325839Speter \ 395425839Speter product(bool, TransmitErrorReport, false, \ 395525839Speter "Enable error report transmission on erroneous termination") \ 395625839Speter \ 395725839Speter product(ccstr, ErrorReportServer, NULL, \ 395825839Speter "Override built-in error report server address") \ 395925839Speter \ 396025839Speter /* Shared spaces */ \ 396125839Speter \ 396225839Speter product(bool, UseSharedSpaces, true, \ 396325839Speter "Use shared spaces for metadata") \ 396425839Speter \ 396525839Speter product(bool, VerifySharedSpaces, false, \ 396625839Speter "Verify shared spaces (false for default archive, true for " \ 396725839Speter "archive specified by -XX:SharedArchiveFile)") \ 396825839Speter \ 396925839Speter product(bool, RequireSharedSpaces, false, \ 397025839Speter "Require shared spaces for metadata") \ 397125839Speter \ 397225839Speter product(bool, DumpSharedSpaces, false, \ 397325839Speter "Special mode: JVM reads a class list, loads classes, builds " \ 397425839Speter "shared spaces, and dumps the shared spaces to a file to be " \ 397525839Speter "used in future JVM runs") \ 397625839Speter \ 397725839Speter product(bool, PrintSharedSpaces, false, \ 397825839Speter "Print usage of shared spaces") \ 397925839Speter \ 398025839Speter product(bool, PrintSharedArchiveAndExit, false, \ 398125839Speter "Print shared archive file contents") \ 398225839Speter \ 398325839Speter product(bool, PrintSharedDictionary, false, \ 398425839Speter "If PrintSharedArchiveAndExit is true, also print the shared " \ 398525839Speter "dictionary") \ 398625839Speter \ 398725839Speter product(size_t, SharedReadWriteSize, NOT_LP64(12*M) LP64_ONLY(16*M), \ 398825839Speter "Size of read-write space for metadata (in bytes)") \ 398925839Speter \ 399025839Speter product(size_t, SharedReadOnlySize, NOT_LP64(12*M) LP64_ONLY(16*M), \ 399125839Speter "Size of read-only space for metadata (in bytes)") \ 399225839Speter \ 399325839Speter product(uintx, SharedMiscDataSize, NOT_LP64(2*M) LP64_ONLY(4*M), \ 399425839Speter "Size of the shared miscellaneous data area (in bytes)") \ 399525839Speter \ 399625839Speter product(uintx, SharedMiscCodeSize, 120*K, \ 399725839Speter "Size of the shared miscellaneous code area (in bytes)") \ 399825839Speter \ 399925839Speter product(uintx, SharedBaseAddress, LP64_ONLY(32*G) \ 400025839Speter NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)), \ 400125839Speter "Address to allocate shared memory region for class data") \ 400225839Speter \ 400325839Speter product(uintx, SharedSymbolTableBucketSize, 4, \ 400425839Speter "Average number of symbols per bucket in shared table") \ 400525839Speter \ 400625839Speter diagnostic(bool, IgnoreUnverifiableClassesDuringDump, false, \ 400725839Speter "Do not quit -Xshare:dump even if we encounter unverifiable " \ 400825839Speter "classes. Just exclude them from the shared dictionary.") \ 400925839Speter \ 401025839Speter diagnostic(bool, PrintMethodHandleStubs, false, \ 401125839Speter "Print generated stub code for method handles") \ 401225839Speter \ 401325839Speter develop(bool, TraceMethodHandles, false, \ 401425839Speter "trace internal method handle operations") \ 401525839Speter \ 401625839Speter diagnostic(bool, VerifyMethodHandles, trueInDebug, \ 401725839Speter "perform extra checks when constructing method handles") \ 401825839Speter \ 401925839Speter diagnostic(bool, ShowHiddenFrames, false, \ 402025839Speter "show method handle implementation frames (usually hidden)") \ 402125839Speter \ 402225839Speter experimental(bool, TrustFinalNonStaticFields, false, \ 402325839Speter "trust final non-static declarations for constant folding") \ 402425839Speter \ 402525839Speter diagnostic(bool, FoldStableValues, true, \ 402625839Speter "Optimize loads from stable fields (marked w/ @Stable)") \ 402725839Speter \ 402825839Speter develop(bool, TraceInvokeDynamic, false, \ 402925839Speter "trace internal invoke dynamic operations") \ 403025839Speter \ 403125839Speter diagnostic(bool, PauseAtStartup, false, \ 403225839Speter "Causes the VM to pause at startup time and wait for the pause " \ 403325839Speter "file to be removed (default: ./vm.paused.<pid>)") \ 403425839Speter \ 403525839Speter diagnostic(ccstr, PauseAtStartupFile, NULL, \ 403625839Speter "The file to create and for whose removal to await when pausing " \ 403725839Speter "at startup. (default: ./vm.paused.<pid>)") \ 403825839Speter \ 403925839Speter diagnostic(bool, PauseAtExit, false, \ 404025839Speter "Pause and wait for keypress on exit if a debugger is attached") \ 404125839Speter \ 404225839Speter product(bool, ExtendedDTraceProbes, false, \ 404325839Speter "Enable performance-impacting dtrace probes") \ 404425839Speter \ 404525839Speter product(bool, DTraceMethodProbes, false, \ 404625839Speter "Enable dtrace probes for method-entry and method-exit") \ 404725839Speter \ 404825839Speter product(bool, DTraceAllocProbes, false, \ 404925839Speter "Enable dtrace probes for object allocation") \ 405025839Speter \ 405125839Speter product(bool, DTraceMonitorProbes, false, \ 405225839Speter "Enable dtrace probes for monitor events") \ 405325839Speter \ 405425839Speter product(bool, RelaxAccessControlCheck, false, \ 405525839Speter "Relax the access control checks in the verifier") \ 405625839Speter \ 405725839Speter product(uintx, StringTableSize, defaultStringTableSize, \ 405825839Speter "Number of buckets in the interned String table") \ 405925839Speter range(minimumStringTableSize, 111*defaultStringTableSize) \ 406025839Speter \ 406125839Speter experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \ 406225839Speter "Number of buckets in the JVM internal Symbol table") \ 406325839Speter range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \ 406425839Speter \ 406525839Speter product(bool, UseStringDeduplication, false, \ 406625839Speter "Use string deduplication") \ 406725839Speter \ 406825839Speter product(bool, PrintStringDeduplicationStatistics, false, \ 406925839Speter "Print string deduplication statistics") \ 407025839Speter \ 407125839Speter product(uintx, StringDeduplicationAgeThreshold, 3, \ 407225839Speter "A string must reach this age (or be promoted to an old region) " \ 407325839Speter "to be considered for deduplication") \ 407425839Speter range(1, markOopDesc::max_age) \ 407525839Speter \ 407625839Speter diagnostic(bool, StringDeduplicationResizeALot, false, \ 407725839Speter "Force table resize every time the table is scanned") \ 407825839Speter \ 407925839Speter diagnostic(bool, StringDeduplicationRehashALot, false, \ 408025839Speter "Force table rehash every time the table is scanned") \ 408125839Speter \ 408225839Speter develop(bool, TraceDefaultMethods, false, \ 408325839Speter "Trace the default method processing steps") \ 408425839Speter \ 408525839Speter diagnostic(bool, WhiteBoxAPI, false, \ 408625839Speter "Enable internal testing APIs") \ 408725839Speter \ 408825839Speter product(bool, PrintGCCause, true, \ 408925839Speter "Include GC cause in GC logging") \ 409025839Speter \ 409125839Speter experimental(intx, SurvivorAlignmentInBytes, 0, \ 409225839Speter "Default survivor space alignment in bytes") \ 409325839Speter constraint(SurvivorAlignmentInBytesConstraintFunc) \ 409425839Speter \ 409525839Speter product(bool , AllowNonVirtualCalls, false, \ 409625839Speter "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \ 409725839Speter \ 409825839Speter product(ccstr, DumpLoadedClassList, NULL, \ 409925839Speter "Dump the names all loaded classes, that could be stored into " \ 410025839Speter "the CDS archive, in the specified file") \ 410117721Speter \ 410217721Speter product(ccstr, SharedClassListFile, NULL, \ 410317721Speter "Override the default CDS class list") \ 410417721Speter \ 410517721Speter diagnostic(ccstr, SharedArchiveFile, NULL, \ 410617721Speter "Override the default location of the CDS archive file") \ 410717721Speter \ 410817721Speter product(ccstr, ExtraSharedClassListFile, NULL, \ 410917721Speter "Extra classlist for building the CDS archive file") \ 411017721Speter \ 411117721Speter experimental(size_t, ArrayAllocatorMallocLimit, \ 411217721Speter SOLARIS_ONLY(64*K) NOT_SOLARIS((size_t)-1), \ 411317721Speter "Allocation less than this value will be allocated " \ 411417721Speter "using malloc. Larger allocations will use mmap.") \ 411517721Speter \ 411617721Speter experimental(bool, AlwaysAtomicAccesses, false, \ 411717721Speter "Accesses to all variables should always be atomic") \ 411817721Speter \ 411917721Speter product(bool, EnableTracing, false, \ 412017721Speter "Enable event-based tracing") \ 412117721Speter \ 412217721Speter product(bool, UseLockedTracing, false, \ 412317721Speter "Use locked-tracing when doing event-based tracing") \ 412417721Speter \ 412517721Speter diagnostic(bool, UseUnalignedAccesses, false, \ 412617721Speter "Use unaligned memory accesses in sun.misc.Unsafe") \ 412717721Speter \ 412817721Speter product_pd(bool, PreserveFramePointer, \ 412917721Speter "Use the FP register for holding the frame pointer " \ 413017721Speter "and not as a general purpose register.") \ 413117721Speter \ 413217721Speter diagnostic(bool, CheckIntrinsics, trueInDebug, \ 413317721Speter "When a class C is loaded, check that " \ 413417721Speter "(1) all intrinsics defined by the VM for class C are present "\ 413517721Speter "in the loaded class file and are marked with the " \ 413617721Speter "@HotSpotIntrinsicCandidate annotation and also that " \ 413717721Speter "(2) there is an intrinsic registered for all loaded methods " \ 413817721Speter "that are annotated with the @HotSpotIntrinsicCandidate " \ 413917721Speter "annotation.") 414017721Speter 414117721Speter/* 414217721Speter * Macros for factoring of globals 414317721Speter */ 414417721Speter 414517721Speter// Interface macros 414617721Speter#define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 414717721Speter#define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name; 414817721Speter#define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name; 414925839Speter#define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name; 415025839Speter#define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name; 415125839Speter#define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name; 415225839Speter#ifdef PRODUCT 415325839Speter#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type CONST_##name; const type name = value; 415425839Speter#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type CONST_##name; const type name = pd_##name; 415525839Speter#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type CONST_##name; 415625839Speter#else 415725839Speter#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name; 415817721Speter#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name; 415917721Speter#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name; 416017721Speter#endif // PRODUCT 416117721Speter// Special LP64 flags, product only needed for now. 416217721Speter#ifdef _LP64 416317721Speter#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 416417721Speter#else 416517721Speter#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) const type name = value; 416617721Speter#endif // _LP64 416717721Speter 416817721Speter// Implementation macros 416917721Speter#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value; 417017721Speter#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name; 417117721Speter#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value; 417217721Speter#define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value; 417317721Speter#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value; 417417721Speter#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value; 417517721Speter#ifdef PRODUCT 417617721Speter#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type CONST_##name = value; 417717721Speter#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type CONST_##name = pd_##name; 417817721Speter#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type CONST_##name = value; 417917721Speter#else 418017721Speter#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value; 418117721Speter#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name; 418217721Speter#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value; 418317721Speter#endif // PRODUCT 418417721Speter#ifdef _LP64 418517721Speter#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value; 418617721Speter#else 418717721Speter#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */ 418817721Speter#endif // _LP64 418917721Speter 419017721Speter// Only materialize src code for range checking when required, ignore otherwise 419117721Speter#define IGNORE_RANGE(a, b) 419217721Speter// Only materialize src code for contraint checking when required, ignore otherwise 419317721Speter#define IGNORE_CONSTRAINT(func) 419417721Speter 419517721SpeterRUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, \ 419617721Speter DECLARE_PD_DEVELOPER_FLAG, \ 419717721Speter DECLARE_PRODUCT_FLAG, \ 419817721Speter DECLARE_PD_PRODUCT_FLAG, \ 419917721Speter DECLARE_DIAGNOSTIC_FLAG, \ 420017721Speter DECLARE_EXPERIMENTAL_FLAG, \ 420117721Speter DECLARE_NOTPRODUCT_FLAG, \ 420217721Speter DECLARE_MANAGEABLE_FLAG, \ 420317721Speter DECLARE_PRODUCT_RW_FLAG, \ 420417721Speter DECLARE_LP64_PRODUCT_FLAG, \ 420517721Speter IGNORE_RANGE, \ 420617721Speter IGNORE_CONSTRAINT) 420717721Speter 420817721SpeterRUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, \ 420917721Speter DECLARE_PD_DEVELOPER_FLAG, \ 421017721Speter DECLARE_PRODUCT_FLAG, \ 421117721Speter DECLARE_PD_PRODUCT_FLAG, \ 421217721Speter DECLARE_DIAGNOSTIC_FLAG, \ 421317721Speter DECLARE_NOTPRODUCT_FLAG, \ 421417721Speter IGNORE_RANGE, \ 421517721Speter IGNORE_CONSTRAINT) 421617721Speter 421717721SpeterARCH_FLAGS(DECLARE_DEVELOPER_FLAG, \ 421817721Speter DECLARE_PRODUCT_FLAG, \ 421917721Speter DECLARE_DIAGNOSTIC_FLAG, \ 422017721Speter DECLARE_EXPERIMENTAL_FLAG, \ 422117721Speter DECLARE_NOTPRODUCT_FLAG, \ 422217721Speter IGNORE_RANGE, \ 422317721Speter IGNORE_CONSTRAINT) 422417721Speter 422517721Speter// Extensions 422617721Speter 422717721Speter#include "runtime/globals_ext.hpp" 422817721Speter 422917721Speter#endif // SHARE_VM_RUNTIME_GLOBALS_HPP 423017721Speter