globals.hpp revision 12784:6e45be41abe4
118334Speter/* 272566Sobrien * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. 390282Sobrien * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 418334Speter * 590282Sobrien * This code is free software; you can redistribute it and/or modify it 618334Speter * under the terms of the GNU General Public License version 2 only, as 790282Sobrien * published by the Free Software Foundation. 890282Sobrien * 990282Sobrien * This code is distributed in the hope that it will be useful, but WITHOUT 1090282Sobrien * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1118334Speter * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1290282Sobrien * version 2 for more details (a copy is included in the LICENSE file that 1390282Sobrien * accompanied this code). 1490282Sobrien * 1590282Sobrien * You should have received a copy of the GNU General Public License version 1618334Speter * 2 along with this work; if not, write to the Free Software Foundation, 1718334Speter * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1890282Sobrien * 1990282Sobrien * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2090282Sobrien * or visit www.oracle.com if you need additional information or have any 2118334Speter * questions. 2252558Sobrien * 2352558Sobrien */ 2418334Speter 2518334Speter#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP 2618334Speter#define SHARE_VM_RUNTIME_GLOBALS_HPP 2718334Speter 2818334Speter#include "utilities/debug.hpp" 2918334Speter#include "utilities/macros.hpp" 3050615Sobrien 3150615Sobrien#include <float.h> // for DBL_MAX 3250615Sobrien 3318334Speter// use this for flags that are true per default in the tiered build 3418334Speter// but false in non-tiered builds, and vice versa 3518334Speter#ifdef TIERED 3650615Sobrien#define trueInTiered true 3750615Sobrien#define falseInTiered false 3818334Speter#else 3950615Sobrien#define trueInTiered false 4050615Sobrien#define falseInTiered true 4150615Sobrien#endif 4218334Speter 4318334Speter#include CPU_HEADER(globals) 4418334Speter#include OS_HEADER(globals) 4518334Speter#include OS_CPU_HEADER(globals) 4618334Speter#ifdef COMPILER1 4790282Sobrien#include CPU_HEADER(c1_globals) 4818334Speter#include OS_HEADER(c1_globals) 4918334Speter#endif 5050615Sobrien#ifdef COMPILER2 5190282Sobrien#include CPU_HEADER(c2_globals) 5290282Sobrien#include OS_HEADER(c2_globals) 5350615Sobrien#endif 5418334Speter#ifdef SHARK 5550615Sobrien#ifdef ZERO 5690282Sobrien# include "shark_globals_zero.hpp" 5750615Sobrien#endif 5852558Sobrien#endif 5952558Sobrien 6052558Sobrien#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK) && !INCLUDE_JVMCI 6190282Sobriendefine_pd_global(bool, BackgroundCompilation, false); 6290282Sobriendefine_pd_global(bool, UseTLAB, false); 6390282Sobriendefine_pd_global(bool, CICompileOSR, false); 6490282Sobriendefine_pd_global(bool, UseTypeProfile, false); 6590282Sobriendefine_pd_global(bool, UseOnStackReplacement, false); 6690282Sobriendefine_pd_global(bool, InlineIntrinsics, false); 6790282Sobriendefine_pd_global(bool, PreferInterpreterNativeStubs, true); 6890282Sobriendefine_pd_global(bool, ProfileInterpreter, false); 6990282Sobriendefine_pd_global(bool, ProfileTraps, false); 7090282Sobriendefine_pd_global(bool, TieredCompilation, false); 7190282Sobrien 7290282Sobriendefine_pd_global(intx, CompileThreshold, 0); 7390282Sobrien 7490282Sobriendefine_pd_global(intx, OnStackReplacePercentage, 0); 7518334Speterdefine_pd_global(bool, ResizeTLAB, false); 7650615Sobriendefine_pd_global(intx, FreqInlineSize, 0); 7750615Sobriendefine_pd_global(size_t, NewSizeThreadIncrease, 4*K); 7850615Sobriendefine_pd_global(intx, InlineClassNatives, true); 7950615Sobriendefine_pd_global(intx, InlineUnsafeOps, true); 8050615Sobriendefine_pd_global(intx, InitialCodeCacheSize, 160*K); 8150615Sobriendefine_pd_global(intx, ReservedCodeCacheSize, 32*M); 8250615Sobriendefine_pd_global(intx, NonProfiledCodeHeapSize, 0); 8350615Sobriendefine_pd_global(intx, ProfiledCodeHeapSize, 0); 8450615Sobriendefine_pd_global(intx, NonNMethodCodeHeapSize, 32*M); 8550615Sobrien 8650615Sobriendefine_pd_global(intx, CodeCacheExpansionSize, 32*K); 8750615Sobriendefine_pd_global(intx, CodeCacheMinBlockLength, 1); 8818334Speterdefine_pd_global(intx, CodeCacheMinimumUseSpace, 200*K); 8990282Sobriendefine_pd_global(size_t, MetaspaceSize, ScaleForWordSize(4*M)); 9090282Sobriendefine_pd_global(bool, NeverActAsServerClassMachine, true); 9118334Speterdefine_pd_global(uint64_t,MaxRAM, 1ULL*G); 9290282Sobrien#define CI_COMPILER_COUNT 0 9390282Sobrien#else 9490282Sobrien 9590282Sobrien#if defined(COMPILER2) || INCLUDE_JVMCI 9618334Speter#define CI_COMPILER_COUNT 2 9718334Speter#else 9818334Speter#define CI_COMPILER_COUNT 1 9918334Speter#endif // COMPILER2 || INCLUDE_JVMCI 10018334Speter 10118334Speter#endif // no compilers 10218334Speter 10390282Sobrien// string type aliases used only in this file 10490282Sobrientypedef const char* ccstr; 10590282Sobrientypedef const char* ccstrlist; // represents string arguments which accumulate 10690282Sobrien 10790282Sobrien// function type that will construct default range string 10890282Sobrientypedef const char* (*RangeStrFunc)(void); 10990282Sobrien 11090282Sobrienstruct Flag { 11118334Speter enum Flags { 11290282Sobrien // latest value origin 11390282Sobrien DEFAULT = 0, 11450615Sobrien COMMAND_LINE = 1, 11590282Sobrien ENVIRON_VAR = 2, 11690282Sobrien CONFIG_FILE = 3, 11790282Sobrien MANAGEMENT = 4, 11890282Sobrien ERGONOMIC = 5, 11990282Sobrien ATTACH_ON_DEMAND = 6, 12090282Sobrien INTERNAL = 7, 12118334Speter 12290282Sobrien LAST_VALUE_ORIGIN = INTERNAL, 12390282Sobrien VALUE_ORIGIN_BITS = 4, 12490282Sobrien VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS), 12590282Sobrien 12690282Sobrien // flag kind 12790282Sobrien KIND_PRODUCT = 1 << 4, 12890282Sobrien KIND_MANAGEABLE = 1 << 5, 12990282Sobrien KIND_DIAGNOSTIC = 1 << 6, 13052558Sobrien KIND_EXPERIMENTAL = 1 << 7, 13152558Sobrien KIND_NOT_PRODUCT = 1 << 8, 13290282Sobrien KIND_DEVELOP = 1 << 9, 13352558Sobrien KIND_PLATFORM_DEPENDENT = 1 << 10, 13452558Sobrien KIND_READ_WRITE = 1 << 11, 13550615Sobrien KIND_C1 = 1 << 12, 13650615Sobrien KIND_C2 = 1 << 13, 13718334Speter KIND_ARCH = 1 << 14, 13818334Speter KIND_SHARK = 1 << 15, 13918334Speter KIND_LP64_PRODUCT = 1 << 16, 14090282Sobrien KIND_COMMERCIAL = 1 << 17, 14118334Speter KIND_JVMCI = 1 << 18, 14290282Sobrien 14318334Speter // set this bit if the flag was set on the command line 14418334Speter ORIG_COMMAND_LINE = 1 << 19, 14518334Speter 14618334Speter KIND_MASK = ~(VALUE_ORIGIN_MASK | ORIG_COMMAND_LINE) 14718334Speter }; 14818334Speter 14990282Sobrien enum Error { 15018334Speter // no error 15118334Speter SUCCESS = 0, 15218334Speter // flag name is missing 15318334Speter MISSING_NAME, 15418334Speter // flag value is missing 15590282Sobrien MISSING_VALUE, 15618334Speter // error parsing the textual form of the value 15718334Speter WRONG_FORMAT, 15818334Speter // flag is not writable 15918334Speter NON_WRITABLE, 16018334Speter // flag value is outside of its bounds 16152558Sobrien OUT_OF_BOUNDS, 16252558Sobrien // flag value violates its constraint 16352558Sobrien VIOLATES_CONSTRAINT, 16418334Speter // there is no flag with the given name 16518334Speter INVALID_FLAG, 16618334Speter // the flag can only be set only on command line during invocation of the VM 16718334Speter COMMAND_LINE_ONLY, 16818334Speter // the flag may only be set once 16918334Speter SET_ONLY_ONCE, 17018334Speter // the flag is not writable in this combination of product/debug build 17118334Speter CONSTANT, 17218334Speter // other, unspecified error related to setting the flag 17352558Sobrien ERR_OTHER 17418334Speter }; 17590282Sobrien 17690282Sobrien enum MsgType { 17790282Sobrien NONE = 0, 17890282Sobrien DIAGNOSTIC_FLAG_BUT_LOCKED, 17990282Sobrien EXPERIMENTAL_FLAG_BUT_LOCKED, 18018334Speter DEVELOPER_FLAG_BUT_PRODUCT_BUILD, 18118334Speter NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD 18218334Speter }; 18318334Speter 18418334Speter const char* _type; 18518334Speter const char* _name; 18690282Sobrien void* _addr; 18718334Speter NOT_PRODUCT(const char* _doc;) 18890282Sobrien Flags _flags; 18990282Sobrien 19090282Sobrien // points to all Flags static array 19190282Sobrien static Flag* flags; 19290282Sobrien 19390282Sobrien // number of flags 19490282Sobrien static size_t numFlags; 19590282Sobrien 19690282Sobrien static Flag* find_flag(const char* name) { return find_flag(name, strlen(name), true, true); }; 19790282Sobrien static Flag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = false); 19890282Sobrien static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false); 19990282Sobrien 20090282Sobrien static const char* get_int_default_range_str(); 20190282Sobrien static const char* get_uint_default_range_str(); 20290282Sobrien static const char* get_intx_default_range_str(); 20390282Sobrien static const char* get_uintx_default_range_str(); 20490282Sobrien static const char* get_uint64_t_default_range_str(); 20590282Sobrien static const char* get_size_t_default_range_str(); 20690282Sobrien static const char* get_double_default_range_str(); 20790282Sobrien 20890282Sobrien Flag::Error check_writable(bool changed); 20990282Sobrien 21090282Sobrien bool is_bool() const; 21190282Sobrien bool get_bool() const; 21290282Sobrien Flag::Error set_bool(bool value); 21390282Sobrien 21490282Sobrien bool is_int() const; 21590282Sobrien int get_int() const; 21690282Sobrien Flag::Error set_int(int value); 21790282Sobrien 21890282Sobrien bool is_uint() const; 21990282Sobrien uint get_uint() const; 22090282Sobrien Flag::Error set_uint(uint value); 22190282Sobrien 22290282Sobrien bool is_intx() const; 22390282Sobrien intx get_intx() const; 22490282Sobrien Flag::Error set_intx(intx value); 22590282Sobrien 22690282Sobrien bool is_uintx() const; 22790282Sobrien uintx get_uintx() const; 22890282Sobrien Flag::Error set_uintx(uintx value); 22990282Sobrien 23090282Sobrien bool is_uint64_t() const; 23190282Sobrien uint64_t get_uint64_t() const; 23290282Sobrien Flag::Error set_uint64_t(uint64_t value); 23390282Sobrien 23490282Sobrien bool is_size_t() const; 23590282Sobrien size_t get_size_t() const; 23690282Sobrien Flag::Error set_size_t(size_t value); 23790282Sobrien 23890282Sobrien bool is_double() const; 23990282Sobrien double get_double() const; 24090282Sobrien Flag::Error set_double(double value); 24190282Sobrien 24290282Sobrien bool is_ccstr() const; 24390282Sobrien bool ccstr_accumulates() const; 24490282Sobrien ccstr get_ccstr() const; 24590282Sobrien Flag::Error set_ccstr(ccstr value); 24690282Sobrien 24790282Sobrien Flags get_origin(); 24890282Sobrien void set_origin(Flags origin); 24990282Sobrien 25090282Sobrien bool is_default(); 25190282Sobrien bool is_ergonomic(); 25290282Sobrien bool is_command_line(); 25390282Sobrien void set_command_line(); 25490282Sobrien 25590282Sobrien bool is_product() const; 25690282Sobrien bool is_manageable() const; 25790282Sobrien bool is_diagnostic() const; 25890282Sobrien bool is_experimental() const; 25990282Sobrien bool is_notproduct() const; 26090282Sobrien bool is_develop() const; 26190282Sobrien bool is_read_write() const; 26290282Sobrien bool is_commercial() const; 26390282Sobrien 26490282Sobrien bool is_constant_in_binary() const; 26590282Sobrien 26690282Sobrien bool is_unlocker() const; 26790282Sobrien bool is_unlocked() const; 26890282Sobrien bool is_writeable() const; 26990282Sobrien bool is_external() const; 27090282Sobrien 27190282Sobrien bool is_unlocker_ext() const; 27290282Sobrien bool is_unlocked_ext() const; 27390282Sobrien bool is_writeable_ext() const; 27490282Sobrien bool is_external_ext() const; 27590282Sobrien 27690282Sobrien void unlock_diagnostic(); 27790282Sobrien 27890282Sobrien Flag::MsgType get_locked_message(char*, int) const; 27990282Sobrien void get_locked_message_ext(char*, int) const; 28090282Sobrien 28190282Sobrien // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges 28290282Sobrien void print_on(outputStream* st, bool withComments = false, bool printRanges = false); 28390282Sobrien void print_kind_and_origin(outputStream* st); 28490282Sobrien void print_as_flag(outputStream* st); 28590282Sobrien 28690282Sobrien static const char* flag_error_str(Flag::Error error); 28790282Sobrien}; 28890282Sobrien 28990282Sobrien// debug flags control various aspects of the VM and are global accessible 29090282Sobrien 29190282Sobrien// use FlagSetting to temporarily change some debug flag 29290282Sobrien// e.g. FlagSetting fs(DebugThisAndThat, true); 29390282Sobrien// restored to previous value upon leaving scope 29490282Sobrienclass FlagSetting { 29590282Sobrien bool val; 29690282Sobrien bool* flag; 29790282Sobrien public: 29890282Sobrien FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; } 29990282Sobrien ~FlagSetting() { *flag = val; } 30090282Sobrien}; 30190282Sobrien 30290282Sobrien 30390282Sobrienclass CounterSetting { 30452558Sobrien intx* counter; 30518334Speter public: 30618334Speter CounterSetting(intx* cnt) { counter = cnt; (*counter)++; } 30718334Speter ~CounterSetting() { (*counter)--; } 30818334Speter}; 30918334Speter 31018334Speterclass IntFlagSetting { 31118334Speter int val; 31218334Speter int* flag; 31318334Speter public: 31418334Speter IntFlagSetting(int& fl, int newValue) { flag = &fl; val = fl; fl = newValue; } 31518334Speter ~IntFlagSetting() { *flag = val; } 31618334Speter}; 31718334Speter 31818334Speterclass UIntFlagSetting { 31918334Speter uint val; 32018334Speter uint* flag; 32118334Speter public: 32218334Speter UIntFlagSetting(uint& fl, uint newValue) { flag = &fl; val = fl; fl = newValue; } 32318334Speter ~UIntFlagSetting() { *flag = val; } 32418334Speter}; 32518334Speter 32618334Speterclass UIntXFlagSetting { 32718334Speter uintx val; 32818334Speter uintx* flag; 32918334Speter public: 33018334Speter UIntXFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; } 33118334Speter ~UIntXFlagSetting() { *flag = val; } 33218334Speter}; 33318334Speter 33418334Speterclass DoubleFlagSetting { 33518334Speter double val; 33618334Speter double* flag; 33718334Speter public: 33850615Sobrien DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; } 33950615Sobrien ~DoubleFlagSetting() { *flag = val; } 34050615Sobrien}; 34150615Sobrien 34250615Sobrienclass SizeTFlagSetting { 34350615Sobrien size_t val; 34450615Sobrien size_t* flag; 34590282Sobrien public: 34690282Sobrien SizeTFlagSetting(size_t& fl, size_t newValue) { flag = &fl; val = fl; fl = newValue; } 34718334Speter ~SizeTFlagSetting() { *flag = val; } 34890282Sobrien}; 34990282Sobrien 35090282Sobrien// Helper class for temporarily saving the value of a flag during a scope. 35118334Spetertemplate <size_t SIZE> 35290282Sobrienclass FlagGuard { 35390282Sobrien unsigned char _value[SIZE]; 35490282Sobrien void* const _addr; 35590282Sobrien 35650615Sobrien // Hide operator new, this class should only be allocated on the stack. 35750615Sobrien // NOTE: Cannot include memory/allocation.hpp here due to circular 35850615Sobrien // dependencies. 35950615Sobrien void* operator new(size_t size) throw(); 36050615Sobrien void* operator new [](size_t size) throw(); 36150615Sobrien 36250615Sobrien public: 36318334Speter FlagGuard(void* flag_addr) : _addr(flag_addr) { 36490282Sobrien memcpy(_value, _addr, SIZE); 36518334Speter } 36618334Speter 36718334Speter ~FlagGuard() { 36852558Sobrien memcpy(_addr, _value, SIZE); 36990282Sobrien } 37052558Sobrien}; 37118334Speter 37252558Sobrien#define FLAG_GUARD(f) FlagGuard<sizeof(f)> f ## _guard(&f) 37352558Sobrien 37418334Speterclass CommandLineFlags { 37518334Speterpublic: 37618334Speter static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false); 37790282Sobrien 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); } 37818334Speter static Flag::Error boolAtPut(Flag* flag, bool* value, Flag::Flags origin); 37990282Sobrien static Flag::Error boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin); 38090282Sobrien static Flag::Error boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); } 38190282Sobrien 38290282Sobrien static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false); 38318334Speter 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); } 38418334Speter static Flag::Error intAtPut(Flag* flag, int* value, Flag::Flags origin); 38518334Speter static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin); 38618334Speter static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); } 38750615Sobrien 38850615Sobrien static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false); 38950615Sobrien 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); } 39050615Sobrien static Flag::Error uintAtPut(Flag* flag, uint* value, Flag::Flags origin); 39150615Sobrien static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin); 39250615Sobrien static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); } 39350615Sobrien 39450615Sobrien static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false); 39550615Sobrien 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); } 39650615Sobrien static Flag::Error intxAtPut(Flag* flag, intx* value, Flag::Flags origin); 39750615Sobrien static Flag::Error intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin); 39850615Sobrien static Flag::Error intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); } 39990282Sobrien 40090282Sobrien static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false); 40190282Sobrien 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); } 40290282Sobrien static Flag::Error uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin); 40390282Sobrien static Flag::Error uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin); 40490282Sobrien static Flag::Error uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); } 40590282Sobrien 40690282Sobrien static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false); 40790282Sobrien 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); } 40818334Speter static Flag::Error size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin); 40918334Speter static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin); 41018334Speter static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); } 41118334Speter 41218334Speter static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false); 41318334Speter 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); } 41418334Speter static Flag::Error uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin); 41518334Speter static Flag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin); 41618334Speter static Flag::Error uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); } 41718334Speter 41890282Sobrien static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false); 41918334Speter 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); } 42090282Sobrien static Flag::Error doubleAtPut(Flag* flag, double* value, Flag::Flags origin); 42118334Speter static Flag::Error doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin); 42290282Sobrien static Flag::Error doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); } 42318334Speter 42490282Sobrien static Flag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false); 42590282Sobrien 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); } 42690282Sobrien // Contract: Flag will make private copy of the incoming value. 42790282Sobrien // Outgoing value is always malloc-ed, and caller MUST call free. 42890282Sobrien static Flag::Error ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin); 42990282Sobrien static Flag::Error ccstrAtPut(const char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); } 43090282Sobrien 43190282Sobrien // Returns false if name is not a command line flag. 43290282Sobrien static bool wasSetOnCmdline(const char* name, bool* value); 43390282Sobrien static void printSetFlags(outputStream* out); 43490282Sobrien 43518334Speter // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges 43618334Speter static void printFlags(outputStream* out, bool withComments, bool printRanges = false); 43718334Speter 43818334Speter static void verify() PRODUCT_RETURN; 43918334Speter}; 44018334Speter 44118334Speter// use this for flags that are true by default in the debug version but 44218334Speter// false in the optimized version, and vice versa 44318334Speter#ifdef ASSERT 44418334Speter#define trueInDebug true 44518334Speter#define falseInDebug false 44618334Speter#else 44718334Speter#define trueInDebug false 44818334Speter#define falseInDebug true 44918334Speter#endif 45018334Speter 45118334Speter// use this for flags that are true per default in the product build 45218334Speter// but false in development builds, and vice versa 45318334Speter#ifdef PRODUCT 45418334Speter#define trueInProduct true 45518334Speter#define falseInProduct false 45618334Speter#else 45718334Speter#define trueInProduct false 45818334Speter#define falseInProduct true 45918334Speter#endif 46018334Speter 46118334Speter// develop flags are settable / visible only during development and are constant in the PRODUCT version 46218334Speter// product flags are always settable / visible 46318334Speter// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version 46418334Speter 46518334Speter// A flag must be declared with one of the following types: 46618334Speter// bool, int, uint, intx, uintx, size_t, ccstr, double, or uint64_t. 46718334Speter// The type "ccstr" is an alias for "const char*" and is used 46818334Speter// only in this file, because the macrology requires single-token type names. 46918334Speter 47018334Speter// Note: Diagnostic options not meant for VM tuning or for product modes. 47118334Speter// They are to be used for VM quality assurance or field diagnosis 47218334Speter// of VM bugs. They are hidden so that users will not be encouraged to 47318334Speter// try them as if they were VM ordinary execution options. However, they 47418334Speter// are available in the product version of the VM. Under instruction 47518334Speter// from support engineers, VM customers can turn them on to collect 47618334Speter// diagnostic information about VM problems. To use a VM diagnostic 47718334Speter// option, you must first specify +UnlockDiagnosticVMOptions. 47818334Speter// (This master switch also affects the behavior of -Xprintflags.) 47918334Speter// 48018334Speter// experimental flags are in support of features that are not 48118334Speter// part of the officially supported product, but are available 48218334Speter// for experimenting with. They could, for example, be performance 48318334Speter// features that may not have undergone full or rigorous QA, but which may 48418334Speter// help performance in some cases and released for experimentation 48518334Speter// by the community of users and developers. This flag also allows one to 48618334Speter// be able to build a fully supported product that nonetheless also 48718334Speter// ships with some unsupported, lightly tested, experimental features. 48818334Speter// Like the UnlockDiagnosticVMOptions flag above, there is a corresponding 48918334Speter// UnlockExperimentalVMOptions flag, which allows the control and 49018334Speter// modification of the experimental flags. 49118334Speter// 49218334Speter// Nota bene: neither diagnostic nor experimental options should be used casually, 49318334Speter// and they are not supported on production loads, except under explicit 49418334Speter// direction from support engineers. 49518334Speter// 49618334Speter// manageable flags are writeable external product flags. 49718334Speter// They are dynamically writeable through the JDK management interface 49818334Speter// (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole. 49918334Speter// These flags are external exported interface (see CCC). The list of 50018334Speter// manageable flags can be queried programmatically through the management 50118334Speter// interface. 50218334Speter// 50318334Speter// A flag can be made as "manageable" only if 50418334Speter// - the flag is defined in a CCC as an external exported interface. 50518334Speter// - the VM implementation supports dynamic setting of the flag. 50618334Speter// This implies that the VM must *always* query the flag variable 50718334Speter// and not reuse state related to the flag state at any given time. 50818334Speter// - you want the flag to be queried programmatically by the customers. 50918334Speter// 51018334Speter// product_rw flags are writeable internal product flags. 51118334Speter// They are like "manageable" flags but for internal/private use. 51218334Speter// The list of product_rw flags are internal/private flags which 51318334Speter// may be changed/removed in a future release. It can be set 51418334Speter// through the management interface to get/set value 51518334Speter// when the name of flag is supplied. 51618334Speter// 51718334Speter// A flag can be made as "product_rw" only if 51818334Speter// - the VM implementation supports dynamic setting of the flag. 51918334Speter// This implies that the VM must *always* query the flag variable 52018334Speter// and not reuse state related to the flag state at any given time. 52118334Speter// 52218334Speter// Note that when there is a need to support develop flags to be writeable, 52390282Sobrien// it can be done in the same way as product_rw. 52490282Sobrien// 52590282Sobrien// range is a macro that will expand to min and max arguments for range 52690282Sobrien// checking code if provided - see commandLineFlagRangeList.hpp 52750615Sobrien// 52890282Sobrien// constraint is a macro that will expand to custom function call 52950615Sobrien// for constraint checking if provided - see commandLineFlagConstraintList.hpp 53050615Sobrien// 53150615Sobrien// writeable is a macro that controls if and how the value can change during the runtime 53250615Sobrien// 53390282Sobrien// writeable(Always) is optional and allows the flag to have its value changed 53450615Sobrien// without any limitations at any time 53550615Sobrien// 53650615Sobrien// writeable(Once) flag value's can be only set once during the lifetime of VM 53750615Sobrien// 53850615Sobrien// writeable(CommandLineOnly) flag value's can be only set from command line 53950615Sobrien// (multiple times allowed) 54050615Sobrien// 54150615Sobrien 54218334Speter 54318334Speter#define RUNTIME_FLAGS(develop, \ 54418334Speter develop_pd, \ 54518334Speter product, \ 54618334Speter product_pd, \ 54718334Speter diagnostic, \ 54818334Speter diagnostic_pd, \ 54918334Speter experimental, \ 55018334Speter notproduct, \ 55118334Speter manageable, \ 55218334Speter product_rw, \ 55318334Speter lp64_product, \ 55418334Speter range, \ 55518334Speter constraint, \ 55618334Speter writeable) \ 55718334Speter \ 55850615Sobrien lp64_product(bool, UseCompressedOops, false, \ 55950615Sobrien "Use 32-bit object references in 64-bit VM. " \ 56050615Sobrien "lp64_product means flag is always constant in 32 bit VM") \ 56150615Sobrien \ 56250615Sobrien lp64_product(bool, UseCompressedClassPointers, false, \ 56352558Sobrien "Use 32-bit class pointers in 64-bit VM. " \ 56490282Sobrien "lp64_product means flag is always constant in 32 bit VM") \ 56552558Sobrien \ 56652558Sobrien notproduct(bool, CheckCompressedOops, true, \ 56718334Speter "Generate checks in encoding/decoding code in debug VM") \ 56818334Speter \ 56918334Speter product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \ 57018334Speter "Heap allocation steps through preferred address regions to find" \ 57190282Sobrien " where it can allocate the heap. Number of steps to take per " \ 57218334Speter "region.") \ 57390282Sobrien range(1, max_uintx) \ 57418334Speter \ 57552558Sobrien lp64_product(intx, ObjectAlignmentInBytes, 8, \ 57690282Sobrien "Default object alignment in bytes, 8 is minimum") \ 57752558Sobrien range(8, 256) \ 57852558Sobrien constraint(ObjectAlignmentInBytesConstraintFunc,AtParse) \ 57952558Sobrien \ 58090282Sobrien product(bool, AssumeMP, false, \ 58190282Sobrien "Instruct the VM to assume multiple processors are available") \ 58290282Sobrien \ 58390282Sobrien /* UseMembar is theoretically a temp flag used for memory barrier */ \ 58490282Sobrien /* removal testing. It was supposed to be removed before FCS but has */ \ 58590282Sobrien /* been re-added (see 6401008) */ \ 58690282Sobrien product_pd(bool, UseMembar, \ 58790282Sobrien "(Unstable) Issues membars on thread state transitions") \ 58890282Sobrien \ 58990282Sobrien develop(bool, CleanChunkPoolAsync, true, \ 59090282Sobrien "Clean the chunk pool asynchronously") \ 59190282Sobrien \ 59290282Sobrien experimental(bool, AlwaysSafeConstructors, false, \ 59352558Sobrien "Force safe construction, as if all fields are final.") \ 59452558Sobrien \ 59590282Sobrien diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \ 59652558Sobrien "Enable normal processing of flags relating to field diagnostics")\ 59752558Sobrien \ 59852558Sobrien experimental(bool, UnlockExperimentalVMOptions, false, \ 59918334Speter "Enable normal processing of flags relating to experimental " \ 60018334Speter "features") \ 60118334Speter \ 60218334Speter product(bool, JavaMonitorsInStackTrace, true, \ 60352558Sobrien "Print information about Java monitor locks when the stacks are" \ 60418334Speter "dumped") \ 60518334Speter \ 60618334Speter product_pd(bool, UseLargePages, \ 60752558Sobrien "Use large page memory") \ 60852558Sobrien \ 60952558Sobrien product_pd(bool, UseLargePagesIndividualAllocation, \ 61052558Sobrien "Allocate large pages individually for better affinity") \ 61118334Speter \ 61218334Speter develop(bool, LargePagesIndividualAllocationInjectError, false, \ 61318334Speter "Fail large pages individual allocation") \ 61418334Speter \ 61550615Sobrien product(bool, UseLargePagesInMetaspace, false, \ 61650615Sobrien "Use large page memory in metaspace. " \ 61750615Sobrien "Only used if UseLargePages is enabled.") \ 61850615Sobrien \ 61990282Sobrien product(bool, UseNUMA, false, \ 62090282Sobrien "Use NUMA if available") \ 62190282Sobrien \ 62290282Sobrien product(bool, UseNUMAInterleaving, false, \ 62390282Sobrien "Interleave memory across NUMA nodes if available") \ 62490282Sobrien \ 62590282Sobrien product(size_t, NUMAInterleaveGranularity, 2*M, \ 62690282Sobrien "Granularity to use for NUMA interleaving on Windows OS") \ 62790282Sobrien range(os::vm_allocation_granularity(), NOT_LP64(2*G) LP64_ONLY(8192*G)) \ 62890282Sobrien \ 62990282Sobrien product(bool, ForceNUMA, false, \ 63090282Sobrien "Force NUMA optimizations on single-node/UMA systems") \ 63190282Sobrien \ 63290282Sobrien product(uintx, NUMAChunkResizeWeight, 20, \ 63390282Sobrien "Percentage (0-100) used to weight the current sample when " \ 63490282Sobrien "computing exponentially decaying average for " \ 63590282Sobrien "AdaptiveNUMAChunkSizing") \ 63618334Speter range(0, 100) \ 63718334Speter \ 63818334Speter product(size_t, NUMASpaceResizeRate, 1*G, \ 63918334Speter "Do not reallocate more than this amount per collection") \ 64018334Speter range(0, max_uintx) \ 64150615Sobrien \ 64250615Sobrien product(bool, UseAdaptiveNUMAChunkSizing, true, \ 64350615Sobrien "Enable adaptive chunk sizing for NUMA") \ 64450615Sobrien \ 64518334Speter product(bool, NUMAStats, false, \ 64618334Speter "Print NUMA stats in detailed heap information") \ 64718334Speter \ 64818334Speter product(uintx, NUMAPageScanRate, 256, \ 64918334Speter "Maximum number of pages to include in the page scan procedure") \ 65018334Speter range(0, max_uintx) \ 65118334Speter \ 65218334Speter product_pd(bool, NeedsDeoptSuspend, \ 65318334Speter "True for register window machines (sparc/ia64)") \ 65418334Speter \ 65518334Speter product(intx, UseSSE, 99, \ 65618334Speter "Highest supported SSE instructions set on x86/x64") \ 65718334Speter range(0, 99) \ 65896289Sobrien \ 65918334Speter product(bool, UseAES, false, \ 66096289Sobrien "Control whether AES instructions are used when available") \ 66196289Sobrien \ 66296289Sobrien product(bool, UseFMA, false, \ 66396289Sobrien "Control whether FMA instructions are used when available") \ 66496289Sobrien \ 66550615Sobrien product(bool, UseSHA, false, \ 66650615Sobrien "Control whether SHA instructions are used when available") \ 66750615Sobrien \ 66850615Sobrien diagnostic(bool, UseGHASHIntrinsics, false, \ 66950615Sobrien "Use intrinsics for GHASH versions of crypto") \ 67018334Speter \ 67118334Speter product(size_t, LargePageSizeInBytes, 0, \ 67218334Speter "Large page size (0 to let VM choose the page size)") \ 67318334Speter range(0, max_uintx) \ 67418334Speter \ 67518334Speter product(size_t, LargePageHeapSizeThreshold, 128*M, \ 67618334Speter "Use large pages if maximum heap is at least this big") \ 67718334Speter range(0, max_uintx) \ 67818334Speter \ 67918334Speter product(bool, ForceTimeHighResolution, false, \ 68018334Speter "Using high time resolution (for Win32 only)") \ 68118334Speter \ 68218334Speter develop(bool, TracePcPatching, false, \ 68318334Speter "Trace usage of frame::patch_pc") \ 68418334Speter \ 68518334Speter develop(bool, TraceRelocator, false, \ 68618334Speter "Trace the bytecode relocator") \ 68718334Speter \ 68818334Speter develop(bool, TraceLongCompiles, false, \ 68918334Speter "Print out every time compilation is longer than " \ 69018334Speter "a given threshold") \ 69118334Speter \ 69218334Speter develop(bool, SafepointALot, false, \ 69350615Sobrien "Generate a lot of safepoints. This works with " \ 69450615Sobrien "GuaranteedSafepointInterval") \ 69518334Speter \ 69650615Sobrien product_pd(bool, BackgroundCompilation, \ 69750615Sobrien "A thread requesting compilation is not blocked during " \ 69890282Sobrien "compilation") \ 69950615Sobrien \ 70090282Sobrien product(bool, PrintVMQWaitTime, false, \ 70150615Sobrien "Print out the waiting time in VM operation queue") \ 70290282Sobrien \ 70390282Sobrien develop(bool, TraceOopMapGeneration, false, \ 70490282Sobrien "Show OopMapGeneration") \ 70590282Sobrien \ 70650615Sobrien product(bool, MethodFlushing, true, \ 70750615Sobrien "Reclamation of zombie and not-entrant methods") \ 70850615Sobrien \ 70918334Speter develop(bool, VerifyStack, false, \ 71018334Speter "Verify stack of each thread when it is entering a runtime call") \ 71118334Speter \ 71218334Speter diagnostic(bool, ForceUnreachable, false, \ 71318334Speter "Make all non code cache addresses to be unreachable by " \ 71418334Speter "forcing use of 64bit literal fixups") \ 71518334Speter \ 71618334Speter notproduct(bool, StressDerivedPointers, false, \ 71718334Speter "Force scavenge when a derived pointer is detected on stack " \ 71818334Speter "after rtm call") \ 71918334Speter \ 72018334Speter develop(bool, TraceDerivedPointers, false, \ 72118334Speter "Trace traversal of derived pointers on stack") \ 72218334Speter \ 72318334Speter notproduct(bool, TraceCodeBlobStacks, false, \ 72418334Speter "Trace stack-walk of codeblobs") \ 72518334Speter \ 72618334Speter product(bool, PrintJNIResolving, false, \ 72718334Speter "Used to implement -v:jni") \ 72818334Speter \ 72918334Speter notproduct(bool, PrintRewrites, false, \ 73050615Sobrien "Print methods that are being rewritten") \ 73150615Sobrien \ 73250615Sobrien product(bool, UseInlineCaches, true, \ 73350615Sobrien "Use Inline Caches for virtual calls ") \ 73450615Sobrien \ 73550615Sobrien diagnostic(bool, InlineArrayCopy, true, \ 73650615Sobrien "Inline arraycopy native that is known to be part of " \ 73750615Sobrien "base library DLL") \ 73850615Sobrien \ 73950615Sobrien diagnostic(bool, InlineObjectHash, true, \ 74050615Sobrien "Inline Object::hashCode() native that is known to be part " \ 74150615Sobrien "of base library DLL") \ 74250615Sobrien \ 74350615Sobrien diagnostic(bool, InlineNatives, true, \ 74450615Sobrien "Inline natives that are known to be part of base library DLL") \ 74590282Sobrien \ 74650615Sobrien diagnostic(bool, InlineMathNatives, true, \ 74790282Sobrien "Inline SinD, CosD, etc.") \ 74890282Sobrien \ 74990282Sobrien diagnostic(bool, InlineClassNatives, true, \ 75090282Sobrien "Inline Class.isInstance, etc") \ 75118334Speter \ 75290282Sobrien diagnostic(bool, InlineThreadNatives, true, \ 75318334Speter "Inline Thread.currentThread, etc") \ 75418334Speter \ 75518334Speter diagnostic(bool, InlineUnsafeOps, true, \ 75618334Speter "Inline memory ops (native methods) from Unsafe") \ 75718334Speter \ 75818334Speter product(bool, CriticalJNINatives, true, \ 75918334Speter "Check for critical JNI entry points") \ 76050615Sobrien \ 76150615Sobrien notproduct(bool, StressCriticalJNINatives, false, \ 76250615Sobrien "Exercise register saving code in critical natives") \ 76318334Speter \ 76418334Speter diagnostic(bool, UseAESIntrinsics, false, \ 76518334Speter "Use intrinsics for AES versions of crypto") \ 76650615Sobrien \ 76750615Sobrien diagnostic(bool, UseAESCTRIntrinsics, false, \ 76850615Sobrien "Use intrinsics for the paralleled version of AES/CTR crypto") \ 76950615Sobrien \ 77050615Sobrien diagnostic(bool, UseSHA1Intrinsics, false, \ 77150615Sobrien "Use intrinsics for SHA-1 crypto hash function. " \ 77250615Sobrien "Requires that UseSHA is enabled.") \ 77350615Sobrien \ 77450615Sobrien diagnostic(bool, UseSHA256Intrinsics, false, \ 77590282Sobrien "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. " \ 77690282Sobrien "Requires that UseSHA is enabled.") \ 77790282Sobrien \ 77890282Sobrien diagnostic(bool, UseSHA512Intrinsics, false, \ 77918334Speter "Use intrinsics for SHA-384 and SHA-512 crypto hash functions. " \ 78018334Speter "Requires that UseSHA is enabled.") \ 78118334Speter \ 78218334Speter diagnostic(bool, UseCRC32Intrinsics, false, \ 78318334Speter "use intrinsics for java.util.zip.CRC32") \ 78418334Speter \ 78518334Speter diagnostic(bool, UseCRC32CIntrinsics, false, \ 78618334Speter "use intrinsics for java.util.zip.CRC32C") \ 78718334Speter \ 78890282Sobrien diagnostic(bool, UseAdler32Intrinsics, false, \ 78990282Sobrien "use intrinsics for java.util.zip.Adler32") \ 79090282Sobrien \ 79190282Sobrien diagnostic(bool, UseVectorizedMismatchIntrinsic, false, \ 79290282Sobrien "Enables intrinsification of ArraysSupport.vectorizedMismatch()") \ 79390282Sobrien \ 79490282Sobrien diagnostic(ccstrlist, DisableIntrinsic, "", \ 79590282Sobrien "do not expand intrinsics whose (internal) names appear here") \ 79690282Sobrien \ 79790282Sobrien develop(bool, TraceCallFixup, false, \ 79818334Speter "Trace all call fixups") \ 79918334Speter \ 80038510Sbde develop(bool, DeoptimizeALot, false, \ 80138510Sbde "Deoptimize at every exit from the runtime system") \ 80238510Sbde \ 80350615Sobrien notproduct(ccstrlist, DeoptimizeOnlyAt, "", \ 80450615Sobrien "A comma separated list of bcis to deoptimize at") \ 80550615Sobrien \ 80650615Sobrien product(bool, DeoptimizeRandom, false, \ 80790282Sobrien "Deoptimize random frames on random exit from the runtime system")\ 80890282Sobrien \ 80990282Sobrien notproduct(bool, ZombieALot, false, \ 81090282Sobrien "Create zombies (non-entrant) at exit from the runtime system") \ 81190282Sobrien \ 81290282Sobrien product(bool, UnlinkSymbolsALot, false, \ 81390282Sobrien "Unlink unreferenced symbols from the symbol table at safepoints")\ 81490282Sobrien \ 81550615Sobrien notproduct(bool, WalkStackALot, false, \ 81650615Sobrien "Trace stack (no print) at every exit from the runtime system") \ 81750615Sobrien \ 81850615Sobrien product(bool, Debugging, false, \ 81950615Sobrien "Set when executing debug methods in debug.cpp " \ 82050615Sobrien "(to prevent triggering assertions)") \ 82150615Sobrien \ 82250615Sobrien notproduct(bool, StrictSafepointChecks, trueInDebug, \ 82350615Sobrien "Enable strict checks that safepoints cannot happen for threads " \ 82450615Sobrien "that use NoSafepointVerifier") \ 82550615Sobrien \ 82650615Sobrien notproduct(bool, VerifyLastFrame, false, \ 82750615Sobrien "Verify oops on last frame on entry to VM") \ 82850615Sobrien \ 82950615Sobrien product(bool, FailOverToOldVerifier, true, \ 83052558Sobrien "Fail over to old verifier when split verifier fails") \ 83152558Sobrien \ 83250615Sobrien develop(bool, ShowSafepointMsgs, false, \ 83352558Sobrien "Show message about safepoint synchronization") \ 83452558Sobrien \ 83552558Sobrien product(bool, SafepointTimeout, false, \ 83650615Sobrien "Time out and warn or fail after SafepointTimeoutDelay " \ 83752558Sobrien "milliseconds if failed to reach safepoint") \ 83852558Sobrien \ 83990282Sobrien develop(bool, DieOnSafepointTimeout, false, \ 84090282Sobrien "Die upon failure to reach safepoint (see SafepointTimeout)") \ 84190282Sobrien \ 84290282Sobrien /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */ \ 84390282Sobrien /* typically, at most a few retries are needed */ \ 84490282Sobrien product(intx, SuspendRetryCount, 50, \ 84590282Sobrien "Maximum retry count for an external suspend request") \ 84690282Sobrien range(0, max_intx) \ 84790282Sobrien \ 84890282Sobrien product(intx, SuspendRetryDelay, 5, \ 84990282Sobrien "Milliseconds to delay per retry (* current_retry_count)") \ 85090282Sobrien range(0, max_intx) \ 85190282Sobrien \ 85290282Sobrien product(bool, AssertOnSuspendWaitFailure, false, \ 85390282Sobrien "Assert/Guarantee on external suspend wait failure") \ 85490282Sobrien \ 85590282Sobrien product(bool, TraceSuspendWaitFailures, false, \ 85690282Sobrien "Trace external suspend wait failures") \ 85790282Sobrien \ 85890282Sobrien product(bool, MaxFDLimit, true, \ 85990282Sobrien "Bump the number of file descriptors to maximum in Solaris") \ 86090282Sobrien \ 86190282Sobrien diagnostic(bool, LogEvents, true, \ 86290282Sobrien "Enable the various ring buffer event logs") \ 86390282Sobrien \ 86490282Sobrien diagnostic(uintx, LogEventsBufferEntries, 10, \ 86590282Sobrien "Number of ring buffer event logs") \ 86690282Sobrien range(1, NOT_LP64(1*K) LP64_ONLY(1*M)) \ 86790282Sobrien \ 86890282Sobrien product(bool, BytecodeVerificationRemote, true, \ 86990282Sobrien "Enable the Java bytecode verifier for remote classes") \ 87090282Sobrien \ 87190282Sobrien product(bool, BytecodeVerificationLocal, false, \ 87290282Sobrien "Enable the Java bytecode verifier for local classes") \ 87390282Sobrien \ 87490282Sobrien develop(bool, ForceFloatExceptions, trueInDebug, \ 87590282Sobrien "Force exceptions on FP stack under/overflow") \ 87690282Sobrien \ 87790282Sobrien develop(bool, VerifyStackAtCalls, false, \ 87890282Sobrien "Verify that the stack pointer is unchanged after calls") \ 87990282Sobrien \ 88090282Sobrien develop(bool, TraceJavaAssertions, false, \ 88190282Sobrien "Trace java language assertions") \ 88290282Sobrien \ 88390282Sobrien notproduct(bool, CheckAssertionStatusDirectives, false, \ 88490282Sobrien "Temporary - see javaClasses.cpp") \ 88590282Sobrien \ 88690282Sobrien notproduct(bool, PrintMallocFree, false, \ 88750615Sobrien "Trace calls to C heap malloc/free allocation") \ 88890282Sobrien \ 88950615Sobrien notproduct(bool, VerifyCodeCache, false, \ 89090282Sobrien "Verify code cache on memory allocation/deallocation") \ 89150615Sobrien \ 89250615Sobrien develop(bool, UseMallocOnly, false, \ 89390282Sobrien "Use only malloc/free for allocation (no resource area/arena)") \ 89490282Sobrien \ 89590282Sobrien develop(bool, PrintMalloc, false, \ 89650615Sobrien "Print all malloc/free calls") \ 89750615Sobrien \ 89850615Sobrien develop(bool, PrintMallocStatistics, false, \ 89990282Sobrien "Print malloc/free statistics") \ 90090282Sobrien \ 90190282Sobrien develop(bool, ZapResourceArea, trueInDebug, \ 90250615Sobrien "Zap freed resource/arena space with 0xABABABAB") \ 90390282Sobrien \ 90490282Sobrien notproduct(bool, ZapVMHandleArea, trueInDebug, \ 90550615Sobrien "Zap freed VM handle space with 0xBCBCBCBC") \ 90650615Sobrien \ 90790282Sobrien develop(bool, ZapJNIHandleArea, trueInDebug, \ 90890282Sobrien "Zap freed JNI handle space with 0xFEFEFEFE") \ 90990282Sobrien \ 91050615Sobrien notproduct(bool, ZapStackSegments, trueInDebug, \ 91150615Sobrien "Zap allocated/freed stack segments with 0xFADFADED") \ 91290282Sobrien \ 91350615Sobrien develop(bool, ZapUnusedHeapArea, trueInDebug, \ 91450615Sobrien "Zap unused heap space with 0xBAADBABE") \ 91590282Sobrien \ 91690282Sobrien develop(bool, CheckZapUnusedHeapArea, false, \ 91750615Sobrien "Check zapping of unused heap space") \ 91850615Sobrien \ 91990282Sobrien develop(bool, ZapFillerObjects, trueInDebug, \ 92050615Sobrien "Zap filler objects with 0xDEAFBABE") \ 92196289Sobrien \ 92296289Sobrien develop(bool, PrintVMMessages, true, \ 92396289Sobrien "Print VM messages on console") \ 92452558Sobrien \ 92550615Sobrien notproduct(uintx, ErrorHandlerTest, 0, \ 92650615Sobrien "If > 0, provokes an error after VM initialization; the value " \ 92750615Sobrien "determines which error to provoke. See test_error_handler() " \ 92850615Sobrien "in debug.cpp.") \ 92990282Sobrien \ 93090282Sobrien notproduct(uintx, TestCrashInErrorHandler, 0, \ 93190282Sobrien "If > 0, provokes an error inside VM error handler (a secondary " \ 93290282Sobrien "crash). see test_error_handler() in debug.cpp.") \ 93350615Sobrien \ 93450615Sobrien notproduct(bool, TestSafeFetchInErrorHandler, false, \ 93550615Sobrien "If true, tests SafeFetch inside error handler.") \ 93690282Sobrien \ 93790282Sobrien develop(bool, Verbose, false, \ 93852558Sobrien "Print additional debugging information from other modes") \ 93952558Sobrien \ 94052558Sobrien develop(bool, PrintMiscellaneous, false, \ 94152558Sobrien "Print uncategorized debugging information (requires +Verbose)") \ 94252558Sobrien \ 94352558Sobrien develop(bool, WizardMode, false, \ 94490282Sobrien "Print much more debugging information") \ 94590282Sobrien \ 94690282Sobrien product(bool, ShowMessageBoxOnError, false, \ 94790282Sobrien "Keep process alive on VM fatal error") \ 94890282Sobrien \ 94990282Sobrien product(bool, CreateCoredumpOnCrash, true, \ 95090282Sobrien "Create core/mini dump on VM fatal error") \ 95190282Sobrien \ 95252558Sobrien product(uint64_t, ErrorLogTimeout, 2 * 60, \ 95352558Sobrien "Timeout, in seconds, to limit the time spent on writing an " \ 95452558Sobrien "error log in case of a crash.") \ 95552558Sobrien range(0, (uint64_t)max_jlong/1000) \ 95652558Sobrien \ 95718334Speter product_pd(bool, UseOSErrorReporting, \ 95818334Speter "Let VM fatal error propagate to the OS (ie. WER on Windows)") \ 95918334Speter \ 96018334Speter product(bool, SuppressFatalErrorMessage, false, \ 96118334Speter "Report NO fatal error message (avoid deadlock)") \ 96218334Speter \ 96390282Sobrien product(ccstrlist, OnError, "", \ 96418334Speter "Run user-defined commands on fatal error; see VMError.cpp " \ 96590282Sobrien "for examples") \ 96690282Sobrien \ 96790282Sobrien product(ccstrlist, OnOutOfMemoryError, "", \ 96890282Sobrien "Run user-defined commands on first java.lang.OutOfMemoryError") \ 96950615Sobrien \ 97090282Sobrien manageable(bool, HeapDumpBeforeFullGC, false, \ 97150615Sobrien "Dump heap to file before any major stop-the-world GC") \ 97290282Sobrien \ 97350615Sobrien manageable(bool, HeapDumpAfterFullGC, false, \ 97490282Sobrien "Dump heap to file after any major stop-the-world GC") \ 97552558Sobrien \ 97690282Sobrien manageable(bool, HeapDumpOnOutOfMemoryError, false, \ 97750615Sobrien "Dump heap to file when java.lang.OutOfMemoryError is thrown") \ 97890282Sobrien \ 97950615Sobrien manageable(ccstr, HeapDumpPath, NULL, \ 98090282Sobrien "When HeapDumpOnOutOfMemoryError is on, the path (filename or " \ 98190282Sobrien "directory) of the dump file (defaults to java_pid<pid>.hprof " \ 98290282Sobrien "in the working directory)") \ 98350615Sobrien \ 98490282Sobrien develop(bool, BreakAtWarning, false, \ 98550615Sobrien "Execute breakpoint upon encountering VM warning") \ 98690282Sobrien \ 98750615Sobrien develop(bool, UseFakeTimers, false, \ 98890282Sobrien "Tell whether the VM should use system time or a fake timer") \ 98950615Sobrien \ 99090282Sobrien product(ccstr, NativeMemoryTracking, "off", \ 99150615Sobrien "Native memory tracking options") \ 99290282Sobrien \ 99350615Sobrien diagnostic(bool, PrintNMTStatistics, false, \ 99490282Sobrien "Print native memory tracking summary data if it is on") \ 99550615Sobrien \ 99690282Sobrien diagnostic(bool, LogCompilation, false, \ 99790282Sobrien "Log compilation activity in detail to LogFile") \ 99890282Sobrien \ 99950615Sobrien product(bool, PrintCompilation, false, \ 100090282Sobrien "Print compilations") \ 100150615Sobrien \ 100290282Sobrien diagnostic(bool, TraceNMethodInstalls, false, \ 100350615Sobrien "Trace nmethod installation") \ 100490282Sobrien \ 100550615Sobrien diagnostic(intx, ScavengeRootsInCode, 2, \ 100690282Sobrien "0: do not allow scavengable oops in the code cache; " \ 100750615Sobrien "1: allow scavenging from the code cache; " \ 100890282Sobrien "2: emit as many constants as the compiler can see") \ 100950615Sobrien range(0, 2) \ 101090282Sobrien \ 101150615Sobrien product(bool, AlwaysRestoreFPU, false, \ 101290282Sobrien "Restore the FPU control word after every JNI call (expensive)") \ 101350615Sobrien \ 101490282Sobrien diagnostic(bool, PrintCompilation2, false, \ 101550615Sobrien "Print additional statistics per compilation") \ 101690282Sobrien \ 101750615Sobrien diagnostic(bool, PrintAdapterHandlers, false, \ 101890282Sobrien "Print code generated for i2c/c2i adapters") \ 101950615Sobrien \ 102090282Sobrien diagnostic(bool, VerifyAdapterCalls, trueInDebug, \ 102150615Sobrien "Verify that i2c/c2i adapters are called properly") \ 102290282Sobrien \ 102350615Sobrien develop(bool, VerifyAdapterSharing, false, \ 102490282Sobrien "Verify that the code for shared adapters is the equivalent") \ 102550615Sobrien \ 102690282Sobrien diagnostic(bool, PrintAssembly, false, \ 102750615Sobrien "Print assembly code (using external disassembler.so)") \ 102890282Sobrien \ 102950615Sobrien diagnostic(ccstr, PrintAssemblyOptions, NULL, \ 103090282Sobrien "Print options string passed to disassembler.so") \ 103150615Sobrien \ 103290282Sobrien notproduct(bool, PrintNMethodStatistics, false, \ 103350615Sobrien "Print a summary statistic for the generated nmethods") \ 103490282Sobrien \ 103590282Sobrien diagnostic(bool, PrintNMethods, false, \ 103690282Sobrien "Print assembly code for nmethods when generated") \ 103790282Sobrien \ 103890282Sobrien diagnostic(bool, PrintNativeNMethods, false, \ 103950615Sobrien "Print assembly code for native nmethods when generated") \ 104090282Sobrien \ 104150615Sobrien develop(bool, PrintDebugInfo, false, \ 104290282Sobrien "Print debug information for all nmethods when generated") \ 104390282Sobrien \ 104490282Sobrien develop(bool, PrintRelocations, false, \ 104550615Sobrien "Print relocation information for all nmethods when generated") \ 104690282Sobrien \ 104750615Sobrien develop(bool, PrintDependencies, false, \ 104890282Sobrien "Print dependency information for all nmethods when generated") \ 104950615Sobrien \ 105090282Sobrien develop(bool, PrintExceptionHandlers, false, \ 105150615Sobrien "Print exception handler tables for all nmethods when generated") \ 105290282Sobrien \ 105350615Sobrien develop(bool, StressCompiledExceptionHandlers, false, \ 105490282Sobrien "Exercise compiled exception handlers") \ 105550615Sobrien \ 105690282Sobrien develop(bool, InterceptOSException, false, \ 105750615Sobrien "Start debugger when an implicit OS (e.g. NULL) " \ 105890282Sobrien "exception happens") \ 105950615Sobrien \ 106090282Sobrien product(bool, PrintCodeCache, false, \ 106150615Sobrien "Print the code cache memory usage when exiting") \ 106290282Sobrien \ 106350615Sobrien develop(bool, PrintCodeCache2, false, \ 106450615Sobrien "Print detailed usage information on the code cache when exiting")\ 106590282Sobrien \ 106690282Sobrien product(bool, PrintCodeCacheOnCompilation, false, \ 106790282Sobrien "Print the code cache memory usage each time a method is " \ 106890282Sobrien "compiled") \ 106990282Sobrien \ 107090282Sobrien diagnostic(bool, PrintStubCode, false, \ 107190282Sobrien "Print generated stub code") \ 107250615Sobrien \ 107390282Sobrien product(bool, StackTraceInThrowable, true, \ 107450615Sobrien "Collect backtrace in throwable when exception happens") \ 107590282Sobrien \ 107650615Sobrien product(bool, OmitStackTraceInFastThrow, true, \ 107790282Sobrien "Omit backtraces for some 'hot' exceptions in optimized code") \ 107890282Sobrien \ 107990282Sobrien product(bool, ProfilerPrintByteCodeStatistics, false, \ 108090282Sobrien "Print bytecode statistics when dumping profiler output") \ 108190282Sobrien \ 108290282Sobrien product(bool, ProfilerRecordPC, false, \ 108390282Sobrien "Collect ticks for each 16 byte interval of compiled code") \ 108450615Sobrien \ 108590282Sobrien product(bool, ProfileVM, false, \ 108650615Sobrien "Profile ticks that fall within VM (either in the VM Thread " \ 108790282Sobrien "or VM code called through stubs)") \ 108850615Sobrien \ 108990282Sobrien product(bool, ProfileIntervals, false, \ 109052558Sobrien "Print profiles for each interval (see ProfileIntervalsTicks)") \ 109190282Sobrien \ 109250615Sobrien notproduct(bool, ProfilerCheckIntervals, false, \ 109390282Sobrien "Collect and print information on spacing of profiler ticks") \ 109450615Sobrien \ 109590282Sobrien product(bool, PrintWarnings, true, \ 109650615Sobrien "Print JVM warnings to output stream") \ 109790282Sobrien \ 109852558Sobrien notproduct(uintx, WarnOnStalledSpinLock, 0, \ 109990282Sobrien "Print warnings for stalled SpinLocks") \ 110050615Sobrien \ 110190282Sobrien product(bool, RegisterFinalizersAtInit, true, \ 110250615Sobrien "Register finalizable objects at end of Object.<init> or " \ 110390282Sobrien "after allocation") \ 110450615Sobrien \ 110590282Sobrien develop(bool, RegisterReferences, true, \ 110650615Sobrien "Tell whether the VM should register soft/weak/final/phantom " \ 110790282Sobrien "references") \ 110850615Sobrien \ 110990282Sobrien develop(bool, IgnoreRewrites, false, \ 111050615Sobrien "Suppress rewrites of bytecodes in the oopmap generator. " \ 111190282Sobrien "This is unsafe!") \ 111290282Sobrien \ 111390282Sobrien develop(bool, PrintCodeCacheExtension, false, \ 111490282Sobrien "Print extension of code cache") \ 111590282Sobrien \ 111690282Sobrien develop(bool, UsePrivilegedStack, true, \ 111790282Sobrien "Enable the security JVM functions") \ 111890282Sobrien \ 111990282Sobrien develop(bool, ProtectionDomainVerification, true, \ 112090282Sobrien "Verify protection domain before resolution in system dictionary")\ 112190282Sobrien \ 112290282Sobrien product(bool, ClassUnloading, true, \ 112390282Sobrien "Do unloading of classes") \ 112452558Sobrien \ 112590282Sobrien product(bool, ClassUnloadingWithConcurrentMark, true, \ 112652558Sobrien "Do unloading of classes with a concurrent marking cycle") \ 112790282Sobrien \ 112890282Sobrien develop(bool, DisableStartThread, false, \ 112990282Sobrien "Disable starting of additional Java threads " \ 113090282Sobrien "(for debugging only)") \ 113190282Sobrien \ 113290282Sobrien develop(bool, MemProfiling, false, \ 113390282Sobrien "Write memory usage profiling to log file") \ 113452558Sobrien \ 113590282Sobrien notproduct(bool, PrintSystemDictionaryAtExit, false, \ 113652558Sobrien "Print the system dictionary at exit") \ 113790282Sobrien \ 113890282Sobrien experimental(intx, PredictedLoadedClassCount, 0, \ 113990282Sobrien "Experimental: Tune loaded class cache starting size") \ 114090282Sobrien \ 114190282Sobrien diagnostic(bool, UnsyncloadClass, false, \ 114290282Sobrien "Unstable: VM calls loadClass unsynchronized. Custom " \ 114390282Sobrien "class loader must call VM synchronized for findClass " \ 114490282Sobrien "and defineClass.") \ 114590282Sobrien \ 114690282Sobrien product(bool, AlwaysLockClassLoader, false, \ 114790282Sobrien "Require the VM to acquire the class loader lock before calling " \ 114890282Sobrien "loadClass() even for class loaders registering " \ 114990282Sobrien "as parallel capable") \ 115090282Sobrien \ 115190282Sobrien product(bool, AllowParallelDefineClass, false, \ 115290282Sobrien "Allow parallel defineClass requests for class loaders " \ 115390282Sobrien "registering as parallel capable") \ 115490282Sobrien \ 115590282Sobrien product(bool, MustCallLoadClassInternal, false, \ 115690282Sobrien "Call loadClassInternal() rather than loadClass()") \ 115790282Sobrien \ 115890282Sobrien product_pd(bool, DontYieldALot, \ 115990282Sobrien "Throw away obvious excess yield calls") \ 116018334Speter \ 116118334Speter develop(bool, UseDetachedThreads, true, \ 116218334Speter "Use detached threads that are recycled upon termination " \ 116318334Speter "(for Solaris only)") \ 116490282Sobrien \ 116518334Speter product(bool, UseLWPSynchronization, true, \ 116690282Sobrien "Use LWP-based instead of libthread-based synchronization " \ 116790282Sobrien "(SPARC only)") \ 116850615Sobrien \ 116950615Sobrien experimental(ccstr, SyncKnobs, NULL, \ 117050615Sobrien "(Unstable) Various monitor synchronization tunables") \ 117150615Sobrien \ 117250615Sobrien experimental(intx, EmitSync, 0, \ 117350615Sobrien "(Unsafe, Unstable) " \ 117418334Speter "Control emission of inline sync fast-path code") \ 117590282Sobrien \ 117690282Sobrien product(intx, MonitorBound, 0, "Bound Monitor population") \ 117750615Sobrien range(0, max_jint) \ 117890282Sobrien \ 117990282Sobrien product(bool, MonitorInUseLists, true, "Track Monitors for Deflation") \ 118090282Sobrien \ 118118334Speter experimental(intx, SyncFlags, 0, "(Unsafe, Unstable) " \ 118250615Sobrien "Experimental Sync flags") \ 118390282Sobrien \ 118490282Sobrien experimental(intx, SyncVerbose, 0, "(Unstable)") \ 118550615Sobrien \ 118650615Sobrien diagnostic(bool, InlineNotify, true, "intrinsify subset of notify") \ 118790282Sobrien \ 118890282Sobrien experimental(intx, ClearFPUAtPark, 0, "(Unsafe, Unstable)") \ 118990282Sobrien \ 119090282Sobrien experimental(intx, hashCode, 5, \ 119150615Sobrien "(Unstable) select hashCode generation algorithm") \ 119250615Sobrien \ 119318334Speter product(bool, FilterSpuriousWakeups, true, \ 119450615Sobrien "When true prevents OS-level spurious, or premature, wakeups " \ 119590282Sobrien "from Object.wait (Ignored for Windows)") \ 119690282Sobrien \ 119750615Sobrien experimental(intx, NativeMonitorTimeout, -1, "(Unstable)") \ 119850615Sobrien \ 119918334Speter experimental(intx, NativeMonitorFlags, 0, "(Unstable)") \ 120050615Sobrien \ 120190282Sobrien experimental(intx, NativeMonitorSpinLimit, 20, "(Unstable)") \ 120290282Sobrien \ 120350615Sobrien develop(bool, UsePthreads, false, \ 120490282Sobrien "Use pthread-based instead of libthread-based synchronization " \ 120590282Sobrien "(SPARC only)") \ 120690282Sobrien \ 120790282Sobrien product(bool, ReduceSignalUsage, false, \ 120850615Sobrien "Reduce the use of OS signals in Java and/or the VM") \ 120950615Sobrien \ 121090282Sobrien develop_pd(bool, ShareVtableStubs, \ 121150615Sobrien "Share vtable stubs (smaller code but worse branch prediction") \ 121290282Sobrien \ 121390282Sobrien develop(bool, LoadLineNumberTables, true, \ 121450615Sobrien "Tell whether the class file parser loads line number tables") \ 121590282Sobrien \ 121690282Sobrien develop(bool, LoadLocalVariableTables, true, \ 121750615Sobrien "Tell whether the class file parser loads local variable tables") \ 121890282Sobrien \ 121990282Sobrien develop(bool, LoadLocalVariableTypeTables, true, \ 122090282Sobrien "Tell whether the class file parser loads local variable type" \ 122190282Sobrien "tables") \ 122250615Sobrien \ 122390282Sobrien product(bool, AllowUserSignalHandlers, false, \ 122490282Sobrien "Do not complain if the application installs signal handlers " \ 122550615Sobrien "(Solaris & Linux only)") \ 122690282Sobrien \ 122790282Sobrien product(bool, UseSignalChaining, true, \ 122890282Sobrien "Use signal-chaining to invoke signal handlers installed " \ 122918334Speter "by the application (Solaris & Linux only)") \ 123090282Sobrien \ 123190282Sobrien product(bool, AllowJNIEnvProxy, false, \ 123250615Sobrien "Allow JNIEnv proxies for jdbx") \ 123390282Sobrien \ 123450615Sobrien product(bool, RestoreMXCSROnJNICalls, false, \ 123552558Sobrien "Restore MXCSR when returning from JNI calls") \ 123690282Sobrien \ 123790282Sobrien product(bool, CheckJNICalls, false, \ 123890282Sobrien "Verify all arguments to JNI calls") \ 123990282Sobrien \ 124090282Sobrien product(bool, CheckEndorsedAndExtDirs, false, \ 124150615Sobrien "Verify the endorsed and extension directories are not used") \ 124290282Sobrien \ 124390282Sobrien product(bool, UseFastJNIAccessors, true, \ 124450615Sobrien "Use optimized versions of Get<Primitive>Field") \ 124590282Sobrien \ 124690282Sobrien product(intx, MaxJNILocalCapacity, 65536, \ 124752558Sobrien "Maximum allowable local JNI handle capacity to " \ 124890282Sobrien "EnsureLocalCapacity() and PushLocalFrame(), " \ 124990282Sobrien "where <= 0 is unlimited, default: 65536") \ 125052558Sobrien range(min_intx, max_intx) \ 125190282Sobrien \ 125290282Sobrien product(bool, EagerXrunInit, false, \ 125350615Sobrien "Eagerly initialize -Xrun libraries; allows startup profiling, " \ 125490282Sobrien "but not all -Xrun libraries may support the state of the VM " \ 125590282Sobrien "at this time") \ 125650615Sobrien \ 125790282Sobrien product(bool, PreserveAllAnnotations, false, \ 125890282Sobrien "Preserve RuntimeInvisibleAnnotations as well " \ 125990282Sobrien "as RuntimeVisibleAnnotations") \ 126090282Sobrien \ 126190282Sobrien develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \ 126290282Sobrien "Number of OutOfMemoryErrors preallocated with backtrace") \ 126390282Sobrien \ 126490282Sobrien product(bool, UseXMMForArrayCopy, false, \ 126590282Sobrien "Use SSE2 MOVQ instruction for Arraycopy") \ 126690282Sobrien \ 126790282Sobrien product(intx, FieldsAllocationStyle, 1, \ 126890282Sobrien "0 - type based with oops first, " \ 126950615Sobrien "1 - with oops last, " \ 127090282Sobrien "2 - oops in super and sub classes are together") \ 127150615Sobrien range(0, 2) \ 127250615Sobrien \ 127390282Sobrien product(bool, CompactFields, true, \ 127490282Sobrien "Allocate nonstatic fields in gaps between previous fields") \ 127550615Sobrien \ 127650615Sobrien notproduct(bool, PrintFieldLayout, false, \ 127750615Sobrien "Print field layout for each class") \ 127890282Sobrien \ 127990282Sobrien /* Need to limit the extent of the padding to reasonable size. */\ 128050615Sobrien /* 8K is well beyond the reasonable HW cache line size, even with */\ 128150615Sobrien /* aggressive prefetching, while still leaving the room for segregating */\ 128290282Sobrien /* among the distinct pages. */\ 128390282Sobrien product(intx, ContendedPaddingWidth, 128, \ 128490282Sobrien "How many bytes to pad the fields/classes marked @Contended with")\ 128590282Sobrien range(0, 8192) \ 128650615Sobrien constraint(ContendedPaddingWidthConstraintFunc,AfterErgo) \ 128750615Sobrien \ 128890282Sobrien product(bool, EnableContended, true, \ 128950615Sobrien "Enable @Contended annotation support") \ 129050615Sobrien \ 129190282Sobrien product(bool, RestrictContended, true, \ 129250615Sobrien "Restrict @Contended to trusted classes") \ 129390282Sobrien \ 129490282Sobrien product(bool, UseBiasedLocking, true, \ 129550615Sobrien "Enable biased locking in JVM") \ 129690282Sobrien \ 129790282Sobrien product(intx, BiasedLockingStartupDelay, 4000, \ 129850615Sobrien "Number of milliseconds to wait before enabling biased locking") \ 129990282Sobrien range(0, (intx)(max_jint-(max_jint%PeriodicTask::interval_gran))) \ 130090282Sobrien constraint(BiasedLockingStartupDelayFunc,AfterErgo) \ 130150615Sobrien \ 130290282Sobrien diagnostic(bool, PrintBiasedLockingStatistics, false, \ 130390282Sobrien "Print statistics of biased locking in JVM") \ 130450615Sobrien \ 130590282Sobrien product(intx, BiasedLockingBulkRebiasThreshold, 20, \ 130690282Sobrien "Threshold of number of revocations per type to try to " \ 130790282Sobrien "rebias all objects in the heap of that type") \ 130890282Sobrien range(0, max_intx) \ 130990282Sobrien constraint(BiasedLockingBulkRebiasThresholdFunc,AfterErgo) \ 131050615Sobrien \ 131150615Sobrien product(intx, BiasedLockingBulkRevokeThreshold, 40, \ 131290282Sobrien "Threshold of number of revocations per type to permanently " \ 131350615Sobrien "revoke biases of all objects in the heap of that type") \ 131490282Sobrien range(0, max_intx) \ 131590282Sobrien constraint(BiasedLockingBulkRevokeThresholdFunc,AfterErgo) \ 131650615Sobrien \ 131790282Sobrien product(intx, BiasedLockingDecayTime, 25000, \ 131890282Sobrien "Decay time (in milliseconds) to re-enable bulk rebiasing of a " \ 131990282Sobrien "type after previous bulk rebias") \ 132090282Sobrien range(500, max_intx) \ 132190282Sobrien constraint(BiasedLockingDecayTimeFunc,AfterErgo) \ 132250615Sobrien \ 132390282Sobrien product(bool, ExitOnOutOfMemoryError, false, \ 132490282Sobrien "JVM exits on the first occurrence of an out-of-memory error") \ 132550615Sobrien \ 132690282Sobrien product(bool, CrashOnOutOfMemoryError, false, \ 132790282Sobrien "JVM aborts, producing an error log and core/mini dump, on the " \ 132850615Sobrien "first occurrence of an out-of-memory error") \ 132990282Sobrien \ 133090282Sobrien /* tracing */ \ 133150615Sobrien \ 133250615Sobrien develop(bool, StressRewriter, false, \ 133350615Sobrien "Stress linktime bytecode rewriting") \ 133490282Sobrien \ 133590282Sobrien product(ccstr, TraceJVMTI, NULL, \ 133650615Sobrien "Trace flags for JVMTI functions and events") \ 133718334Speter \ 133850615Sobrien /* This option can change an EMCP method into an obsolete method. */ \ 133950615Sobrien /* This can affect tests that except specific methods to be EMCP. */ \ 134018334Speter /* This option should be used with caution. */ \ 134190282Sobrien product(bool, StressLdcRewrite, false, \ 134218334Speter "Force ldc -> ldc_w rewrite during RedefineClasses") \ 134350615Sobrien \ 134450615Sobrien /* change to false by default sometime after Mustang */ \ 134550615Sobrien product(bool, VerifyMergedCPBytecodes, true, \ 134650615Sobrien "Verify bytecodes after RedefineClasses constant pool merging") \ 134750615Sobrien \ 134850615Sobrien develop(bool, TraceBytecodes, false, \ 134950615Sobrien "Trace bytecode execution") \ 135090282Sobrien \ 135150615Sobrien develop(bool, TraceICs, false, \ 135290282Sobrien "Trace inline cache changes") \ 135390282Sobrien \ 135490282Sobrien notproduct(bool, TraceInvocationCounterOverflow, false, \ 135550615Sobrien "Trace method invocation counter overflow") \ 135650615Sobrien \ 135750615Sobrien develop(bool, TraceInlineCacheClearing, false, \ 135850615Sobrien "Trace clearing of inline caches in nmethods") \ 135950615Sobrien \ 136050615Sobrien develop(bool, TraceDependencies, false, \ 136190282Sobrien "Trace dependencies") \ 136250615Sobrien \ 136390282Sobrien develop(bool, VerifyDependencies, trueInDebug, \ 136490282Sobrien "Exercise and verify the compilation dependency mechanism") \ 136590282Sobrien \ 136650615Sobrien develop(bool, TraceNewOopMapGeneration, false, \ 136750615Sobrien "Trace OopMapGeneration") \ 136850615Sobrien \ 136918334Speter develop(bool, TraceNewOopMapGenerationDetailed, false, \ 137090282Sobrien "Trace OopMapGeneration: print detailed cell states") \ 137118334Speter \ 137218334Speter develop(bool, TimeOopMap, false, \ 137318334Speter "Time calls to GenerateOopMap::compute_map() in sum") \ 137418334Speter \ 137518334Speter develop(bool, TimeOopMap2, false, \ 137690282Sobrien "Time calls to GenerateOopMap::compute_map() individually") \ 137790282Sobrien \ 137890282Sobrien develop(bool, TraceOopMapRewrites, false, \ 137990282Sobrien "Trace rewriting of method oops during oop map generation") \ 138018334Speter \ 138118334Speter develop(bool, TraceICBuffer, false, \ 138218334Speter "Trace usage of IC buffer") \ 138318334Speter \ 138418334Speter develop(bool, TraceCompiledIC, false, \ 138518334Speter "Trace changes of compiled IC") \ 138618334Speter \ 138718334Speter /* gc */ \ 138890282Sobrien \ 138918334Speter product(bool, UseSerialGC, false, \ 139090282Sobrien "Use the Serial garbage collector") \ 139190282Sobrien \ 139290282Sobrien product(bool, UseG1GC, false, \ 139390282Sobrien "Use the Garbage-First garbage collector") \ 139490282Sobrien \ 139518334Speter product(bool, UseParallelGC, false, \ 139690282Sobrien "Use the Parallel Scavenge garbage collector") \ 139790282Sobrien \ 139890282Sobrien product(bool, UseParallelOldGC, false, \ 139990282Sobrien "Use the Parallel Old garbage collector") \ 140018334Speter \ 140118334Speter product(uintx, HeapMaximumCompactionInterval, 20, \ 140218334Speter "How often should we maximally compact the heap (not allowing " \ 140318334Speter "any dead space)") \ 140490282Sobrien range(0, max_uintx) \ 140518334Speter \ 140618334Speter product(uintx, HeapFirstMaximumCompactionCount, 3, \ 140718334Speter "The collection count for the first maximum compaction") \ 140818334Speter range(0, max_uintx) \ 140918334Speter \ 141018334Speter product(bool, UseMaximumCompactionOnSystemGC, true, \ 141118334Speter "Use maximum compaction in the Parallel Old garbage collector " \ 141218334Speter "for a system GC") \ 141318334Speter \ 141418334Speter product(uintx, ParallelOldDeadWoodLimiterMean, 50, \ 141518334Speter "The mean used by the parallel compact dead wood " \ 141618334Speter "limiter (a number between 0-100)") \ 141718334Speter range(0, 100) \ 141818334Speter \ 141918334Speter product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \ 142018334Speter "The standard deviation used by the parallel compact dead wood " \ 142118334Speter "limiter (a number between 0-100)") \ 142218334Speter range(0, 100) \ 142318334Speter \ 142418334Speter product(uint, ParallelGCThreads, 0, \ 142518334Speter "Number of parallel threads parallel gc will use") \ 142690282Sobrien constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \ 142718334Speter \ 142890282Sobrien diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \ 142918334Speter "Use semaphore synchronization for the GC Threads, " \ 143018334Speter "instead of synchronization based on mutexes") \ 143118334Speter \ 143218334Speter product(bool, UseDynamicNumberOfGCThreads, false, \ 143318334Speter "Dynamically choose the number of parallel threads " \ 143418334Speter "parallel gc will use") \ 143518334Speter \ 143618334Speter diagnostic(bool, InjectGCWorkerCreationFailure, false, \ 143718334Speter "Inject thread creation failures for " \ 143818334Speter "UseDynamicNumberOfGCThreads") \ 143990282Sobrien \ 144090282Sobrien diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \ 144190282Sobrien "Force dynamic selection of the number of " \ 144290282Sobrien "parallel threads parallel gc will use to aid debugging") \ 144390282Sobrien \ 144490282Sobrien product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \ 144590282Sobrien "Size of heap (bytes) per GC thread used in calculating the " \ 144690282Sobrien "number of GC threads") \ 144790282Sobrien range((size_t)os::vm_page_size(), (size_t)max_uintx) \ 144890282Sobrien \ 144990282Sobrien product(uint, ConcGCThreads, 0, \ 145090282Sobrien "Number of threads concurrent gc will use") \ 145190282Sobrien constraint(ConcGCThreadsConstraintFunc,AfterErgo) \ 145290282Sobrien \ 145390282Sobrien product(uint, GCTaskTimeStampEntries, 200, \ 145490282Sobrien "Number of time stamp entries per gc worker thread") \ 145590282Sobrien range(1, max_jint) \ 145690282Sobrien \ 145790282Sobrien product(bool, AlwaysTenure, false, \ 145890282Sobrien "Always tenure objects in eden (ParallelGC only)") \ 145990282Sobrien \ 146018334Speter product(bool, NeverTenure, false, \ 146118334Speter "Never tenure objects in eden, may tenure on overflow " \ 146290282Sobrien "(ParallelGC only)") \ 146318334Speter \ 146490282Sobrien product(bool, ScavengeBeforeFullGC, true, \ 146590282Sobrien "Scavenge youngest generation before each full GC.") \ 146690282Sobrien \ 146790282Sobrien product(bool, UseConcMarkSweepGC, false, \ 146890282Sobrien "Use Concurrent Mark-Sweep GC in the old generation") \ 146990282Sobrien \ 147090282Sobrien product(bool, ExplicitGCInvokesConcurrent, false, \ 147190282Sobrien "A System.gc() request invokes a concurrent collection; " \ 147290282Sobrien "(effective only when using concurrent collectors)") \ 147390282Sobrien \ 147490282Sobrien product(bool, GCLockerInvokesConcurrent, false, \ 147590282Sobrien "The exit of a JNI critical section necessitating a scavenge, " \ 147690282Sobrien "also kicks off a background concurrent collection") \ 147790282Sobrien \ 147890282Sobrien product(uintx, GCLockerEdenExpansionPercent, 5, \ 147990282Sobrien "How much the GC can expand the eden by while the GC locker " \ 148050615Sobrien "is active (as a percentage)") \ 148190282Sobrien range(0, 100) \ 148250615Sobrien \ 148390282Sobrien diagnostic(uintx, GCLockerRetryAllocationCount, 2, \ 148450615Sobrien "Number of times to retry allocations when " \ 148590282Sobrien "blocked by the GC locker") \ 148690282Sobrien range(0, max_uintx) \ 148790282Sobrien \ 148850615Sobrien product(bool, UseCMSBestFit, true, \ 148990282Sobrien "Use CMS best fit allocation strategy") \ 149050615Sobrien \ 149190282Sobrien product(uintx, ParallelGCBufferWastePct, 10, \ 149290282Sobrien "Wasted fraction of parallel allocation buffer") \ 149390282Sobrien range(0, 100) \ 149490282Sobrien \ 149590282Sobrien product(uintx, TargetPLABWastePct, 10, \ 149690282Sobrien "Target wasted space in last buffer as percent of overall " \ 149790282Sobrien "allocation") \ 149890282Sobrien range(1, 100) \ 149990282Sobrien \ 150090282Sobrien product(uintx, PLABWeight, 75, \ 150190282Sobrien "Percentage (0-100) used to weight the current sample when " \ 150218334Speter "computing exponentially decaying average for ResizePLAB") \ 150390282Sobrien range(0, 100) \ 150490282Sobrien \ 150590282Sobrien product(bool, ResizePLAB, true, \ 150690282Sobrien "Dynamically resize (survivor space) promotion LAB's") \ 150790282Sobrien \ 150890282Sobrien product(int, ParGCArrayScanChunk, 50, \ 150990282Sobrien "Scan a subset of object array and push remainder, if array is " \ 151090282Sobrien "bigger than this") \ 151190282Sobrien range(1, max_jint/3) \ 151290282Sobrien \ 151390282Sobrien product(bool, ParGCUseLocalOverflow, false, \ 151490282Sobrien "Instead of a global overflow list, use local overflow stacks") \ 151590282Sobrien \ 151690282Sobrien product(bool, ParGCTrimOverflow, true, \ 151790282Sobrien "Eagerly trim the local overflow lists " \ 151890282Sobrien "(when ParGCUseLocalOverflow)") \ 151990282Sobrien \ 152090282Sobrien notproduct(bool, ParGCWorkQueueOverflowALot, false, \ 152190282Sobrien "Simulate work queue overflow in ParNew") \ 152290282Sobrien \ 152390282Sobrien notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \ 152490282Sobrien "An `interval' counter that determines how frequently " \ 152590282Sobrien "we simulate overflow; a smaller number increases frequency") \ 152690282Sobrien \ 152790282Sobrien product(uintx, ParGCDesiredObjsFromOverflowList, 20, \ 152890282Sobrien "The desired number of objects to claim from the overflow list") \ 152990282Sobrien range(0, max_uintx) \ 153090282Sobrien \ 153190282Sobrien diagnostic(uintx, ParGCStridesPerThread, 2, \ 153290282Sobrien "The number of strides per worker thread that we divide up the " \ 153390282Sobrien "card table scanning work into") \ 153490282Sobrien range(1, max_uintx) \ 153590282Sobrien constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \ 153690282Sobrien \ 153790282Sobrien diagnostic(intx, ParGCCardsPerStrideChunk, 256, \ 153890282Sobrien "The number of cards in each chunk of the parallel chunks used " \ 153990282Sobrien "during card table scanning") \ 154018334Speter range(1, max_intx) \ 154118334Speter constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit)\ 154218334Speter \ 154318334Speter product(uintx, OldPLABWeight, 50, \ 154418334Speter "Percentage (0-100) used to weight the current sample when " \ 154518334Speter "computing exponentially decaying average for resizing " \ 154650615Sobrien "OldPLABSize") \ 154718334Speter range(0, 100) \ 154852558Sobrien \ 154952558Sobrien product(bool, ResizeOldPLAB, true, \ 155052558Sobrien "Dynamically resize (old gen) promotion LAB's") \ 155190282Sobrien \ 155290282Sobrien product(size_t, CMSOldPLABMax, 1024, \ 155352558Sobrien "Maximum size of CMS gen promotion LAB caches per worker " \ 155452558Sobrien "per block size") \ 155552558Sobrien range(1, max_uintx) \ 155652558Sobrien constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \ 155752558Sobrien \ 155852558Sobrien product(size_t, CMSOldPLABMin, 16, \ 155952558Sobrien "Minimum size of CMS gen promotion LAB caches per worker " \ 156052558Sobrien "per block size") \ 156152558Sobrien range(1, max_uintx) \ 156252558Sobrien constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \ 156390282Sobrien \ 156452558Sobrien product(uintx, CMSOldPLABNumRefills, 4, \ 156552558Sobrien "Nominal number of refills of CMS gen promotion LAB cache " \ 156652558Sobrien "per worker per block size") \ 156752558Sobrien range(1, max_uintx) \ 156852558Sobrien \ 156952558Sobrien product(bool, CMSOldPLABResizeQuicker, false, \ 157052558Sobrien "React on-the-fly during a scavenge to a sudden " \ 157152558Sobrien "change in block demand rate") \ 157290282Sobrien \ 157352558Sobrien product(uintx, CMSOldPLABToleranceFactor, 4, \ 157452558Sobrien "The tolerance of the phase-change detector for on-the-fly " \ 157552558Sobrien "PLAB resizing during a scavenge") \ 157652558Sobrien range(1, max_uintx) \ 157752558Sobrien \ 157852558Sobrien product(uintx, CMSOldPLABReactivityFactor, 2, \ 157918334Speter "The gain in the feedback loop for on-the-fly PLAB resizing " \ 158018334Speter "during a scavenge") \ 158118334Speter range(1, max_uintx) \ 158290282Sobrien \ 158350615Sobrien product(bool, AlwaysPreTouch, false, \ 158418334Speter "Force all freshly committed pages to be pre-touched") \ 158552558Sobrien \ 158618334Speter product(size_t, PreTouchParallelChunkSize, 1 * G, \ 158718334Speter "Per-thread chunk size for parallel memory pre-touch.") \ 158818334Speter range(1, SIZE_MAX / 2) \ 158918334Speter \ 159018334Speter product_pd(size_t, CMSYoungGenPerWorker, \ 159118334Speter "The maximum size of young gen chosen by default per GC worker " \ 159218334Speter "thread available") \ 159318334Speter range(1, max_uintx) \ 159418334Speter \ 159518334Speter product(uintx, CMSIncrementalSafetyFactor, 10, \ 159618334Speter "Percentage (0-100) used to add conservatism when computing the " \ 159718334Speter "duty cycle") \ 159818334Speter range(0, 100) \ 159918334Speter \ 160018334Speter product(uintx, CMSExpAvgFactor, 50, \ 160118334Speter "Percentage (0-100) used to weight the current sample when " \ 160218334Speter "computing exponential averages for CMS statistics") \ 160318334Speter range(0, 100) \ 160418334Speter \ 160590282Sobrien product(uintx, CMS_FLSWeight, 75, \ 160618334Speter "Percentage (0-100) used to weight the current sample when " \ 160718334Speter "computing exponentially decaying averages for CMS FLS " \ 160818334Speter "statistics") \ 160918334Speter range(0, 100) \ 161018334Speter \ 161118334Speter product(uintx, CMS_FLSPadding, 1, \ 161218334Speter "The multiple of deviation from mean to use for buffering " \ 161318334Speter "against volatility in free list demand") \ 161418334Speter range(0, max_juint) \ 161518334Speter \ 161618334Speter product(uintx, FLSCoalescePolicy, 2, \ 161790282Sobrien "CMS: aggressiveness level for coalescing, increasing " \ 161818334Speter "from 0 to 4") \ 161990282Sobrien range(0, 4) \ 162018334Speter \ 162118334Speter product(bool, FLSAlwaysCoalesceLarge, false, \ 162218334Speter "CMS: larger free blocks are always available for coalescing") \ 162318334Speter \ 162418334Speter product(double, FLSLargestBlockCoalesceProximity, 0.99, \ 162518334Speter "CMS: the smaller the percentage the greater the coalescing " \ 162618334Speter "force") \ 162718334Speter range(0.0, 1.0) \ 162818334Speter \ 162918334Speter product(double, CMSSmallCoalSurplusPercent, 1.05, \ 163018334Speter "CMS: the factor by which to inflate estimated demand of small " \ 163118334Speter "block sizes to prevent coalescing with an adjoining block") \ 163218334Speter range(0.0, DBL_MAX) \ 163318334Speter \ 163418334Speter product(double, CMSLargeCoalSurplusPercent, 0.95, \ 163590282Sobrien "CMS: the factor by which to inflate estimated demand of large " \ 163618334Speter "block sizes to prevent coalescing with an adjoining block") \ 163790282Sobrien range(0.0, DBL_MAX) \ 163818334Speter \ 163918334Speter product(double, CMSSmallSplitSurplusPercent, 1.10, \ 164018334Speter "CMS: the factor by which to inflate estimated demand of small " \ 164118334Speter "block sizes to prevent splitting to supply demand for smaller " \ 164218334Speter "blocks") \ 164318334Speter range(0.0, DBL_MAX) \ 164450615Sobrien \ 164518334Speter product(double, CMSLargeSplitSurplusPercent, 1.00, \ 164618334Speter "CMS: the factor by which to inflate estimated demand of large " \ 164718334Speter "block sizes to prevent splitting to supply demand for smaller " \ 164850615Sobrien "blocks") \ 164950615Sobrien range(0.0, DBL_MAX) \ 165050615Sobrien \ 165150615Sobrien product(bool, CMSExtrapolateSweep, false, \ 165250615Sobrien "CMS: cushion for block demand during sweep") \ 165350615Sobrien \ 165450615Sobrien product(uintx, CMS_SweepWeight, 75, \ 165550615Sobrien "Percentage (0-100) used to weight the current sample when " \ 165690282Sobrien "computing exponentially decaying average for inter-sweep " \ 165750615Sobrien "duration") \ 165890282Sobrien range(0, 100) \ 165990282Sobrien \ 166090282Sobrien product(uintx, CMS_SweepPadding, 1, \ 166150615Sobrien "The multiple of deviation from mean to use for buffering " \ 166250615Sobrien "against volatility in inter-sweep duration") \ 166350615Sobrien range(0, max_juint) \ 166450615Sobrien \ 166518334Speter product(uintx, CMS_SweepTimerThresholdMillis, 10, \ 166618334Speter "Skip block flux-rate sampling for an epoch unless inter-sweep " \ 166718334Speter "duration exceeds this threshold in milliseconds") \ 166890282Sobrien range(0, max_uintx) \ 166918334Speter \ 167018334Speter product(bool, CMSClassUnloadingEnabled, true, \ 167118334Speter "Whether class unloading enabled when using CMS GC") \ 167218334Speter \ 167318334Speter product(uintx, CMSClassUnloadingMaxInterval, 0, \ 167490282Sobrien "When CMS class unloading is enabled, the maximum CMS cycle " \ 167550615Sobrien "count for which classes may not be unloaded") \ 167650615Sobrien range(0, max_uintx) \ 167750615Sobrien \ 167850615Sobrien product(uintx, CMSIndexedFreeListReplenish, 4, \ 167950615Sobrien "Replenish an indexed free list with this number of chunks") \ 168050615Sobrien range(1, max_uintx) \ 168118334Speter \ 168218334Speter product(bool, CMSReplenishIntermediate, true, \ 168352558Sobrien "Replenish all intermediate free-list caches") \ 168452558Sobrien \ 168552558Sobrien product(bool, CMSSplitIndexedFreeListBlocks, true, \ 168652558Sobrien "When satisfying batched demand, split blocks from the " \ 168752558Sobrien "IndexedFreeList whose size is a multiple of requested size") \ 168890282Sobrien \ 168952558Sobrien product(bool, CMSLoopWarn, false, \ 169052558Sobrien "Warn in case of excessive CMS looping") \ 169152558Sobrien \ 169290282Sobrien /* where does the range max value of (max_jint - 1) come from? */ \ 169390282Sobrien product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \ 169452558Sobrien "Maximum size of marking stack") \ 169552558Sobrien range(1, (max_jint - 1)) \ 169652558Sobrien \ 169752558Sobrien product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \ 169852558Sobrien "Size of marking stack") \ 169990282Sobrien constraint(MarkStackSizeConstraintFunc,AfterErgo) \ 170090282Sobrien \ 170152558Sobrien notproduct(bool, CMSMarkStackOverflowALot, false, \ 170252558Sobrien "Simulate frequent marking stack / work queue overflow") \ 170352558Sobrien \ 170452558Sobrien notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \ 170552558Sobrien "An \"interval\" counter that determines how frequently " \ 170652558Sobrien "to simulate overflow; a smaller number increases frequency") \ 170752558Sobrien \ 170852558Sobrien product(uintx, CMSMaxAbortablePrecleanLoops, 0, \ 170952558Sobrien "Maximum number of abortable preclean iterations, if > 0") \ 171052558Sobrien range(0, max_uintx) \ 171190282Sobrien \ 171290282Sobrien product(intx, CMSMaxAbortablePrecleanTime, 5000, \ 171318334Speter "Maximum time in abortable preclean (in milliseconds)") \ 171418334Speter range(0, max_intx) \ 171590282Sobrien \ 171690282Sobrien product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \ 171718334Speter "Nominal minimum work per abortable preclean iteration") \ 171890282Sobrien range(0, max_uintx) \ 171918334Speter \ 172018334Speter manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \ 172118334Speter "Time that we sleep between iterations when not given " \ 172218334Speter "enough work per iteration") \ 172350615Sobrien range(0, max_intx) \ 172490282Sobrien \ 172518334Speter /* 4096 = CardTableModRefBS::card_size_in_words * BitsPerWord */ \ 172618334Speter product(size_t, CMSRescanMultiple, 32, \ 172718334Speter "Size (in cards) of CMS parallel rescan task") \ 172818334Speter range(1, SIZE_MAX / 4096) \ 172918334Speter constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit) \ 173018334Speter \ 173150615Sobrien /* 4096 = CardTableModRefBS::card_size_in_words * BitsPerWord */ \ 173250615Sobrien product(size_t, CMSConcMarkMultiple, 32, \ 173350615Sobrien "Size (in cards) of CMS concurrent MT marking task") \ 173450615Sobrien range(1, SIZE_MAX / 4096) \ 173550615Sobrien constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit) \ 173650615Sobrien \ 173750615Sobrien product(bool, CMSAbortSemantics, false, \ 173850615Sobrien "Whether abort-on-overflow semantics is implemented") \ 173950615Sobrien \ 174018334Speter product(bool, CMSParallelInitialMarkEnabled, true, \ 174118334Speter "Use the parallel initial mark.") \ 174218334Speter \ 174350615Sobrien product(bool, CMSParallelRemarkEnabled, true, \ 174418334Speter "Whether parallel remark enabled (only if ParNewGC)") \ 174518334Speter \ 174618334Speter product(bool, CMSParallelSurvivorRemarkEnabled, true, \ 174752558Sobrien "Whether parallel remark of survivor space " \ 174818334Speter "enabled (effective only if CMSParallelRemarkEnabled)") \ 174950615Sobrien \ 175050615Sobrien product(bool, CMSPLABRecordAlways, true, \ 175150615Sobrien "Always record survivor space PLAB boundaries (effective only " \ 175218334Speter "if CMSParallelSurvivorRemarkEnabled)") \ 175318334Speter \ 175418334Speter product(bool, CMSEdenChunksRecordAlways, true, \ 175518334Speter "Always record eden chunks used for the parallel initial mark " \ 175618334Speter "or remark of eden") \ 175796289Sobrien \ 175896289Sobrien product(bool, CMSConcurrentMTEnabled, true, \ 175996289Sobrien "Whether multi-threaded concurrent work enabled " \ 176096289Sobrien "(effective only if ParNewGC)") \ 176196289Sobrien \ 176296289Sobrien product(bool, CMSPrecleaningEnabled, true, \ 176396289Sobrien "Whether concurrent precleaning enabled") \ 176496289Sobrien \ 176518334Speter product(uintx, CMSPrecleanIter, 3, \ 176618334Speter "Maximum number of precleaning iteration passes") \ 176750615Sobrien range(0, 9) \ 176818334Speter \ 176918334Speter product(uintx, CMSPrecleanDenominator, 3, \ 177018334Speter "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ 177118334Speter "ratio") \ 177218334Speter range(1, max_uintx) \ 177318334Speter constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \ 177418334Speter \ 177552558Sobrien product(uintx, CMSPrecleanNumerator, 2, \ 177618334Speter "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ 177718334Speter "ratio") \ 177852558Sobrien range(0, max_uintx-1) \ 177918334Speter constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo) \ 178018334Speter \ 178118334Speter product(bool, CMSPrecleanRefLists1, true, \ 178218334Speter "Preclean ref lists during (initial) preclean phase") \ 178390282Sobrien \ 178490282Sobrien product(bool, CMSPrecleanRefLists2, false, \ 178518334Speter "Preclean ref lists during abortable preclean phase") \ 178618334Speter \ 178718334Speter product(bool, CMSPrecleanSurvivors1, false, \ 178818334Speter "Preclean survivors during (initial) preclean phase") \ 178918334Speter \ 179018334Speter product(bool, CMSPrecleanSurvivors2, true, \ 179118334Speter "Preclean survivors during abortable preclean phase") \ 179218334Speter \ 179318334Speter product(uintx, CMSPrecleanThreshold, 1000, \ 179418334Speter "Do not iterate again if number of dirty cards is less than this")\ 179518334Speter range(100, max_uintx) \ 179618334Speter \ 179718334Speter product(bool, CMSCleanOnEnter, true, \ 179818334Speter "Clean-on-enter optimization for reducing number of dirty cards") \ 179918334Speter \ 180018334Speter product(uintx, CMSRemarkVerifyVariant, 1, \ 180190282Sobrien "Choose variant (1,2) of verification following remark") \ 180218334Speter range(1, 2) \ 180390282Sobrien \ 180490282Sobrien product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \ 180590282Sobrien "If Eden size is below this, do not try to schedule remark") \ 180690282Sobrien range(0, max_uintx) \ 180718334Speter \ 180890282Sobrien product(uintx, CMSScheduleRemarkEdenPenetration, 50, \ 180990282Sobrien "The Eden occupancy percentage (0-100) at which " \ 181090282Sobrien "to try and schedule remark pause") \ 181118334Speter range(0, 100) \ 181290282Sobrien \ 181390282Sobrien product(uintx, CMSScheduleRemarkSamplingRatio, 5, \ 181450615Sobrien "Start sampling eden top at least before young gen " \ 181590282Sobrien "occupancy reaches 1/<ratio> of the size at which " \ 181690282Sobrien "we plan to schedule remark") \ 181790282Sobrien range(1, max_uintx) \ 181850615Sobrien \ 181990282Sobrien product(uintx, CMSSamplingGrain, 16*K, \ 182050615Sobrien "The minimum distance between eden samples for CMS (see above)") \ 182190282Sobrien range(ObjectAlignmentInBytes, max_uintx) \ 182290282Sobrien constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit) \ 182390282Sobrien \ 182490282Sobrien product(bool, CMSScavengeBeforeRemark, false, \ 182590282Sobrien "Attempt scavenge before the CMS remark step") \ 182690282Sobrien \ 182790282Sobrien product(uintx, CMSWorkQueueDrainThreshold, 10, \ 182890282Sobrien "Don't drain below this size per parallel worker/thief") \ 182990282Sobrien range(1, max_juint) \ 183090282Sobrien constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \ 183190282Sobrien \ 183290282Sobrien manageable(intx, CMSWaitDuration, 2000, \ 183390282Sobrien "Time in milliseconds that CMS thread waits for young GC") \ 183490282Sobrien range(min_jint, max_jint) \ 183590282Sobrien \ 183650615Sobrien develop(uintx, CMSCheckInterval, 1000, \ 183790282Sobrien "Interval in milliseconds that CMS thread checks if it " \ 183890282Sobrien "should start a collection cycle") \ 183950615Sobrien \ 184090282Sobrien product(bool, CMSYield, true, \ 184190282Sobrien "Yield between steps of CMS") \ 184290282Sobrien \ 184390282Sobrien product(size_t, CMSBitMapYieldQuantum, 10*M, \ 184490282Sobrien "Bitmap operations should process at most this many bits " \ 184590282Sobrien "between yields") \ 184690282Sobrien range(1, max_uintx) \ 184790282Sobrien constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit) \ 184890282Sobrien \ 184990282Sobrien product(bool, CMSPrintChunksInDump, false, \ 185090282Sobrien "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ 185190282Sobrien "trace level include more detailed information about the" \ 185250615Sobrien "free chunks") \ 185350615Sobrien \ 185490282Sobrien product(bool, CMSPrintObjectsInDump, false, \ 185590282Sobrien "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ 185650615Sobrien "trace level include more detailed information about the" \ 185790282Sobrien "allocated objects") \ 185890282Sobrien \ 185990282Sobrien diagnostic(bool, FLSVerifyAllHeapReferences, false, \ 186090282Sobrien "Verify that all references across the FLS boundary " \ 186150615Sobrien "are to valid objects") \ 186290282Sobrien \ 186390282Sobrien diagnostic(bool, FLSVerifyLists, false, \ 186450615Sobrien "Do lots of (expensive) FreeListSpace verification") \ 186590282Sobrien \ 186690282Sobrien diagnostic(bool, FLSVerifyIndexTable, false, \ 186790282Sobrien "Do lots of (expensive) FLS index table verification") \ 186890282Sobrien \ 186990282Sobrien develop(bool, FLSVerifyDictionary, false, \ 187090282Sobrien "Do lots of (expensive) FLS dictionary verification") \ 187190282Sobrien \ 187250615Sobrien develop(bool, VerifyBlockOffsetArray, false, \ 187390282Sobrien "Do (expensive) block offset array verification") \ 187490282Sobrien \ 187590282Sobrien diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \ 187690282Sobrien "Maintain _unallocated_block in BlockOffsetArray " \ 187790282Sobrien "(currently applicable only to CMS collector)") \ 187850615Sobrien \ 187990282Sobrien product(intx, RefDiscoveryPolicy, 0, \ 188090282Sobrien "Select type of reference discovery policy: " \ 188150615Sobrien "reference-based(0) or referent-based(1)") \ 188290282Sobrien range(ReferenceProcessor::DiscoveryPolicyMin, \ 188390282Sobrien ReferenceProcessor::DiscoveryPolicyMax) \ 188450615Sobrien \ 188550615Sobrien product(bool, ParallelRefProcEnabled, false, \ 188690282Sobrien "Enable parallel reference processing whenever possible") \ 188718334Speter \ 188818334Speter product(bool, ParallelRefProcBalancingEnabled, true, \ 188952558Sobrien "Enable balancing of reference processing queues") \ 189052558Sobrien \ 189152558Sobrien product(uintx, CMSTriggerRatio, 80, \ 189290282Sobrien "Percentage of MinHeapFreeRatio in CMS generation that is " \ 189390282Sobrien "allocated before a CMS collection cycle commences") \ 189452558Sobrien range(0, 100) \ 189552558Sobrien \ 189652558Sobrien product(uintx, CMSBootstrapOccupancy, 50, \ 189752558Sobrien "Percentage CMS generation occupancy at which to " \ 189852558Sobrien "initiate CMS collection for bootstrapping collection stats") \ 189952558Sobrien range(0, 100) \ 190052558Sobrien \ 190152558Sobrien product(intx, CMSInitiatingOccupancyFraction, -1, \ 190252558Sobrien "Percentage CMS generation occupancy to start a CMS collection " \ 190350615Sobrien "cycle. A negative value means that CMSTriggerRatio is used") \ 190452558Sobrien range(min_intx, 100) \ 190552558Sobrien \ 190652558Sobrien product(uintx, InitiatingHeapOccupancyPercent, 45, \ 190790282Sobrien "The percent occupancy (IHOP) of the current old generation " \ 190852558Sobrien "capacity above which a concurrent mark cycle will be initiated " \ 190952558Sobrien "Its value may change over time if adaptive IHOP is enabled, " \ 191090282Sobrien "otherwise the value remains constant. " \ 191152558Sobrien "In the latter case a value of 0 will result as frequent as " \ 191252558Sobrien "possible concurrent marking cycles. A value of 100 disables " \ 191352558Sobrien "concurrent marking. " \ 191452558Sobrien "Fragmentation waste in the old generation is not considered " \ 191552558Sobrien "free space in this calculation. (G1 collector only)") \ 191652558Sobrien range(0, 100) \ 191752558Sobrien \ 191852558Sobrien manageable(intx, CMSTriggerInterval, -1, \ 191952558Sobrien "Commence a CMS collection cycle (at least) every so many " \ 192052558Sobrien "milliseconds (0 permanently, -1 disabled)") \ 192152558Sobrien range(-1, max_intx) \ 192252558Sobrien \ 192352558Sobrien product(bool, UseCMSInitiatingOccupancyOnly, false, \ 192452558Sobrien "Only use occupancy as a criterion for starting a CMS collection")\ 192552558Sobrien \ 192652558Sobrien product(uintx, CMSIsTooFullPercentage, 98, \ 192752558Sobrien "An absolute ceiling above which CMS will always consider the " \ 192852558Sobrien "unloading of classes when class unloading is enabled") \ 192952558Sobrien range(0, 100) \ 193052558Sobrien \ 193152558Sobrien develop(bool, CMSTestInFreeList, false, \ 193252558Sobrien "Check if the coalesced range is already in the " \ 193352558Sobrien "free lists as claimed") \ 193452558Sobrien \ 193552558Sobrien notproduct(bool, CMSVerifyReturnedBytes, false, \ 193652558Sobrien "Check that all the garbage collected was returned to the " \ 193752558Sobrien "free lists") \ 193852558Sobrien \ 193952558Sobrien notproduct(bool, ScavengeALot, false, \ 194052558Sobrien "Force scavenge at every Nth exit from the runtime system " \ 194152558Sobrien "(N=ScavengeALotInterval)") \ 194252558Sobrien \ 194352558Sobrien develop(bool, FullGCALot, false, \ 194452558Sobrien "Force full gc at every Nth exit from the runtime system " \ 194552558Sobrien "(N=FullGCALotInterval)") \ 194652558Sobrien \ 194752558Sobrien notproduct(bool, GCALotAtAllSafepoints, false, \ 194852558Sobrien "Enforce ScavengeALot/GCALot at all potential safepoints") \ 194952558Sobrien \ 195052558Sobrien notproduct(bool, PromotionFailureALot, false, \ 195152558Sobrien "Use promotion failure handling on every youngest generation " \ 195252558Sobrien "collection") \ 195352558Sobrien \ 195496289Sobrien develop(uintx, PromotionFailureALotCount, 1000, \ 195552558Sobrien "Number of promotion failures occurring at PLAB " \ 195696289Sobrien "refill attempts (ParNew) or promotion attempts " \ 195796289Sobrien "(other young collectors)") \ 195896289Sobrien \ 195996289Sobrien develop(uintx, PromotionFailureALotInterval, 5, \ 196096289Sobrien "Total collections between promotion failures a lot") \ 196196289Sobrien \ 196296289Sobrien experimental(uintx, WorkStealingSleepMillis, 1, \ 196396289Sobrien "Sleep time when sleep is used for yields") \ 196496289Sobrien \ 196596289Sobrien experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \ 196696289Sobrien "Number of yields before a sleep is done during work stealing") \ 196796289Sobrien \ 196896289Sobrien experimental(uintx, WorkStealingHardSpins, 4096, \ 196996289Sobrien "Number of iterations in a spin loop between checks on " \ 197096289Sobrien "time out of hard spin") \ 197196289Sobrien \ 197252558Sobrien experimental(uintx, WorkStealingSpinToYieldRatio, 10, \ 197352558Sobrien "Ratio of hard spins to calls to yield") \ 197452558Sobrien \ 197552558Sobrien develop(uintx, ObjArrayMarkingStride, 2048, \ 197652558Sobrien "Number of object array elements to push onto the marking stack " \ 197752558Sobrien "before pushing a continuation entry") \ 197852558Sobrien \ 197952558Sobrien develop(bool, MetadataAllocationFailALot, false, \ 198052558Sobrien "Fail metadata allocations at intervals controlled by " \ 198152558Sobrien "MetadataAllocationFailALotInterval") \ 198252558Sobrien \ 198352558Sobrien develop(uintx, MetadataAllocationFailALotInterval, 1000, \ 198452558Sobrien "Metadata allocation failure a lot interval") \ 198552558Sobrien \ 198652558Sobrien notproduct(bool, ExecuteInternalVMTests, false, \ 198752558Sobrien "Enable execution of internal VM tests") \ 198852558Sobrien \ 198952558Sobrien notproduct(bool, VerboseInternalVMTests, false, \ 199052558Sobrien "Turn on logging for internal VM tests.") \ 199152558Sobrien \ 199252558Sobrien product(bool, ExecutingUnitTests, false, \ 199352558Sobrien "Whether the JVM is running unit tests or not") \ 199452558Sobrien \ 199552558Sobrien product_pd(bool, UseTLAB, "Use thread-local object allocation") \ 199690282Sobrien \ 199752558Sobrien product_pd(bool, ResizeTLAB, \ 199852558Sobrien "Dynamically resize TLAB size for threads") \ 199952558Sobrien \ 200052558Sobrien product(bool, ZeroTLAB, false, \ 200152558Sobrien "Zero out the newly created TLAB") \ 200252558Sobrien \ 200352558Sobrien product(bool, FastTLABRefill, true, \ 200452558Sobrien "Use fast TLAB refill code") \ 200552558Sobrien \ 200652558Sobrien product(bool, TLABStats, true, \ 200752558Sobrien "Provide more detailed and expensive TLAB statistics.") \ 200852558Sobrien \ 200952558Sobrien product_pd(bool, NeverActAsServerClassMachine, \ 201052558Sobrien "Never act like a server-class machine") \ 201152558Sobrien \ 201252558Sobrien product(bool, AlwaysActAsServerClassMachine, false, \ 201352558Sobrien "Always act like a server-class machine") \ 201490282Sobrien \ 201552558Sobrien product_pd(uint64_t, MaxRAM, \ 201652558Sobrien "Real memory size (in bytes) used to set maximum heap size") \ 201752558Sobrien range(0, 0XFFFFFFFFFFFFFFFF) \ 201852558Sobrien \ 201952558Sobrien product(size_t, ErgoHeapSizeLimit, 0, \ 202052558Sobrien "Maximum ergonomically set heap size (in bytes); zero means use " \ 202152558Sobrien "MaxRAM / MaxRAMFraction") \ 202290282Sobrien range(0, max_uintx) \ 202352558Sobrien \ 202452558Sobrien experimental(bool, UseCGroupMemoryLimitForHeap, false, \ 202552558Sobrien "Use CGroup memory limit as physical memory limit for heap " \ 202652558Sobrien "sizing") \ 202752558Sobrien \ 202852558Sobrien product(uintx, MaxRAMFraction, 4, \ 202952558Sobrien "Maximum fraction (1/n) of real memory used for maximum heap " \ 203052558Sobrien "size") \ 203152558Sobrien range(1, max_uintx) \ 203252558Sobrien \ 203352558Sobrien product(uintx, MinRAMFraction, 2, \ 203452558Sobrien "Minimum fraction (1/n) of real memory used for maximum heap " \ 203552558Sobrien "size on systems with small physical memory size") \ 203652558Sobrien range(1, max_uintx) \ 203752558Sobrien \ 203852558Sobrien product(uintx, InitialRAMFraction, 64, \ 203952558Sobrien "Fraction (1/n) of real memory used for initial heap size") \ 204052558Sobrien range(1, max_uintx) \ 204152558Sobrien \ 204252558Sobrien develop(uintx, MaxVirtMemFraction, 2, \ 204390282Sobrien "Maximum fraction (1/n) of virtual memory used for ergonomically "\ 204490282Sobrien "determining maximum heap size") \ 204590282Sobrien \ 204690282Sobrien product(bool, UseAdaptiveSizePolicy, true, \ 204752558Sobrien "Use adaptive generation sizing policies") \ 204852558Sobrien \ 204952558Sobrien product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \ 205052558Sobrien "Use adaptive survivor sizing policies") \ 205152558Sobrien \ 205252558Sobrien product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \ 205352558Sobrien "Use adaptive young-old sizing policies at minor collections") \ 205452558Sobrien \ 205552558Sobrien product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \ 205652558Sobrien "Use adaptive young-old sizing policies at major collections") \ 205752558Sobrien \ 205890282Sobrien product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \ 205990282Sobrien "Include statistics from System.gc() for adaptive size policy") \ 206090282Sobrien \ 206152558Sobrien product(bool, UseAdaptiveGCBoundary, false, \ 206252558Sobrien "Allow young-old boundary to move") \ 206352558Sobrien \ 206490282Sobrien develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \ 206590282Sobrien "Resize the virtual spaces of the young or old generations") \ 206690282Sobrien range(-1, 1) \ 206718334Speter \ 206890282Sobrien product(uintx, AdaptiveSizeThroughPutPolicy, 0, \ 206990282Sobrien "Policy for changing generation size for throughput goals") \ 207090282Sobrien range(0, 1) \ 207190282Sobrien \ 207218334Speter product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \ 207390282Sobrien "Number of steps where heuristics is used before data is used") \ 207418334Speter range(0, max_uintx) \ 207590282Sobrien \ 207618334Speter develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \ 207790282Sobrien "Number of collections before the adaptive sizing is started") \ 207890282Sobrien \ 207918334Speter product(uintx, AdaptiveSizePolicyOutputInterval, 0, \ 208018334Speter "Collection interval for printing information; zero means never") \ 208190282Sobrien range(0, max_uintx) \ 208290282Sobrien \ 208390282Sobrien product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \ 208490282Sobrien "Use adaptive minimum footprint as a goal") \ 208590282Sobrien \ 208690282Sobrien product(uintx, AdaptiveSizePolicyWeight, 10, \ 208790282Sobrien "Weight given to exponential resizing, between 0 and 100") \ 208890282Sobrien range(0, 100) \ 208918334Speter \ 209090282Sobrien product(uintx, AdaptiveTimeWeight, 25, \ 209190282Sobrien "Weight given to time in adaptive policy, between 0 and 100") \ 209290282Sobrien range(0, 100) \ 209318334Speter \ 209490282Sobrien product(uintx, PausePadding, 1, \ 209590282Sobrien "How much buffer to keep for pause time") \ 209690282Sobrien range(0, max_juint) \ 209790282Sobrien \ 209818334Speter product(uintx, PromotedPadding, 3, \ 209990282Sobrien "How much buffer to keep for promotion failure") \ 210090282Sobrien range(0, max_juint) \ 210190282Sobrien \ 210290282Sobrien product(uintx, SurvivorPadding, 3, \ 210390282Sobrien "How much buffer to keep for survivor overflow") \ 210490282Sobrien range(0, max_juint) \ 210590282Sobrien \ 210690282Sobrien product(uintx, ThresholdTolerance, 10, \ 210790282Sobrien "Allowed collection cost difference between generations") \ 210890282Sobrien range(0, 100) \ 210918334Speter \ 211090282Sobrien product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \ 211190282Sobrien "If collection costs are within margin, reduce both by full " \ 211218334Speter "delta") \ 211390282Sobrien range(0, 100) \ 211490282Sobrien \ 211590282Sobrien product(uintx, YoungGenerationSizeIncrement, 20, \ 211690282Sobrien "Adaptive size percentage change in young generation") \ 211718334Speter range(0, 100) \ 211818334Speter \ 211918334Speter product(uintx, YoungGenerationSizeSupplement, 80, \ 212050615Sobrien "Supplement to YoungedGenerationSizeIncrement used at startup") \ 212150615Sobrien range(0, 100) \ 212218334Speter \ 212390282Sobrien product(uintx, YoungGenerationSizeSupplementDecay, 8, \ 212418334Speter "Decay factor to YoungedGenerationSizeSupplement") \ 212518334Speter range(1, max_uintx) \ 212618334Speter \ 212790282Sobrien product(uintx, TenuredGenerationSizeIncrement, 20, \ 212818334Speter "Adaptive size percentage change in tenured generation") \ 212990282Sobrien range(0, 100) \ 213090282Sobrien \ 213190282Sobrien product(uintx, TenuredGenerationSizeSupplement, 80, \ 213218334Speter "Supplement to TenuredGenerationSizeIncrement used at startup") \ 213318334Speter range(0, 100) \ 213418334Speter \ 213518334Speter product(uintx, TenuredGenerationSizeSupplementDecay, 2, \ 213690282Sobrien "Decay factor to TenuredGenerationSizeIncrement") \ 213718334Speter range(1, max_uintx) \ 213852558Sobrien \ 213990282Sobrien product(uintx, MaxGCPauseMillis, max_uintx - 1, \ 214052558Sobrien "Adaptive size policy maximum GC pause time goal in millisecond, "\ 214118334Speter "or (G1 Only) the maximum GC time per MMU time slice") \ 214218334Speter range(1, max_uintx - 1) \ 214318334Speter constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \ 214418334Speter \ 214518334Speter product(uintx, GCPauseIntervalMillis, 0, \ 214618334Speter "Time slice for MMU specification") \ 214718334Speter constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \ 214818334Speter \ 214990282Sobrien product(uintx, MaxGCMinorPauseMillis, max_uintx, \ 215018334Speter "Adaptive size policy maximum GC minor pause time goal " \ 215118334Speter "in millisecond") \ 215218334Speter range(0, max_uintx) \ 215318334Speter \ 215418334Speter product(uintx, GCTimeRatio, 99, \ 215518334Speter "Adaptive size policy application time to GC time ratio") \ 215618334Speter range(0, max_juint) \ 215718334Speter \ 215818334Speter product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \ 215952558Sobrien "Adaptive size scale down factor for shrinking") \ 216018334Speter range(1, max_uintx) \ 216152558Sobrien \ 216252558Sobrien product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \ 216352558Sobrien "Adaptive size decays the major cost for long major intervals") \ 216418334Speter \ 216552558Sobrien product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \ 216652558Sobrien "Time scale over which major costs decay") \ 216752558Sobrien range(0, max_uintx) \ 216852558Sobrien \ 216918334Speter product(uintx, MinSurvivorRatio, 3, \ 217090282Sobrien "Minimum ratio of young generation/survivor space size") \ 217150615Sobrien range(3, max_uintx) \ 217290282Sobrien \ 217390282Sobrien product(uintx, InitialSurvivorRatio, 8, \ 217418334Speter "Initial ratio of young generation/survivor space size") \ 217518334Speter range(0, max_uintx) \ 217618334Speter \ 217718334Speter product(size_t, BaseFootPrintEstimate, 256*M, \ 217818334Speter "Estimate of footprint other than Java Heap") \ 217918334Speter range(0, max_uintx) \ 218090282Sobrien \ 218190282Sobrien product(bool, UseGCOverheadLimit, true, \ 218218334Speter "Use policy to limit of proportion of time spent in GC " \ 218350615Sobrien "before an OutOfMemory error is thrown") \ 218450615Sobrien \ 218550615Sobrien product(uintx, GCTimeLimit, 98, \ 218650615Sobrien "Limit of the proportion of time spent in GC before " \ 218750615Sobrien "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \ 218890282Sobrien range(0, 100) \ 218990282Sobrien \ 219050615Sobrien product(uintx, GCHeapFreeLimit, 2, \ 219118334Speter "Minimum percentage of free space after a full GC before an " \ 219218334Speter "OutOfMemoryError is thrown (used with GCTimeLimit)") \ 219390282Sobrien range(0, 100) \ 219490282Sobrien \ 219550615Sobrien develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \ 219618334Speter "Number of consecutive collections before gc time limit fires") \ 219790282Sobrien range(1, max_uintx) \ 219890282Sobrien \ 219990282Sobrien product(intx, PrefetchCopyIntervalInBytes, -1, \ 220090282Sobrien "How far ahead to prefetch destination area (<= 0 means off)") \ 220152558Sobrien range(-1, max_jint) \ 220290282Sobrien \ 220318334Speter product(intx, PrefetchScanIntervalInBytes, -1, \ 220490282Sobrien "How far ahead to prefetch scan area (<= 0 means off)") \ 220590282Sobrien range(-1, max_jint) \ 220618334Speter \ 220718334Speter product(intx, PrefetchFieldsAhead, -1, \ 220890282Sobrien "How many fields ahead to prefetch in oop scan (<= 0 means off)") \ 220990282Sobrien range(-1, max_jint) \ 221090282Sobrien \ 221118334Speter diagnostic(bool, VerifyDuringStartup, false, \ 221290282Sobrien "Verify memory system before executing any Java code " \ 221390282Sobrien "during VM initialization") \ 221490282Sobrien \ 221590282Sobrien diagnostic(bool, VerifyBeforeExit, trueInDebug, \ 221690282Sobrien "Verify system before exiting") \ 221790282Sobrien \ 221890282Sobrien diagnostic(bool, VerifyBeforeGC, false, \ 221952558Sobrien "Verify memory system before GC") \ 222052558Sobrien \ 222190282Sobrien diagnostic(bool, VerifyAfterGC, false, \ 222218334Speter "Verify memory system after GC") \ 222390282Sobrien \ 222490282Sobrien diagnostic(bool, VerifyDuringGC, false, \ 222590282Sobrien "Verify memory system during GC (between phases)") \ 222690282Sobrien \ 222718334Speter diagnostic(ccstrlist, VerifySubSet, "", \ 222818334Speter "Memory sub-systems to verify when Verify*GC flag(s) " \ 222918334Speter "are enabled. One or more sub-systems can be specified " \ 223018334Speter "in a comma separated string. Sub-systems are: " \ 223118334Speter "threads, heap, symbol_table, string_table, codecache, " \ 223218334Speter "dictionary, classloader_data_graph, metaspace, jni_handles, " \ 223390282Sobrien "codecache_oops") \ 223490282Sobrien \ 223590282Sobrien diagnostic(bool, GCParallelVerificationEnabled, true, \ 223690282Sobrien "Enable parallel memory system verification") \ 223790282Sobrien \ 223818334Speter diagnostic(bool, DeferInitialCardMark, false, \ 223918334Speter "When +ReduceInitialCardMarks, explicitly defer any that " \ 224018334Speter "may arise from new_pre_store_barrier") \ 224118334Speter \ 224218334Speter product(bool, UseCondCardMark, false, \ 224318334Speter "Check for already marked card before updating card table") \ 224418334Speter \ 224518334Speter diagnostic(bool, VerifyRememberedSets, false, \ 224652558Sobrien "Verify GC remembered sets") \ 224718334Speter \ 224818334Speter diagnostic(bool, VerifyObjectStartArray, true, \ 224918334Speter "Verify GC object start array if verify before/after") \ 225018334Speter \ 225118334Speter product(bool, DisableExplicitGC, false, \ 225218334Speter "Ignore calls to System.gc()") \ 225318334Speter \ 225418334Speter notproduct(bool, CheckMemoryInitialization, false, \ 225518334Speter "Check memory initialization") \ 225618334Speter \ 225718334Speter diagnostic(bool, BindCMSThreadToCPU, false, \ 225818334Speter "Bind CMS Thread to CPU if possible") \ 225918334Speter \ 226018334Speter diagnostic(uintx, CPUForCMSThread, 0, \ 226118334Speter "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \ 226290282Sobrien range(0, max_juint) \ 226390282Sobrien \ 226490282Sobrien product(bool, BindGCTaskThreadsToCPUs, false, \ 226590282Sobrien "Bind GCTaskThreads to CPUs if possible") \ 226690282Sobrien \ 226790282Sobrien product(bool, UseGCTaskAffinity, false, \ 226890282Sobrien "Use worker affinity when asking for GCTasks") \ 226990282Sobrien \ 227090282Sobrien product(uintx, ProcessDistributionStride, 4, \ 227190282Sobrien "Stride through processors when distributing processes") \ 227290282Sobrien range(0, max_juint) \ 227390282Sobrien \ 227490282Sobrien product(uintx, CMSCoordinatorYieldSleepCount, 10, \ 227590282Sobrien "Number of times the coordinator GC thread will sleep while " \ 227690282Sobrien "yielding before giving up and resuming GC") \ 227790282Sobrien range(0, max_juint) \ 227818334Speter \ 227918334Speter product(uintx, CMSYieldSleepCount, 0, \ 228018334Speter "Number of times a GC thread (minus the coordinator) " \ 228118334Speter "will sleep while yielding before giving up and resuming GC") \ 228290282Sobrien range(0, max_juint) \ 228390282Sobrien \ 228418334Speter product(bool, PrintGC, false, \ 228518334Speter "Print message at garbage collection. " \ 228690282Sobrien "Deprecated, use -Xlog:gc instead.") \ 228790282Sobrien \ 228890282Sobrien product(bool, PrintGCDetails, false, \ 228990282Sobrien "Print more details at garbage collection. " \ 229090282Sobrien "Deprecated, use -Xlog:gc* instead.") \ 229190282Sobrien \ 229218334Speter develop(intx, ConcGCYieldTimeout, 0, \ 229318334Speter "If non-zero, assert that GC threads yield within this " \ 229418334Speter "number of milliseconds") \ 229518334Speter range(0, max_intx) \ 229690282Sobrien \ 229790282Sobrien develop(bool, TraceFinalizerRegistration, false, \ 229890282Sobrien "Trace registration of final references") \ 229990282Sobrien \ 230090282Sobrien notproduct(bool, TraceScavenge, false, \ 230118334Speter "Trace scavenge") \ 230218334Speter \ 230318334Speter product(bool, IgnoreEmptyClassPaths, false, \ 230418334Speter "Ignore empty path elements in -classpath") \ 230590282Sobrien \ 230690282Sobrien product(size_t, InitialBootClassLoaderMetaspaceSize, \ 230790282Sobrien NOT_LP64(2200*K) LP64_ONLY(4*M), \ 230890282Sobrien "Initial size of the boot class loader data metaspace") \ 230990282Sobrien range(30*K, max_uintx/BytesPerWord) \ 231018334Speter constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\ 231118334Speter \ 231218334Speter product(bool, TraceYoungGenTime, false, \ 231318334Speter "Trace accumulated time for young collection") \ 231418334Speter \ 231518334Speter product(bool, TraceOldGenTime, false, \ 231618334Speter "Trace accumulated time for old collection") \ 231752558Sobrien \ 231818334Speter product(bool, PrintHeapAtSIGBREAK, true, \ 231918334Speter "Print heap layout in response to SIGBREAK") \ 232052558Sobrien \ 232152558Sobrien manageable(bool, PrintClassHistogram, false, \ 232252558Sobrien "Print a histogram of class instances") \ 232352558Sobrien \ 232418334Speter develop(bool, TraceGCTaskManager, false, \ 232590282Sobrien "Trace actions of the GC task manager") \ 232618334Speter \ 232718334Speter develop(bool, TraceGCTaskQueue, false, \ 232890282Sobrien "Trace actions of the GC task queues") \ 232918334Speter \ 233018334Speter develop(bool, TraceParallelOldGCMarkingPhase, false, \ 233118334Speter "Trace marking phase in ParallelOldGC") \ 233290282Sobrien \ 233318334Speter develop(bool, TraceParallelOldGCDensePrefix, false, \ 233490282Sobrien "Trace dense prefix computation for ParallelOldGC") \ 233590282Sobrien \ 233690282Sobrien develop(bool, IgnoreLibthreadGPFault, false, \ 233790282Sobrien "Suppress workaround for libthread GP fault") \ 233890282Sobrien \ 233990282Sobrien experimental(double, ObjectCountCutOffPercent, 0.5, \ 234090282Sobrien "The percentage of the used heap that the instances of a class " \ 234118334Speter "must occupy for the class to generate a trace event") \ 234218334Speter range(0.0, 100.0) \ 234318334Speter \ 234418334Speter /* JVMTI heap profiling */ \ 234518334Speter \ 234618334Speter diagnostic(bool, TraceJVMTIObjectTagging, false, \ 234718334Speter "Trace JVMTI object tagging calls") \ 234818334Speter \ 234918334Speter diagnostic(bool, VerifyBeforeIteration, false, \ 235018334Speter "Verify memory system before JVMTI iteration") \ 235118334Speter \ 235218334Speter /* compiler interface */ \ 235390282Sobrien \ 235418334Speter develop(bool, CIPrintCompilerName, false, \ 235518334Speter "when CIPrint is active, print the name of the active compiler") \ 235652558Sobrien \ 235790282Sobrien diagnostic(bool, CIPrintCompileQueue, false, \ 235896289Sobrien "display the contents of the compile queue whenever a " \ 235918334Speter "compilation is enqueued") \ 236090282Sobrien \ 236190282Sobrien develop(bool, CIPrintRequests, false, \ 236290282Sobrien "display every request for compilation") \ 236390282Sobrien \ 236490282Sobrien product(bool, CITime, false, \ 236590282Sobrien "collect timing information for compilation") \ 236690282Sobrien \ 236790282Sobrien develop(bool, CITimeVerbose, false, \ 236890282Sobrien "be more verbose in compilation timings") \ 236990282Sobrien \ 237090282Sobrien develop(bool, CITimeEach, false, \ 237190282Sobrien "display timing information after each successful compilation") \ 237290282Sobrien \ 237390282Sobrien develop(bool, CICountOSR, false, \ 237490282Sobrien "use a separate counter when assigning ids to osr compilations") \ 237590282Sobrien \ 237690282Sobrien develop(bool, CICompileNatives, true, \ 237790282Sobrien "compile native methods if supported by the compiler") \ 237890282Sobrien \ 237990282Sobrien develop_pd(bool, CICompileOSR, \ 238090282Sobrien "compile on stack replacement methods if supported by the " \ 238190282Sobrien "compiler") \ 238218334Speter \ 238318334Speter develop(bool, CIPrintMethodCodes, false, \ 238418334Speter "print method bytecodes of the compiled code") \ 238518334Speter \ 238618334Speter develop(bool, CIPrintTypeFlow, false, \ 238750615Sobrien "print the results of ciTypeFlow analysis") \ 238890282Sobrien \ 238952558Sobrien develop(bool, CITraceTypeFlow, false, \ 239018334Speter "detailed per-bytecode tracing of ciTypeFlow analysis") \ 239190282Sobrien \ 239290282Sobrien develop(intx, OSROnlyBCI, -1, \ 239390282Sobrien "OSR only at this bci. Negative values mean exclude that bci") \ 239490282Sobrien \ 239590282Sobrien /* compiler */ \ 239690282Sobrien \ 239790282Sobrien /* notice: the max range value here is max_jint, not max_intx */ \ 239890282Sobrien /* because of overflow issue */ \ 239990282Sobrien product(intx, CICompilerCount, CI_COMPILER_COUNT, \ 240090282Sobrien "Number of compiler threads to run") \ 240190282Sobrien range(0, max_jint) \ 240290282Sobrien constraint(CICompilerCountConstraintFunc, AfterErgo) \ 240390282Sobrien \ 240490282Sobrien product(intx, CompilationPolicyChoice, 0, \ 240518334Speter "which compilation policy (0-3)") \ 240690282Sobrien range(0, 3) \ 240790282Sobrien \ 240890282Sobrien develop(bool, UseStackBanging, true, \ 240990282Sobrien "use stack banging for stack overflow checks (required for " \ 241090282Sobrien "proper StackOverflow handling; disable only to measure cost " \ 241190282Sobrien "of stackbanging)") \ 241290282Sobrien \ 241390282Sobrien develop(bool, UseStrictFP, true, \ 241490282Sobrien "use strict fp if modifier strictfp is set") \ 241590282Sobrien \ 241690282Sobrien develop(bool, GenerateSynchronizationCode, true, \ 241790282Sobrien "generate locking/unlocking code for synchronized methods and " \ 241890282Sobrien "monitors") \ 241990282Sobrien \ 242090282Sobrien develop(bool, GenerateRangeChecks, true, \ 242190282Sobrien "Generate range checks for array accesses") \ 242290282Sobrien \ 242390282Sobrien diagnostic_pd(bool, ImplicitNullChecks, \ 242490282Sobrien "Generate code for implicit null checks") \ 242590282Sobrien \ 242690282Sobrien product_pd(bool, TrapBasedNullChecks, \ 242790282Sobrien "Generate code for null checks that uses a cmp and trap " \ 242890282Sobrien "instruction raising SIGTRAP. This is only used if an access to" \ 242990282Sobrien "null (+offset) will not raise a SIGSEGV, i.e.," \ 243090282Sobrien "ImplicitNullChecks don't work (PPC64).") \ 243190282Sobrien \ 243290282Sobrien product(bool, PrintSafepointStatistics, false, \ 243318334Speter "Print statistics about safepoint synchronization") \ 243418334Speter \ 243518334Speter product(intx, PrintSafepointStatisticsCount, 300, \ 243618334Speter "Total number of safepoint statistics collected " \ 243718334Speter "before printing them out") \ 243890282Sobrien range(1, max_intx) \ 243950615Sobrien \ 244050615Sobrien product(intx, PrintSafepointStatisticsTimeout, -1, \ 244150615Sobrien "Print safepoint statistics only when safepoint takes " \ 244290282Sobrien "more than PrintSafepointSatisticsTimeout in millis") \ 244350615Sobrien LP64_ONLY(range(-1, max_intx/MICROUNITS)) \ 244418334Speter NOT_LP64(range(-1, max_intx)) \ 244590282Sobrien \ 244690282Sobrien product(bool, Inline, true, \ 244790282Sobrien "Enable inlining") \ 244890282Sobrien \ 244950615Sobrien product(bool, ClipInlining, true, \ 245018334Speter "Clip inlining if aggregate method exceeds DesiredMethodLimit") \ 245118334Speter \ 245218334Speter develop(bool, UseCHA, true, \ 245318334Speter "Enable CHA") \ 245490282Sobrien \ 245518334Speter product(bool, UseTypeProfile, true, \ 245690282Sobrien "Check interpreter profile for historically monomorphic calls") \ 245790282Sobrien \ 245890282Sobrien diagnostic(bool, PrintInlining, false, \ 245996289Sobrien "Print inlining optimizations") \ 246090282Sobrien \ 246190282Sobrien product(bool, UsePopCountInstruction, false, \ 246290282Sobrien "Use population count instruction") \ 246350615Sobrien \ 246490282Sobrien develop(bool, EagerInitialization, false, \ 246590282Sobrien "Eagerly initialize classes if possible") \ 246690282Sobrien \ 246790282Sobrien diagnostic(bool, LogTouchedMethods, false, \ 246890282Sobrien "Log methods which have been ever touched in runtime") \ 246990282Sobrien \ 247090282Sobrien diagnostic(bool, PrintTouchedMethodsAtExit, false, \ 247190282Sobrien "Print all methods that have been ever touched in runtime") \ 247290282Sobrien \ 247350615Sobrien develop(bool, TraceMethodReplacement, false, \ 247490282Sobrien "Print when methods are replaced do to recompilation") \ 247590282Sobrien \ 247690282Sobrien develop(bool, PrintMethodFlushing, false, \ 247790282Sobrien "Print the nmethods being flushed") \ 247850615Sobrien \ 247918334Speter diagnostic(bool, PrintMethodFlushingStatistics, false, \ 248050615Sobrien "print statistics about method flushing") \ 248190282Sobrien \ 248250615Sobrien diagnostic(intx, HotMethodDetectionLimit, 100000, \ 248390282Sobrien "Number of compiled code invocations after which " \ 248450615Sobrien "the method is considered as hot by the flusher") \ 248590282Sobrien range(1, max_jint) \ 248690282Sobrien \ 248750615Sobrien diagnostic(intx, MinPassesBeforeFlush, 10, \ 248890282Sobrien "Minimum number of sweeper passes before an nmethod " \ 248990282Sobrien "can be flushed") \ 249090282Sobrien range(0, max_intx) \ 249150615Sobrien \ 249250615Sobrien product(bool, UseCodeAging, true, \ 249390282Sobrien "Insert counter to detect warm methods") \ 249490282Sobrien \ 249590282Sobrien diagnostic(bool, StressCodeAging, false, \ 249690282Sobrien "Start with counters compiled in") \ 249790282Sobrien \ 249890282Sobrien develop(bool, UseRelocIndex, false, \ 249990282Sobrien "Use an index to speed random access to relocations") \ 250090282Sobrien \ 250190282Sobrien develop(bool, StressCodeBuffers, false, \ 250290282Sobrien "Exercise code buffer expansion and other rare state changes") \ 250350615Sobrien \ 250418334Speter diagnostic(bool, DebugNonSafepoints, trueInDebug, \ 250518334Speter "Generate extra debugging information for non-safepoints in " \ 250618334Speter "nmethods") \ 250752558Sobrien \ 250852558Sobrien product(bool, PrintVMOptions, false, \ 250952558Sobrien "Print flags that appeared on the command line") \ 251018334Speter \ 251118334Speter product(bool, IgnoreUnrecognizedVMOptions, false, \ 251218334Speter "Ignore unrecognized VM options") \ 251390282Sobrien \ 251490282Sobrien product(bool, PrintCommandLineFlags, false, \ 251590282Sobrien "Print flags specified on command line or set by ergonomics") \ 251690282Sobrien \ 251790282Sobrien product(bool, PrintFlagsInitial, false, \ 251890282Sobrien "Print all VM flags before argument processing and exit VM") \ 251990282Sobrien \ 252090282Sobrien product(bool, PrintFlagsFinal, false, \ 252190282Sobrien "Print all VM flags after argument and ergonomic processing") \ 252290282Sobrien \ 252390282Sobrien notproduct(bool, PrintFlagsWithComments, false, \ 252490282Sobrien "Print all VM flags with default values and descriptions and " \ 252590282Sobrien "exit") \ 252690282Sobrien \ 252790282Sobrien product(bool, PrintFlagsRanges, false, \ 252890282Sobrien "Print VM flags and their ranges and exit VM") \ 252990282Sobrien \ 253090282Sobrien diagnostic(bool, SerializeVMOutput, true, \ 253190282Sobrien "Use a mutex to serialize output to tty and LogFile") \ 253290282Sobrien \ 253390282Sobrien diagnostic(bool, DisplayVMOutput, true, \ 253490282Sobrien "Display all VM output on the tty, independently of LogVMOutput") \ 253590282Sobrien \ 253690282Sobrien diagnostic(bool, LogVMOutput, false, \ 253790282Sobrien "Save VM output to LogFile") \ 253890282Sobrien \ 253990282Sobrien diagnostic(ccstr, LogFile, NULL, \ 254090282Sobrien "If LogVMOutput or LogCompilation is on, save VM output to " \ 254118334Speter "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)")\ 254218334Speter \ 254318334Speter product(ccstr, ErrorFile, NULL, \ 254490282Sobrien "If an error occurs, save the error data to this file " \ 254590282Sobrien "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \ 254690282Sobrien \ 254790282Sobrien product(bool, DisplayVMOutputToStderr, false, \ 254890282Sobrien "If DisplayVMOutput is true, display all VM output to stderr") \ 254990282Sobrien \ 255018334Speter product(bool, DisplayVMOutputToStdout, false, \ 255190282Sobrien "If DisplayVMOutput is true, display all VM output to stdout") \ 255218334Speter \ 255396289Sobrien product(bool, UseHeavyMonitors, false, \ 255496289Sobrien "use heavyweight instead of lightweight Java monitors") \ 255596289Sobrien \ 255696289Sobrien product(bool, PrintStringTableStatistics, false, \ 255796289Sobrien "print statistics about the StringTable and SymbolTable") \ 255890282Sobrien \ 255990282Sobrien diagnostic(bool, VerifyStringTableAtExit, false, \ 256090282Sobrien "verify StringTable contents at exit") \ 256190282Sobrien \ 256290282Sobrien notproduct(bool, PrintSymbolTableSizeHistogram, false, \ 256318334Speter "print histogram of the symbol table") \ 256490282Sobrien \ 256590282Sobrien notproduct(bool, ExitVMOnVerifyError, false, \ 256690282Sobrien "standard exit from VM if bytecode verify error " \ 256790282Sobrien "(only in debug mode)") \ 256890282Sobrien \ 256990282Sobrien diagnostic(ccstr, AbortVMOnException, NULL, \ 257090282Sobrien "Call fatal if this exception is thrown. Example: " \ 257118334Speter "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \ 257218334Speter \ 257390282Sobrien diagnostic(ccstr, AbortVMOnExceptionMessage, NULL, \ 257490282Sobrien "Call fatal if the exception pointed by AbortVMOnException " \ 257590282Sobrien "has this message") \ 257690282Sobrien \ 257790282Sobrien develop(bool, DebugVtables, false, \ 257890282Sobrien "add debugging code to vtable dispatch") \ 257918334Speter \ 258090282Sobrien notproduct(bool, PrintVtableStats, false, \ 258190282Sobrien "print vtables stats at end of run") \ 258290282Sobrien \ 258390282Sobrien develop(bool, TraceCreateZombies, false, \ 258490282Sobrien "trace creation of zombie nmethods") \ 258590282Sobrien \ 258696289Sobrien notproduct(bool, IgnoreLockingAssertions, false, \ 258796289Sobrien "disable locking assertions (for speed)") \ 258896289Sobrien \ 258996289Sobrien product(bool, RangeCheckElimination, true, \ 259018334Speter "Eliminate range checks") \ 259118334Speter \ 259218334Speter develop_pd(bool, UncommonNullCast, \ 259318334Speter "track occurrences of null in casts; adjust compiler tactics") \ 259418334Speter \ 259518334Speter develop(bool, TypeProfileCasts, true, \ 259618334Speter "treat casts like calls for purposes of type profiling") \ 259718334Speter \ 259818334Speter develop(bool, DelayCompilationDuringStartup, true, \ 259918334Speter "Delay invoking the compiler until main application class is " \ 260018334Speter "loaded") \ 260118334Speter \ 260272566Sobrien develop(bool, CompileTheWorld, false, \ 260318334Speter "Compile all methods in all classes in bootstrap class path " \ 260450615Sobrien "(stress test)") \ 260590282Sobrien \ 260650615Sobrien develop(bool, CompileTheWorldPreloadClasses, true, \ 260750615Sobrien "Preload all classes used by a class before start loading") \ 260850615Sobrien \ 260950615Sobrien notproduct(intx, CompileTheWorldSafepointInterval, 100, \ 261018334Speter "Force a safepoint every n compiles so sweeper can keep up") \ 261190282Sobrien \ 261218334Speter develop(bool, FillDelaySlots, true, \ 261390282Sobrien "Fill delay slots (on SPARC only)") \ 261418334Speter \ 261550615Sobrien develop(bool, TimeLivenessAnalysis, false, \ 261650615Sobrien "Time computation of bytecode liveness analysis") \ 261750615Sobrien \ 261818334Speter develop(bool, TraceLivenessGen, false, \ 261990282Sobrien "Trace the generation of liveness analysis information") \ 262090282Sobrien \ 262190282Sobrien notproduct(bool, TraceLivenessQuery, false, \ 262290282Sobrien "Trace queries of liveness analysis information") \ 262390282Sobrien \ 262490282Sobrien notproduct(bool, CollectIndexSetStatistics, false, \ 262590282Sobrien "Collect information about IndexSets") \ 262690282Sobrien \ 262790282Sobrien develop(bool, UseLoopSafepoints, true, \ 262890282Sobrien "Generate Safepoint nodes in every loop") \ 262990282Sobrien \ 263090282Sobrien develop(intx, FastAllocateSizeLimit, 128*K, \ 263190282Sobrien /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ \ 263290282Sobrien "Inline allocations larger than this in doublewords must go slow")\ 263390282Sobrien \ 263490282Sobrien product(bool, AggressiveOpts, false, \ 263590282Sobrien "Enable aggressive optimizations - see arguments.cpp") \ 263618334Speter \ 263718334Speter product_pd(bool, CompactStrings, \ 263890282Sobrien "Enable Strings to use single byte chars in backing store") \ 263990282Sobrien \ 264090282Sobrien product_pd(uintx, TypeProfileLevel, \ 264190282Sobrien "=XYZ, with Z: Type profiling of arguments at call; " \ 264218334Speter "Y: Type profiling of return value at call; " \ 264390282Sobrien "X: Type profiling of parameters to methods; " \ 264490282Sobrien "X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods") \ 264590282Sobrien constraint(TypeProfileLevelConstraintFunc, AfterErgo) \ 264690282Sobrien \ 264790282Sobrien product(intx, TypeProfileArgsLimit, 2, \ 264890282Sobrien "max number of call arguments to consider for type profiling") \ 264918334Speter range(0, 16) \ 265090282Sobrien \ 265190282Sobrien product(intx, TypeProfileParmsLimit, 2, \ 265218334Speter "max number of incoming parameters to consider for type profiling"\ 265390282Sobrien ", -1 for all") \ 265490282Sobrien range(-1, 64) \ 265590282Sobrien \ 265690282Sobrien /* statistics */ \ 265790282Sobrien develop(bool, CountCompiledCalls, false, \ 265890282Sobrien "Count method invocations") \ 265990282Sobrien \ 266090282Sobrien notproduct(bool, CountRuntimeCalls, false, \ 266190282Sobrien "Count VM runtime calls") \ 266290282Sobrien \ 266390282Sobrien develop(bool, CountJNICalls, false, \ 266490282Sobrien "Count jni method invocations") \ 266590282Sobrien \ 266690282Sobrien notproduct(bool, CountJVMCalls, false, \ 266790282Sobrien "Count jvm method invocations") \ 266890282Sobrien \ 266990282Sobrien notproduct(bool, CountRemovableExceptions, false, \ 267090282Sobrien "Count exceptions that could be replaced by branches due to " \ 267190282Sobrien "inlining") \ 267290282Sobrien \ 267390282Sobrien notproduct(bool, ICMissHistogram, false, \ 267490282Sobrien "Produce histogram of IC misses") \ 267590282Sobrien \ 267690282Sobrien /* interpreter */ \ 267790282Sobrien product_pd(bool, RewriteBytecodes, \ 267890282Sobrien "Allow rewriting of bytecodes (bytecodes are not immutable)") \ 267990282Sobrien \ 268090282Sobrien product_pd(bool, RewriteFrequentPairs, \ 268190282Sobrien "Rewrite frequently used bytecode pairs into a single bytecode") \ 268290282Sobrien \ 268390282Sobrien diagnostic(bool, PrintInterpreter, false, \ 268490282Sobrien "Print the generated interpreter code") \ 268590282Sobrien \ 268690282Sobrien product(bool, UseInterpreter, true, \ 268790282Sobrien "Use interpreter for non-compiled methods") \ 268890282Sobrien \ 268990282Sobrien develop(bool, UseFastSignatureHandlers, true, \ 269090282Sobrien "Use fast signature handlers for native calls") \ 269190282Sobrien \ 269290282Sobrien product(bool, UseLoopCounter, true, \ 269390282Sobrien "Increment invocation counter on backward branch") \ 269490282Sobrien \ 269590282Sobrien product_pd(bool, UseOnStackReplacement, \ 269690282Sobrien "Use on stack replacement, calls runtime if invoc. counter " \ 269790282Sobrien "overflows in loop") \ 269890282Sobrien \ 269990282Sobrien notproduct(bool, TraceOnStackReplacement, false, \ 270090282Sobrien "Trace on stack replacement") \ 270190282Sobrien \ 270290282Sobrien product_pd(bool, PreferInterpreterNativeStubs, \ 270390282Sobrien "Use always interpreter stubs for native methods invoked via " \ 270490282Sobrien "interpreter") \ 270590282Sobrien \ 270690282Sobrien develop(bool, CountBytecodes, false, \ 270790282Sobrien "Count number of bytecodes executed") \ 270890282Sobrien \ 270990282Sobrien develop(bool, PrintBytecodeHistogram, false, \ 271090282Sobrien "Print histogram of the executed bytecodes") \ 271190282Sobrien \ 271290282Sobrien develop(bool, PrintBytecodePairHistogram, false, \ 271390282Sobrien "Print histogram of the executed bytecode pairs") \ 271490282Sobrien \ 271590282Sobrien diagnostic(bool, PrintSignatureHandlers, false, \ 271690282Sobrien "Print code generated for native method signature handlers") \ 271790282Sobrien \ 271890282Sobrien develop(bool, VerifyOops, false, \ 271990282Sobrien "Do plausibility checks for oops") \ 272090282Sobrien \ 272190282Sobrien develop(bool, CheckUnhandledOops, false, \ 272290282Sobrien "Check for unhandled oops in VM code") \ 272390282Sobrien \ 272490282Sobrien develop(bool, VerifyJNIFields, trueInDebug, \ 272590282Sobrien "Verify jfieldIDs for instance fields") \ 272690282Sobrien \ 272790282Sobrien notproduct(bool, VerifyJNIEnvThread, false, \ 272890282Sobrien "Verify JNIEnv.thread == Thread::current() when entering VM " \ 272990282Sobrien "from JNI") \ 273090282Sobrien \ 273190282Sobrien develop(bool, VerifyFPU, false, \ 273290282Sobrien "Verify FPU state (check for NaN's, etc.)") \ 273390282Sobrien \ 273490282Sobrien develop(bool, VerifyThread, false, \ 273590282Sobrien "Watch the thread register for corruption (SPARC only)") \ 273690282Sobrien \ 273790282Sobrien develop(bool, VerifyActivationFrameSize, false, \ 273890282Sobrien "Verify that activation frame didn't become smaller than its " \ 273990282Sobrien "minimal size") \ 274090282Sobrien \ 274190282Sobrien develop(bool, TraceFrequencyInlining, false, \ 274290282Sobrien "Trace frequency based inlining") \ 274390282Sobrien \ 274490282Sobrien develop_pd(bool, InlineIntrinsics, \ 274590282Sobrien "Inline intrinsics that can be statically resolved") \ 274690282Sobrien \ 274718334Speter product_pd(bool, ProfileInterpreter, \ 274818334Speter "Profile at the bytecode level during interpretation") \ 274918334Speter \ 275018334Speter develop(bool, TraceProfileInterpreter, false, \ 275118334Speter "Trace profiling at the bytecode level during interpretation. " \ 275218334Speter "This outputs the profiling information collected to improve " \ 275318334Speter "jit compilation.") \ 275490282Sobrien \ 275590282Sobrien develop_pd(bool, ProfileTraps, \ 275650615Sobrien "Profile deoptimization traps at the bytecode level") \ 275790282Sobrien \ 275818334Speter product(intx, ProfileMaturityPercentage, 20, \ 275990282Sobrien "number of method invocations/branches (expressed as % of " \ 276018334Speter "CompileThreshold) before using the method's profile") \ 276190282Sobrien range(0, 100) \ 276290282Sobrien \ 276390282Sobrien diagnostic(bool, PrintMethodData, false, \ 276490282Sobrien "Print the results of +ProfileInterpreter at end of run") \ 276518334Speter \ 276690282Sobrien develop(bool, VerifyDataPointer, trueInDebug, \ 276790282Sobrien "Verify the method data pointer during interpreter profiling") \ 276890282Sobrien \ 276990282Sobrien develop(bool, VerifyCompiledCode, false, \ 277090282Sobrien "Include miscellaneous runtime verifications in nmethod code; " \ 277190282Sobrien "default off because it disturbs nmethod size heuristics") \ 277290282Sobrien \ 277390282Sobrien notproduct(bool, CrashGCForDumpingJavaThread, false, \ 277490282Sobrien "Manually make GC thread crash then dump java stack trace; " \ 277550615Sobrien "Test only") \ 277656392Sobrien \ 277756392Sobrien /* compilation */ \ 277890282Sobrien product(bool, UseCompiler, true, \ 277956392Sobrien "Use Just-In-Time compilation") \ 278090282Sobrien \ 278190282Sobrien develop(bool, TraceCompilationPolicy, false, \ 278290282Sobrien "Trace compilation policy") \ 278390282Sobrien \ 278490282Sobrien develop(bool, TimeCompilationPolicy, false, \ 278552558Sobrien "Time the compilation policy") \ 278690282Sobrien \ 278790282Sobrien product(bool, UseCounterDecay, true, \ 278890282Sobrien "Adjust recompilation counters") \ 278990282Sobrien \ 279090282Sobrien develop(intx, CounterHalfLifeTime, 30, \ 279190282Sobrien "Half-life time of invocation counters (in seconds)") \ 279290282Sobrien \ 279390282Sobrien develop(intx, CounterDecayMinIntervalLength, 500, \ 279452558Sobrien "The minimum interval (in milliseconds) between invocation of " \ 279590282Sobrien "CounterDecay") \ 279690282Sobrien \ 279790282Sobrien product(bool, AlwaysCompileLoopMethods, false, \ 279890282Sobrien "When using recompilation, never interpret methods " \ 279990282Sobrien "containing loops") \ 280090282Sobrien \ 280190282Sobrien product(bool, DontCompileHugeMethods, true, \ 280218334Speter "Do not compile methods > HugeMethodLimit") \ 280318334Speter \ 280490282Sobrien /* Bytecode escape analysis estimation. */ \ 280590282Sobrien product(bool, EstimateArgEscape, true, \ 280650615Sobrien "Analyze bytecodes to estimate escape state of arguments") \ 280750615Sobrien \ 280818334Speter product(intx, BCEATraceLevel, 0, \ 280990282Sobrien "How much tracing to do of bytecode escape analysis estimates " \ 281052558Sobrien "(0-3)") \ 281190282Sobrien range(0, 3) \ 281290282Sobrien \ 281350615Sobrien product(intx, MaxBCEAEstimateLevel, 5, \ 281418334Speter "Maximum number of nested calls that are analyzed by BC EA") \ 281550615Sobrien range(0, max_jint) \ 281650615Sobrien \ 281790282Sobrien product(intx, MaxBCEAEstimateSize, 150, \ 281890282Sobrien "Maximum bytecode size of a method to be analyzed by BC EA") \ 281918334Speter range(0, max_jint) \ 282090282Sobrien \ 282190282Sobrien product(intx, AllocatePrefetchStyle, 1, \ 282252558Sobrien "0 = no prefetch, " \ 282390282Sobrien "1 = generate prefetch instructions for each allocation, " \ 282490282Sobrien "2 = use TLAB watermark to gate allocation prefetch, " \ 282590282Sobrien "3 = generate one prefetch instruction per cache line") \ 282690282Sobrien range(0, 3) \ 282790282Sobrien \ 282890282Sobrien product(intx, AllocatePrefetchDistance, -1, \ 282990282Sobrien "Distance to prefetch ahead of allocation pointer. " \ 283090282Sobrien "-1: use system-specific value (automatically determined") \ 283190282Sobrien constraint(AllocatePrefetchDistanceConstraintFunc, AfterMemoryInit)\ 283290282Sobrien \ 283390282Sobrien product(intx, AllocatePrefetchLines, 3, \ 283490282Sobrien "Number of lines to prefetch ahead of array allocation pointer") \ 283590282Sobrien range(1, 64) \ 283690282Sobrien \ 283752558Sobrien product(intx, AllocateInstancePrefetchLines, 1, \ 283890282Sobrien "Number of lines to prefetch ahead of instance allocation " \ 283990282Sobrien "pointer") \ 284090282Sobrien range(1, 64) \ 284190282Sobrien \ 284290282Sobrien product(intx, AllocatePrefetchStepSize, 16, \ 284390282Sobrien "Step size in bytes of sequential prefetch instructions") \ 284452558Sobrien range(1, 512) \ 284590282Sobrien constraint(AllocatePrefetchStepSizeConstraintFunc,AfterMemoryInit)\ 284690282Sobrien \ 284790282Sobrien product(intx, AllocatePrefetchInstr, 0, \ 284852558Sobrien "Select instruction to prefetch ahead of allocation pointer") \ 284990282Sobrien constraint(AllocatePrefetchInstrConstraintFunc, AfterMemoryInit) \ 285090282Sobrien \ 285190282Sobrien /* deoptimization */ \ 285290282Sobrien develop(bool, TraceDeoptimization, false, \ 285390282Sobrien "Trace deoptimization") \ 285490282Sobrien \ 285590282Sobrien develop(bool, PrintDeoptimizationDetails, false, \ 285690282Sobrien "Print more information about deoptimization") \ 285790282Sobrien \ 285890282Sobrien develop(bool, DebugDeoptimization, false, \ 285990282Sobrien "Tracing various information while debugging deoptimization") \ 286090282Sobrien \ 286190282Sobrien product(intx, SelfDestructTimer, 0, \ 286290282Sobrien "Will cause VM to terminate after a given time (in minutes) " \ 286390282Sobrien "(0 means off)") \ 286490282Sobrien range(0, max_intx) \ 286590282Sobrien \ 286652558Sobrien product(intx, MaxJavaStackTraceDepth, 1024, \ 286790282Sobrien "The maximum number of lines in the stack trace for Java " \ 286890282Sobrien "exceptions (0 means all)") \ 286990282Sobrien range(0, max_jint/2) \ 287090282Sobrien \ 287190282Sobrien /* notice: the max range value here is max_jint, not max_intx */ \ 287290282Sobrien /* because of overflow issue */ \ 287390282Sobrien diagnostic(intx, GuaranteedSafepointInterval, 1000, \ 287450615Sobrien "Guarantee a safepoint (at least) every so many milliseconds " \ 287590282Sobrien "(0 means none)") \ 287618334Speter range(0, max_jint) \ 287718334Speter \ 287818334Speter product(intx, SafepointTimeoutDelay, 10000, \ 287918334Speter "Delay in milliseconds for option SafepointTimeout") \ 288090282Sobrien LP64_ONLY(range(0, max_intx/MICROUNITS)) \ 288190282Sobrien NOT_LP64(range(0, max_intx)) \ 288290282Sobrien \ 288318334Speter product(intx, NmethodSweepActivity, 10, \ 288490282Sobrien "Removes cold nmethods from code cache if > 0. Higher values " \ 288590282Sobrien "result in more aggressive sweeping") \ 288690282Sobrien range(0, 2000) \ 288790282Sobrien \ 288890282Sobrien notproduct(bool, LogSweeper, false, \ 288996289Sobrien "Keep a ring buffer of sweeper activity") \ 289090282Sobrien \ 289190282Sobrien notproduct(intx, SweeperLogEntries, 1024, \ 289290282Sobrien "Number of records in the ring buffer of sweeper activity") \ 289390282Sobrien \ 289490282Sobrien notproduct(intx, MemProfilingInterval, 500, \ 289590282Sobrien "Time between each invocation of the MemProfiler") \ 289690282Sobrien \ 289790282Sobrien develop(intx, MallocCatchPtr, -1, \ 289850615Sobrien "Hit breakpoint when mallocing/freeing this pointer") \ 289990282Sobrien \ 290090282Sobrien notproduct(ccstrlist, SuppressErrorAt, "", \ 290190282Sobrien "List of assertions (file:line) to muzzle") \ 290290282Sobrien \ 290390282Sobrien develop(intx, StackPrintLimit, 100, \ 290490282Sobrien "number of stack frames to print in VM-level stack dump") \ 290552558Sobrien \ 290690282Sobrien notproduct(intx, MaxElementPrintSize, 256, \ 290790282Sobrien "maximum number of elements to print") \ 290852558Sobrien \ 290990282Sobrien notproduct(intx, MaxSubklassPrintSize, 4, \ 291050615Sobrien "maximum number of subklasses to print when printing klass") \ 291118334Speter \ 291250615Sobrien product(intx, MaxInlineLevel, 9, \ 291318334Speter "maximum number of nested calls that are inlined") \ 291490282Sobrien range(0, max_jint) \ 291590282Sobrien \ 291652558Sobrien product(intx, MaxRecursiveInlineLevel, 1, \ 291750615Sobrien "maximum number of nested recursive calls that are inlined") \ 291850615Sobrien range(0, max_jint) \ 291950615Sobrien \ 292050615Sobrien develop(intx, MaxForceInlineLevel, 100, \ 292150615Sobrien "maximum number of nested calls that are forced for inlining " \ 292250615Sobrien "(using CompileCommand or marked w/ @ForceInline)") \ 292350615Sobrien range(0, max_jint) \ 292490282Sobrien \ 292590282Sobrien product_pd(intx, InlineSmallCode, \ 292690282Sobrien "Only inline already compiled methods if their code size is " \ 292790282Sobrien "less than this") \ 292890282Sobrien range(0, max_jint) \ 292990282Sobrien \ 293090282Sobrien product(intx, MaxInlineSize, 35, \ 293190282Sobrien "The maximum bytecode size of a method to be inlined") \ 293290282Sobrien range(0, max_jint) \ 293390282Sobrien \ 293490282Sobrien product_pd(intx, FreqInlineSize, \ 293590282Sobrien "The maximum bytecode size of a frequent method to be inlined") \ 293690282Sobrien range(0, max_jint) \ 293790282Sobrien \ 293890282Sobrien product(intx, MaxTrivialSize, 6, \ 293990282Sobrien "The maximum bytecode size of a trivial method to be inlined") \ 294090282Sobrien range(0, max_jint) \ 294190282Sobrien \ 294290282Sobrien product(intx, MinInliningThreshold, 250, \ 294390282Sobrien "The minimum invocation count a method needs to have to be " \ 294490282Sobrien "inlined") \ 294590282Sobrien range(0, max_jint) \ 294690282Sobrien \ 294790282Sobrien develop(intx, MethodHistogramCutoff, 100, \ 294890282Sobrien "The cutoff value for method invocation histogram (+CountCalls)") \ 294950615Sobrien \ 295090282Sobrien diagnostic(intx, ProfilerNumberOfInterpretedMethods, 25, \ 295190282Sobrien "Number of interpreted methods to show in profile") \ 295290282Sobrien \ 295390282Sobrien diagnostic(intx, ProfilerNumberOfCompiledMethods, 25, \ 295490282Sobrien "Number of compiled methods to show in profile") \ 295590282Sobrien \ 295690282Sobrien diagnostic(intx, ProfilerNumberOfStubMethods, 25, \ 295790282Sobrien "Number of stub methods to show in profile") \ 295890282Sobrien \ 295950615Sobrien diagnostic(intx, ProfilerNumberOfRuntimeStubNodes, 25, \ 296018334Speter "Number of runtime stub nodes to show in profile") \ 296190282Sobrien \ 296290282Sobrien product(intx, ProfileIntervalsTicks, 100, \ 296352558Sobrien "Number of ticks between printing of interval profile " \ 296490282Sobrien "(+ProfileIntervals)") \ 296518334Speter range(0, max_intx) \ 296652558Sobrien \ 296790282Sobrien notproduct(intx, ScavengeALotInterval, 1, \ 296890282Sobrien "Interval between which scavenge will occur with +ScavengeALot") \ 296990282Sobrien \ 297090282Sobrien notproduct(intx, FullGCALotInterval, 1, \ 297190282Sobrien "Interval between which full gc will occur with +FullGCALot") \ 297290282Sobrien \ 297390282Sobrien notproduct(intx, FullGCALotStart, 0, \ 297490282Sobrien "For which invocation to start FullGCAlot") \ 297590282Sobrien \ 297690282Sobrien notproduct(intx, FullGCALotDummies, 32*K, \ 297790282Sobrien "Dummy object allocated with +FullGCALot, forcing all objects " \ 297890282Sobrien "to move") \ 297990282Sobrien \ 298090282Sobrien develop(intx, DontYieldALotInterval, 10, \ 298190282Sobrien "Interval between which yields will be dropped (milliseconds)") \ 298290282Sobrien \ 298390282Sobrien develop(intx, ProfilerPCTickThreshold, 15, \ 298490282Sobrien "Number of ticks in a PC buckets to be a hotspot") \ 298590282Sobrien \ 298690282Sobrien notproduct(intx, DeoptimizeALotInterval, 5, \ 298790282Sobrien "Number of exits until DeoptimizeALot kicks in") \ 298890282Sobrien \ 298990282Sobrien notproduct(intx, ZombieALotInterval, 5, \ 299090282Sobrien "Number of exits until ZombieALot kicks in") \ 299190282Sobrien \ 299290282Sobrien diagnostic(uintx, MallocMaxTestWords, 0, \ 299350615Sobrien "If non-zero, maximum number of words that malloc/realloc can " \ 299450615Sobrien "allocate (for testing only)") \ 299590282Sobrien range(0, max_uintx) \ 299690282Sobrien \ 299752558Sobrien product(intx, TypeProfileWidth, 2, \ 299890282Sobrien "Number of receiver types to record in call/cast profile") \ 299952558Sobrien range(0, 8) \ 300090282Sobrien \ 300190282Sobrien develop(intx, BciProfileWidth, 2, \ 300250615Sobrien "Number of return bci's to record in ret profile") \ 300352558Sobrien \ 300490282Sobrien product(intx, PerMethodRecompilationCutoff, 400, \ 300590282Sobrien "After recompiling N times, stay in the interpreter (-1=>'Inf')") \ 300690282Sobrien range(-1, max_intx) \ 300790282Sobrien \ 300818334Speter product(intx, PerBytecodeRecompilationCutoff, 200, \ 300990282Sobrien "Per-BCI limit on repeated recompilation (-1=>'Inf')") \ 301090282Sobrien range(-1, max_intx) \ 301190282Sobrien \ 301218334Speter product(intx, PerMethodTrapLimit, 100, \ 301390282Sobrien "Limit on traps (of one kind) in a method (includes inlines)") \ 301490282Sobrien range(0, max_jint) \ 301590282Sobrien \ 301618334Speter experimental(intx, PerMethodSpecTrapLimit, 5000, \ 301790282Sobrien "Limit on speculative traps (of one kind) in a method " \ 301890282Sobrien "(includes inlines)") \ 301918334Speter range(0, max_jint) \ 302090282Sobrien \ 302190282Sobrien product(intx, PerBytecodeTrapLimit, 4, \ 302290282Sobrien "Limit on traps (of one kind) at a particular BCI") \ 302390282Sobrien range(0, max_jint) \ 302418334Speter \ 302590282Sobrien experimental(intx, SpecTrapLimitExtraEntries, 3, \ 302618334Speter "Extra method data trap entries for speculation") \ 302790282Sobrien \ 302818334Speter develop(intx, InlineFrequencyRatio, 20, \ 302990282Sobrien "Ratio of call site execution to caller method invocation") \ 303090282Sobrien range(0, max_jint) \ 303190282Sobrien \ 303218334Speter diagnostic_pd(intx, InlineFrequencyCount, \ 303390282Sobrien "Count of call site execution necessary to trigger frequent " \ 303490282Sobrien "inlining") \ 303518334Speter range(0, max_jint) \ 303690282Sobrien \ 303718334Speter develop(intx, InlineThrowCount, 50, \ 303890282Sobrien "Force inlining of interpreted methods that throw this often") \ 303990282Sobrien range(0, max_jint) \ 304090282Sobrien \ 304190282Sobrien develop(intx, InlineThrowMaxSize, 200, \ 304218334Speter "Force inlining of throwing methods smaller than this") \ 304318334Speter range(0, max_jint) \ 304418334Speter \ 304590282Sobrien develop(intx, ProfilerNodeSize, 1024, \ 304618334Speter "Size in K to allocate for the Profile Nodes of each thread") \ 304790282Sobrien range(0, 1024) \ 304852558Sobrien \ 304918334Speter /* gc parameters */ \ 305018334Speter product(size_t, InitialHeapSize, 0, \ 305118334Speter "Initial heap size (in bytes); zero means use ergonomics") \ 305250615Sobrien constraint(InitialHeapSizeConstraintFunc,AfterErgo) \ 305390282Sobrien \ 305452558Sobrien product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \ 305590282Sobrien "Maximum heap size (in bytes)") \ 305690282Sobrien constraint(MaxHeapSizeConstraintFunc,AfterErgo) \ 305752558Sobrien \ 305890282Sobrien product(size_t, OldSize, ScaleForWordSize(4*M), \ 305990282Sobrien "Initial tenured generation size (in bytes)") \ 306090282Sobrien range(0, max_uintx) \ 306190282Sobrien \ 306290282Sobrien product(size_t, NewSize, ScaleForWordSize(1*M), \ 306390282Sobrien "Initial new generation size (in bytes)") \ 306490282Sobrien constraint(NewSizeConstraintFunc,AfterErgo) \ 306590282Sobrien \ 306690282Sobrien product(size_t, MaxNewSize, max_uintx, \ 306790282Sobrien "Maximum new generation size (in bytes), max_uintx means set " \ 306890282Sobrien "ergonomically") \ 306952558Sobrien range(0, max_uintx) \ 307090282Sobrien \ 307190282Sobrien product_pd(size_t, HeapBaseMinAddress, \ 307290282Sobrien "OS specific low limit for heap base address") \ 307390282Sobrien constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \ 307490282Sobrien \ 307552558Sobrien product(size_t, PretenureSizeThreshold, 0, \ 307690282Sobrien "Maximum size in bytes of objects allocated in DefNew " \ 307790282Sobrien "generation; zero means no maximum") \ 307890282Sobrien range(0, max_uintx) \ 307990282Sobrien \ 308090282Sobrien product(size_t, MinTLABSize, 2*K, \ 308150615Sobrien "Minimum allowed TLAB size (in bytes)") \ 308218334Speter range(1, max_uintx/2) \ 308390282Sobrien constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \ 308490282Sobrien \ 308590282Sobrien product(size_t, TLABSize, 0, \ 308690282Sobrien "Starting TLAB size (in bytes); zero means set ergonomically") \ 308790282Sobrien constraint(TLABSizeConstraintFunc,AfterMemoryInit) \ 308890282Sobrien \ 308990282Sobrien product(size_t, YoungPLABSize, 4096, \ 309090282Sobrien "Size of young gen promotion LAB's (in HeapWords)") \ 309190282Sobrien constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \ 309290282Sobrien \ 309390282Sobrien product(size_t, OldPLABSize, 1024, \ 309490282Sobrien "Size of old gen promotion LAB's (in HeapWords), or Number " \ 309590282Sobrien "of blocks to attempt to claim when refilling CMS LAB's") \ 309690282Sobrien constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \ 309790282Sobrien \ 309850615Sobrien product(uintx, TLABAllocationWeight, 35, \ 309950615Sobrien "Allocation averaging weight") \ 310050615Sobrien range(0, 100) \ 310150615Sobrien \ 310290282Sobrien /* Limit the lower bound of this flag to 1 as it is used */ \ 310390282Sobrien /* in a division expression. */ \ 310452558Sobrien product(uintx, TLABWasteTargetPercent, 1, \ 310590282Sobrien "Percentage of Eden that can be wasted") \ 310652558Sobrien range(1, 100) \ 310790282Sobrien \ 310890282Sobrien product(uintx, TLABRefillWasteFraction, 64, \ 310990282Sobrien "Maximum TLAB waste at a refill (internal fragmentation)") \ 311090282Sobrien range(1, max_juint) \ 311150615Sobrien \ 311218334Speter product(uintx, TLABWasteIncrement, 4, \ 311390282Sobrien "Increment allowed waste at slow allocation") \ 311490282Sobrien range(0, max_jint) \ 311590282Sobrien constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \ 311690282Sobrien \ 311790282Sobrien product(uintx, SurvivorRatio, 8, \ 311890282Sobrien "Ratio of eden/survivor space size") \ 311990282Sobrien range(1, max_uintx-2) \ 312090282Sobrien constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \ 312190282Sobrien \ 312290282Sobrien product(uintx, NewRatio, 2, \ 312390282Sobrien "Ratio of old/new generation sizes") \ 312490282Sobrien range(0, max_uintx-1) \ 312590282Sobrien \ 312690282Sobrien product_pd(size_t, NewSizeThreadIncrease, \ 312790282Sobrien "Additional size added to desired new generation size per " \ 312890282Sobrien "non-daemon thread (in bytes)") \ 312990282Sobrien range(0, max_uintx) \ 313090282Sobrien \ 313190282Sobrien product_pd(size_t, MetaspaceSize, \ 313290282Sobrien "Initial threshold (in bytes) at which a garbage collection " \ 313390282Sobrien "is done to reduce Metaspace usage") \ 313490282Sobrien constraint(MetaspaceSizeConstraintFunc,AfterErgo) \ 313590282Sobrien \ 313690282Sobrien product(size_t, MaxMetaspaceSize, max_uintx, \ 313790282Sobrien "Maximum size of Metaspaces (in bytes)") \ 313890282Sobrien constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \ 313990282Sobrien \ 314090282Sobrien product(size_t, CompressedClassSpaceSize, 1*G, \ 314118334Speter "Maximum size of class area in Metaspace when compressed " \ 314218334Speter "class pointers are used") \ 314318334Speter range(1*M, 3*G) \ 314418334Speter \ 314590282Sobrien manageable(uintx, MinHeapFreeRatio, 40, \ 314652558Sobrien "The minimum percentage of heap free after GC to avoid expansion."\ 314718334Speter " For most GCs this applies to the old generation. In G1 and" \ 314818334Speter " ParallelGC it applies to the whole heap.") \ 314918334Speter range(0, 100) \ 315090282Sobrien constraint(MinHeapFreeRatioConstraintFunc,AfterErgo) \ 315152558Sobrien \ 315290282Sobrien manageable(uintx, MaxHeapFreeRatio, 70, \ 315352558Sobrien "The maximum percentage of heap free after GC to avoid shrinking."\ 315490282Sobrien " For most GCs this applies to the old generation. In G1 and" \ 315590282Sobrien " ParallelGC it applies to the whole heap.") \ 315690282Sobrien range(0, 100) \ 315718334Speter constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \ 315890282Sobrien \ 315990282Sobrien product(bool, ShrinkHeapInSteps, true, \ 316018334Speter "When disabled, informs the GC to shrink the java heap directly" \ 316190282Sobrien " to the target size at the next full GC rather than requiring" \ 316290282Sobrien " smaller steps during multiple full GCs.") \ 316352558Sobrien \ 316452558Sobrien product(intx, SoftRefLRUPolicyMSPerMB, 1000, \ 316552558Sobrien "Number of milliseconds per MB of free space in the heap") \ 316652558Sobrien range(0, max_intx) \ 316752558Sobrien constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \ 316890282Sobrien \ 316990282Sobrien product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \ 317018334Speter "The minimum change in heap space due to GC (in bytes)") \ 317190282Sobrien range(0, max_uintx) \ 317290282Sobrien \ 317352558Sobrien product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \ 317452558Sobrien "The minimum expansion of Metaspace (in bytes)") \ 317552558Sobrien range(0, max_uintx) \ 317690282Sobrien \ 317790282Sobrien product(uintx, MaxMetaspaceFreeRatio, 70, \ 317818334Speter "The maximum percentage of Metaspace free after GC to avoid " \ 317990282Sobrien "shrinking") \ 318090282Sobrien range(0, 100) \ 318118334Speter constraint(MaxMetaspaceFreeRatioConstraintFunc,AfterErgo) \ 318290282Sobrien \ 318390282Sobrien product(uintx, MinMetaspaceFreeRatio, 40, \ 318490282Sobrien "The minimum percentage of Metaspace free after GC to avoid " \ 318590282Sobrien "expansion") \ 318690282Sobrien range(0, 99) \ 318790282Sobrien constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \ 318890282Sobrien \ 318990282Sobrien product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \ 319090282Sobrien "The maximum expansion of Metaspace without full GC (in bytes)") \ 319190282Sobrien range(0, max_uintx) \ 319290282Sobrien \ 319350615Sobrien product(uintx, QueuedAllocationWarningCount, 0, \ 319490282Sobrien "Number of times an allocation that queues behind a GC " \ 319552558Sobrien "will retry before printing a warning") \ 319690282Sobrien range(0, max_uintx) \ 319790282Sobrien \ 319852558Sobrien diagnostic(uintx, VerifyGCStartAt, 0, \ 319990282Sobrien "GC invoke count where +VerifyBefore/AfterGC kicks in") \ 320090282Sobrien range(0, max_uintx) \ 320150615Sobrien \ 320218334Speter diagnostic(intx, VerifyGCLevel, 0, \ 320390282Sobrien "Generation level at which to start +VerifyBefore/AfterGC") \ 320418334Speter range(0, 1) \ 320590282Sobrien \ 320690282Sobrien product(uintx, MaxTenuringThreshold, 15, \ 320718334Speter "Maximum value for tenuring threshold") \ 320890282Sobrien range(0, markOopDesc::max_age + 1) \ 320990282Sobrien constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \ 321018334Speter \ 321190282Sobrien product(uintx, InitialTenuringThreshold, 7, \ 321290282Sobrien "Initial value for tenuring threshold") \ 321390282Sobrien range(0, markOopDesc::max_age + 1) \ 321490282Sobrien constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \ 321590282Sobrien \ 321690282Sobrien product(uintx, TargetSurvivorRatio, 50, \ 321790282Sobrien "Desired percentage of survivor space used after scavenge") \ 321818334Speter range(0, 100) \ 321990282Sobrien \ 322090282Sobrien product(uintx, MarkSweepDeadRatio, 5, \ 322190282Sobrien "Percentage (0-100) of the old gen allowed as dead wood. " \ 322290282Sobrien "Serial mark sweep treats this as both the minimum and maximum " \ 322390282Sobrien "value. " \ 322490282Sobrien "CMS uses this value only if it falls back to mark sweep. " \ 322590282Sobrien "Par compact uses a variable scale based on the density of the " \ 322690282Sobrien "generation and treats this as the maximum value when the heap " \ 322790282Sobrien "is either completely full or completely empty. Par compact " \ 322890282Sobrien "also has a smaller default value; see arguments.cpp.") \ 322990282Sobrien range(0, 100) \ 323090282Sobrien \ 323118334Speter product(uint, MarkSweepAlwaysCompactCount, 4, \ 323218334Speter "How often should we fully compact the heap (ignoring the dead " \ 323318334Speter "space parameters)") \ 323490282Sobrien range(1, max_juint) \ 323590282Sobrien \ 323690282Sobrien develop(uintx, GCExpandToAllocateDelayMillis, 0, \ 323790282Sobrien "Delay between expansion and allocation (in milliseconds)") \ 323850615Sobrien \ 323950615Sobrien develop(uintx, GCWorkerDelayMillis, 0, \ 324090282Sobrien "Delay in scheduling GC workers (in milliseconds)") \ 324190282Sobrien \ 324290282Sobrien product(intx, DeferThrSuspendLoopCount, 4000, \ 324390282Sobrien "(Unstable) Number of times to iterate in safepoint loop " \ 324490282Sobrien "before blocking VM threads ") \ 324550615Sobrien range(-1, max_jint-1) \ 324652558Sobrien \ 324752558Sobrien product(intx, DeferPollingPageLoopCount, -1, \ 324852558Sobrien "(Unsafe,Unstable) Number of iterations in safepoint loop " \ 324952558Sobrien "before changing safepoint polling page to RO ") \ 325090282Sobrien range(-1, max_jint-1) \ 325190282Sobrien \ 325252558Sobrien product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \ 325390282Sobrien range(0, max_intx) \ 325452558Sobrien \ 325590282Sobrien product(bool, PSChunkLargeArrays, true, \ 325690282Sobrien "Process large arrays in chunks") \ 325752558Sobrien \ 325890282Sobrien product(uintx, GCDrainStackTargetSize, 64, \ 325952558Sobrien "Number of entries we will try to leave on the stack " \ 326090282Sobrien "during parallel gc") \ 326190282Sobrien range(0, max_juint) \ 326290282Sobrien \ 326352558Sobrien /* stack parameters */ \ 326490282Sobrien product_pd(intx, StackYellowPages, \ 326590282Sobrien "Number of yellow zone (recoverable overflows) pages of size " \ 326690282Sobrien "4KB. If pages are bigger yellow zone is aligned up.") \ 326752558Sobrien range(MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5)) \ 326890282Sobrien \ 326990282Sobrien product_pd(intx, StackRedPages, \ 327090282Sobrien "Number of red zone (unrecoverable overflows) pages of size " \ 327152558Sobrien "4KB. If pages are bigger red zone is aligned up.") \ 327290282Sobrien range(MIN_STACK_RED_PAGES, (DEFAULT_STACK_RED_PAGES+2)) \ 327352558Sobrien \ 327490282Sobrien product_pd(intx, StackReservedPages, \ 327590282Sobrien "Number of reserved zone (reserved to annotated methods) pages" \ 327690282Sobrien " of size 4KB. If pages are bigger reserved zone is aligned up.") \ 327790282Sobrien range(MIN_STACK_RESERVED_PAGES, (DEFAULT_STACK_RESERVED_PAGES+10))\ 327890282Sobrien \ 327990282Sobrien product(bool, RestrictReservedStack, true, \ 328096289Sobrien "Restrict @ReservedStackAccess to trusted classes") \ 328196289Sobrien \ 328296289Sobrien /* greater stack shadow pages can't generate instruction to bang stack */ \ 328396289Sobrien product_pd(intx, StackShadowPages, \ 328496289Sobrien "Number of shadow zone (for overflow checking) pages of size " \ 328596289Sobrien "4KB. If pages are bigger shadow zone is aligned up. " \ 328696289Sobrien "This should exceed the depth of the VM and native call stack.") \ 328796289Sobrien range(MIN_STACK_SHADOW_PAGES, (DEFAULT_STACK_SHADOW_PAGES+30)) \ 328896289Sobrien \ 328996289Sobrien product_pd(intx, ThreadStackSize, \ 329096289Sobrien "Thread Stack Size (in Kbytes)") \ 329196289Sobrien range(0, (max_intx-os::vm_page_size())/(1 * K)) \ 329252558Sobrien \ 329352558Sobrien product_pd(intx, VMThreadStackSize, \ 329496289Sobrien "Non-Java Thread Stack Size (in Kbytes)") \ 329590282Sobrien range(0, max_intx/(1 * K)) \ 329690282Sobrien \ 329790282Sobrien product_pd(intx, CompilerThreadStackSize, \ 329890282Sobrien "Compiler Thread Stack Size (in Kbytes)") \ 329990282Sobrien range(0, max_intx/(1 * K)) \ 330090282Sobrien \ 330190282Sobrien develop_pd(size_t, JVMInvokeMethodSlack, \ 330290282Sobrien "Stack space (bytes) required for JVM_InvokeMethod to complete") \ 330390282Sobrien \ 330490282Sobrien /* code cache parameters */ \ 330590282Sobrien develop_pd(uintx, CodeCacheSegmentSize, \ 330690282Sobrien "Code cache segment size (in bytes) - smallest unit of " \ 330752558Sobrien "allocation") \ 330852558Sobrien range(1, 1024) \ 330952558Sobrien constraint(CodeCacheSegmentSizeConstraintFunc, AfterErgo) \ 331052558Sobrien \ 331190282Sobrien develop_pd(intx, CodeEntryAlignment, \ 331290282Sobrien "Code entry alignment for generated code (in bytes)") \ 331318334Speter constraint(CodeEntryAlignmentConstraintFunc, AfterErgo) \ 331490282Sobrien \ 331590282Sobrien product_pd(intx, OptoLoopAlignment, \ 331690282Sobrien "Align inner loops to zero relative to this modulus") \ 331790282Sobrien range(1, 16) \ 331890282Sobrien constraint(OptoLoopAlignmentConstraintFunc, AfterErgo) \ 331918334Speter \ 332090282Sobrien product_pd(uintx, InitialCodeCacheSize, \ 332190282Sobrien "Initial code cache size (in bytes)") \ 332290282Sobrien range(0, max_uintx) \ 332390282Sobrien \ 332490282Sobrien develop_pd(uintx, CodeCacheMinimumUseSpace, \ 332590282Sobrien "Minimum code cache size (in bytes) required to start VM.") \ 332690282Sobrien range(0, max_uintx) \ 332796289Sobrien \ 332850615Sobrien product(bool, SegmentedCodeCache, false, \ 332990282Sobrien "Use a segmented code cache") \ 333090282Sobrien \ 333190282Sobrien product_pd(uintx, ReservedCodeCacheSize, \ 333290282Sobrien "Reserved code cache size (in bytes) - maximum code cache size") \ 333390282Sobrien range(0, max_uintx) \ 333490282Sobrien \ 333590282Sobrien product_pd(uintx, NonProfiledCodeHeapSize, \ 333690282Sobrien "Size of code heap with non-profiled methods (in bytes)") \ 333790282Sobrien range(0, max_uintx) \ 333890282Sobrien \ 333950615Sobrien product_pd(uintx, ProfiledCodeHeapSize, \ 334052558Sobrien "Size of code heap with profiled methods (in bytes)") \ 334190282Sobrien range(0, max_uintx) \ 334290282Sobrien \ 334390282Sobrien product_pd(uintx, NonNMethodCodeHeapSize, \ 334490282Sobrien "Size of code heap with non-nmethods (in bytes)") \ 334590282Sobrien range(0, max_uintx) \ 334690282Sobrien \ 334790282Sobrien product_pd(uintx, CodeCacheExpansionSize, \ 334890282Sobrien "Code cache expansion size (in bytes)") \ 334990282Sobrien range(0, max_uintx) \ 335090282Sobrien \ 335190282Sobrien diagnostic_pd(uintx, CodeCacheMinBlockLength, \ 335290282Sobrien "Minimum number of segments in a code cache block") \ 335390282Sobrien range(1, 100) \ 335490282Sobrien \ 335590282Sobrien notproduct(bool, ExitOnFullCodeCache, false, \ 335690282Sobrien "Exit the VM if we fill the code cache") \ 335718334Speter \ 335818334Speter product(bool, UseCodeCacheFlushing, true, \ 335990282Sobrien "Remove cold/old nmethods from the code cache") \ 336090282Sobrien \ 336118334Speter product(uintx, StartAggressiveSweepingAt, 10, \ 336218334Speter "Start aggressive sweeping if X[%] of the code cache is free." \ 336318334Speter "Segmented code cache: X[%] of the non-profiled heap." \ 336418334Speter "Non-segmented code cache: X[%] of the total code cache") \ 336590282Sobrien range(0, 100) \ 336618334Speter \ 336790282Sobrien /* AOT parameters */ \ 336818334Speter product(bool, UseAOT, AOT_ONLY(true) NOT_AOT(false), \ 336990282Sobrien "Use AOT compiled files") \ 337090282Sobrien \ 337190282Sobrien product(ccstrlist, AOTLibrary, NULL, \ 337290282Sobrien "AOT library") \ 337318334Speter \ 337490282Sobrien product(bool, PrintAOT, false, \ 337518334Speter "Print used AOT klasses and methods") \ 337618334Speter \ 337752558Sobrien notproduct(bool, PrintAOTStatistics, false, \ 337852558Sobrien "Print AOT statistics") \ 337918334Speter \ 338018334Speter diagnostic(bool, UseAOTStrictLoading, false, \ 338190282Sobrien "Exit the VM if any of the AOT libraries has invalid config") \ 338290282Sobrien \ 338390282Sobrien /* interpreter debugging */ \ 338418334Speter develop(intx, BinarySwitchThreshold, 5, \ 338590282Sobrien "Minimal number of lookupswitch entries for rewriting to binary " \ 338690282Sobrien "switch") \ 338790282Sobrien \ 338890282Sobrien develop(intx, StopInterpreterAt, 0, \ 338990282Sobrien "Stop interpreter execution at specified bytecode number") \ 339090282Sobrien \ 339190282Sobrien develop(intx, TraceBytecodesAt, 0, \ 339218334Speter "Trace bytecodes starting with specified bytecode number") \ 339318334Speter \ 339490282Sobrien /* compiler interface */ \ 339590282Sobrien develop(intx, CIStart, 0, \ 339652558Sobrien "The id of the first compilation to permit") \ 339796289Sobrien \ 339896289Sobrien develop(intx, CIStop, max_jint, \ 339996289Sobrien "The id of the last compilation to permit") \ 340096289Sobrien \ 340196289Sobrien develop(intx, CIStartOSR, 0, \ 340296289Sobrien "The id of the first osr compilation to permit " \ 340390282Sobrien "(CICountOSR must be on)") \ 340452558Sobrien \ 340590282Sobrien develop(intx, CIStopOSR, max_jint, \ 340690282Sobrien "The id of the last osr compilation to permit " \ 340752558Sobrien "(CICountOSR must be on)") \ 340890282Sobrien \ 340990282Sobrien develop(intx, CIBreakAtOSR, -1, \ 341090282Sobrien "The id of osr compilation to break at") \ 341118334Speter \ 341290282Sobrien develop(intx, CIBreakAt, -1, \ 341318334Speter "The id of compilation to break at") \ 341490282Sobrien \ 341590282Sobrien product(ccstrlist, CompileOnly, "", \ 341690282Sobrien "List of methods (pkg/class.name) to restrict compilation to") \ 341718334Speter \ 341818334Speter product(ccstr, CompileCommandFile, NULL, \ 341990282Sobrien "Read compiler commands from this file [.hotspot_compiler]") \ 342090282Sobrien \ 342150615Sobrien diagnostic(ccstr, CompilerDirectivesFile, NULL, \ 342290282Sobrien "Read compiler directives from this file") \ 342390282Sobrien \ 342490282Sobrien product(ccstrlist, CompileCommand, "", \ 342590282Sobrien "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \ 342690282Sobrien \ 342790282Sobrien develop(bool, ReplayCompiles, false, \ 342818334Speter "Enable replay of compilations from ReplayDataFile") \ 342918334Speter \ 343090282Sobrien product(ccstr, ReplayDataFile, NULL, \ 343190282Sobrien "File containing compilation replay information" \ 343290282Sobrien "[default: ./replay_pid%p.log] (%p replaced with pid)") \ 343318334Speter \ 343450615Sobrien product(ccstr, InlineDataFile, NULL, \ 343518334Speter "File containing inlining replay information" \ 343618334Speter "[default: ./inline_pid%p.log] (%p replaced with pid)") \ 343718334Speter \ 343818334Speter develop(intx, ReplaySuppressInitializers, 2, \ 343990282Sobrien "Control handling of class initialization during replay: " \ 344090282Sobrien "0 - don't do anything special; " \ 344152558Sobrien "1 - treat all class initializers as empty; " \ 344290282Sobrien "2 - treat class initializers for application classes as empty; " \ 344352558Sobrien "3 - allow all class initializers to run during bootstrap but " \ 344490282Sobrien " pretend they are empty after starting replay") \ 344590282Sobrien range(0, 3) \ 344690282Sobrien \ 344790282Sobrien develop(bool, ReplayIgnoreInitErrors, false, \ 344818334Speter "Ignore exceptions thrown during initialization for replay") \ 344918334Speter \ 345018334Speter product(bool, DumpReplayDataOnError, true, \ 345190282Sobrien "Record replay data for crashing compiler threads") \ 345290282Sobrien \ 345390282Sobrien product(bool, CICompilerCountPerCPU, false, \ 345490282Sobrien "1 compiler thread for log(N CPUs)") \ 345590282Sobrien \ 345690282Sobrien develop(intx, CIFireOOMAt, -1, \ 345790282Sobrien "Fire OutOfMemoryErrors throughout CI for testing the compiler " \ 345890282Sobrien "(non-negative value throws OOM after this many CI accesses " \ 345918334Speter "in each compile)") \ 346090282Sobrien notproduct(intx, CICrashAt, -1, \ 346190282Sobrien "id of compilation to trigger assert in compiler thread for " \ 346290282Sobrien "the purpose of testing, e.g. generation of replay data") \ 346318334Speter notproduct(bool, CIObjectFactoryVerify, false, \ 346490282Sobrien "enable potentially expensive verification in ciObjectFactory") \ 346590282Sobrien \ 346690282Sobrien /* Priorities */ \ 346790282Sobrien product_pd(bool, UseThreadPriorities, "Use native thread priorities") \ 346890282Sobrien \ 346952558Sobrien product(intx, ThreadPriorityPolicy, 0, \ 347090282Sobrien "0 : Normal. "\ 347150615Sobrien " VM chooses priorities that are appropriate for normal "\ 347290282Sobrien " applications. On Solaris NORM_PRIORITY and above are mapped "\ 347390282Sobrien " to normal native priority. Java priorities below " \ 347490282Sobrien " NORM_PRIORITY map to lower native priority values. On "\ 347590282Sobrien " Windows applications are allowed to use higher native "\ 347690282Sobrien " priorities. However, with ThreadPriorityPolicy=0, VM will "\ 347790282Sobrien " not use the highest possible native priority, "\ 347890282Sobrien " THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with "\ 347990282Sobrien " system threads. On Linux thread priorities are ignored "\ 348090282Sobrien " because the OS does not support static priority in "\ 348190282Sobrien " SCHED_OTHER scheduling class which is the only choice for "\ 348290282Sobrien " non-root, non-realtime applications. "\ 348390282Sobrien "1 : Aggressive. "\ 348490282Sobrien " Java thread priorities map over to the entire range of "\ 348590282Sobrien " native thread priorities. Higher Java thread priorities map "\ 348690282Sobrien " to higher native thread priorities. This policy should be "\ 348790282Sobrien " used with care, as sometimes it can cause performance "\ 348890282Sobrien " degradation in the application and/or the entire system. On "\ 348990282Sobrien " Linux this policy requires root privilege.") \ 349090282Sobrien range(0, 1) \ 349190282Sobrien \ 349290282Sobrien product(bool, ThreadPriorityVerbose, false, \ 349390282Sobrien "Print priority changes") \ 349490282Sobrien \ 349590282Sobrien product(intx, CompilerThreadPriority, -1, \ 349690282Sobrien "The native priority at which compiler threads should run " \ 349718334Speter "(-1 means no change)") \ 349818334Speter range(min_jint, max_jint) \ 349990282Sobrien constraint(CompilerThreadPriorityConstraintFunc, AfterErgo) \ 350018334Speter \ 350190282Sobrien product(intx, VMThreadPriority, -1, \ 350290282Sobrien "The native priority at which the VM thread should run " \ 350390282Sobrien "(-1 means no change)") \ 350490282Sobrien range(-1, 127) \ 350518334Speter \ 350690282Sobrien product(bool, CompilerThreadHintNoPreempt, true, \ 350790282Sobrien "(Solaris only) Give compiler threads an extra quanta") \ 350818334Speter \ 350990282Sobrien product(bool, VMThreadHintNoPreempt, false, \ 351090282Sobrien "(Solaris only) Give VM thread an extra quanta") \ 351118334Speter \ 351290282Sobrien product(intx, JavaPriority1_To_OSPriority, -1, \ 351390282Sobrien "Map Java priorities to OS priorities") \ 351490282Sobrien range(-1, 127) \ 351590282Sobrien \ 351650615Sobrien product(intx, JavaPriority2_To_OSPriority, -1, \ 351790282Sobrien "Map Java priorities to OS priorities") \ 351852558Sobrien range(-1, 127) \ 351990282Sobrien \ 352018334Speter product(intx, JavaPriority3_To_OSPriority, -1, \ 352118334Speter "Map Java priorities to OS priorities") \ 352218334Speter range(-1, 127) \ 352318334Speter \ 352418334Speter product(intx, JavaPriority4_To_OSPriority, -1, \ 352518334Speter "Map Java priorities to OS priorities") \ 352618334Speter range(-1, 127) \ 352718334Speter \ 352818334Speter product(intx, JavaPriority5_To_OSPriority, -1, \ 352990282Sobrien "Map Java priorities to OS priorities") \ 353090282Sobrien range(-1, 127) \ 353190282Sobrien \ 353218334Speter product(intx, JavaPriority6_To_OSPriority, -1, \ 353318334Speter "Map Java priorities to OS priorities") \ 353418334Speter range(-1, 127) \ 353518334Speter \ 353618334Speter product(intx, JavaPriority7_To_OSPriority, -1, \ 353718334Speter "Map Java priorities to OS priorities") \ 353818334Speter range(-1, 127) \ 353918334Speter \ 354018334Speter product(intx, JavaPriority8_To_OSPriority, -1, \ 354118334Speter "Map Java priorities to OS priorities") \ 354218334Speter range(-1, 127) \ 354318334Speter \ 354452558Sobrien product(intx, JavaPriority9_To_OSPriority, -1, \ 354552558Sobrien "Map Java priorities to OS priorities") \ 354618334Speter range(-1, 127) \ 354790282Sobrien \ 354818334Speter product(intx, JavaPriority10_To_OSPriority,-1, \ 354990282Sobrien "Map Java priorities to OS priorities") \ 355090282Sobrien range(-1, 127) \ 355190282Sobrien \ 355218334Speter experimental(bool, UseCriticalJavaThreadPriority, false, \ 355390282Sobrien "Java thread priority 10 maps to critical scheduling priority") \ 355490282Sobrien \ 355590282Sobrien experimental(bool, UseCriticalCompilerThreadPriority, false, \ 355618334Speter "Compiler thread(s) run at critical scheduling priority") \ 355790282Sobrien \ 355890282Sobrien experimental(bool, UseCriticalCMSThreadPriority, false, \ 355918334Speter "ConcurrentMarkSweep thread runs at critical scheduling priority")\ 356090282Sobrien \ 356190282Sobrien /* compiler debugging */ \ 356290282Sobrien notproduct(intx, CompileTheWorldStartAt, 1, \ 356390282Sobrien "First class to consider when using +CompileTheWorld") \ 356490282Sobrien \ 356550615Sobrien notproduct(intx, CompileTheWorldStopAt, max_jint, \ 356650615Sobrien "Last class to consider when using +CompileTheWorld") \ 356750615Sobrien \ 356850615Sobrien develop(intx, NewCodeParameter, 0, \ 356950615Sobrien "Testing Only: Create a dedicated integer parameter before " \ 357018334Speter "putback") \ 357150615Sobrien \ 357250615Sobrien /* new oopmap storage allocation */ \ 357350615Sobrien develop(intx, MinOopMapAllocation, 8, \ 357450615Sobrien "Minimum number of OopMap entries in an OopMapSet") \ 357550615Sobrien \ 357690282Sobrien /* Background Compilation */ \ 357790282Sobrien develop(intx, LongCompileThreshold, 50, \ 357890282Sobrien "Used with +TraceLongCompiles") \ 357990282Sobrien \ 358090282Sobrien /* recompilation */ \ 358118334Speter product_pd(intx, CompileThreshold, \ 358290282Sobrien "number of interpreted method invocations before (re-)compiling") \ 358390282Sobrien constraint(CompileThresholdConstraintFunc, AfterErgo) \ 358490282Sobrien \ 358590282Sobrien product(double, CompileThresholdScaling, 1.0, \ 358690282Sobrien "Factor to control when first compilation happens " \ 358752558Sobrien "(both with and without tiered compilation): " \ 358890282Sobrien "values greater than 1.0 delay counter overflow, " \ 358990282Sobrien "values between 0 and 1.0 rush counter overflow, " \ 359090282Sobrien "value of 1.0 leaves compilation thresholds unchanged " \ 359118334Speter "value of 0.0 is equivalent to -Xint. " \ 359218334Speter "" \ 359350615Sobrien "Flag can be set as per-method option. " \ 359450615Sobrien "If a value is specified for a method, compilation thresholds " \ 359550615Sobrien "for that method are scaled by both the value of the global flag "\ 359690282Sobrien "and the value of the per-method flag.") \ 359790282Sobrien range(0.0, DBL_MAX) \ 359890282Sobrien \ 359950615Sobrien product(intx, Tier0InvokeNotifyFreqLog, 7, \ 360090282Sobrien "Interpreter (tier 0) invocation notification frequency") \ 360190282Sobrien range(0, 30) \ 360290282Sobrien \ 360390282Sobrien product(intx, Tier2InvokeNotifyFreqLog, 11, \ 360490282Sobrien "C1 without MDO (tier 2) invocation notification frequency") \ 360590282Sobrien range(0, 30) \ 360690282Sobrien \ 360790282Sobrien product(intx, Tier3InvokeNotifyFreqLog, 10, \ 360850615Sobrien "C1 with MDO profiling (tier 3) invocation notification " \ 360990282Sobrien "frequency") \ 361090282Sobrien range(0, 30) \ 361150615Sobrien \ 361250615Sobrien product(intx, Tier23InlineeNotifyFreqLog, 20, \ 361390282Sobrien "Inlinee invocation (tiers 2 and 3) notification frequency") \ 361450615Sobrien range(0, 30) \ 361590282Sobrien \ 361690282Sobrien product(intx, Tier0BackedgeNotifyFreqLog, 10, \ 361790282Sobrien "Interpreter (tier 0) invocation notification frequency") \ 361890282Sobrien range(0, 30) \ 361950615Sobrien \ 362090282Sobrien product(intx, Tier2BackedgeNotifyFreqLog, 14, \ 362190282Sobrien "C1 without MDO (tier 2) invocation notification frequency") \ 362290282Sobrien range(0, 30) \ 362350615Sobrien \ 362490282Sobrien product(intx, Tier3BackedgeNotifyFreqLog, 13, \ 362590282Sobrien "C1 with MDO profiling (tier 3) invocation notification " \ 362690282Sobrien "frequency") \ 362790282Sobrien range(0, 30) \ 362890282Sobrien \ 362990282Sobrien product(intx, Tier2CompileThreshold, 0, \ 363090282Sobrien "threshold at which tier 2 compilation is invoked") \ 363190282Sobrien range(0, max_jint) \ 363290282Sobrien \ 363390282Sobrien product(intx, Tier2BackEdgeThreshold, 0, \ 363490282Sobrien "Back edge threshold at which tier 2 compilation is invoked") \ 363590282Sobrien range(0, max_jint) \ 363690282Sobrien \ 363790282Sobrien product(intx, Tier3InvocationThreshold, 200, \ 363890282Sobrien "Compile if number of method invocations crosses this " \ 363950615Sobrien "threshold") \ 364090282Sobrien range(0, max_jint) \ 364150615Sobrien \ 364290282Sobrien product(intx, Tier3MinInvocationThreshold, 100, \ 364390282Sobrien "Minimum invocation to compile at tier 3") \ 364490282Sobrien range(0, max_jint) \ 364590282Sobrien \ 364650615Sobrien product(intx, Tier3CompileThreshold, 2000, \ 364790282Sobrien "Threshold at which tier 3 compilation is invoked (invocation " \ 364890282Sobrien "minimum must be satisfied)") \ 364950615Sobrien range(0, max_jint) \ 365090282Sobrien \ 365190282Sobrien product(intx, Tier3BackEdgeThreshold, 60000, \ 365290282Sobrien "Back edge threshold at which tier 3 OSR compilation is invoked") \ 365390282Sobrien range(0, max_jint) \ 365490282Sobrien \ 365590282Sobrien product(intx, Tier3AOTInvocationThreshold, 10000, \ 365690282Sobrien "Compile if number of method invocations crosses this " \ 365790282Sobrien "threshold if coming from AOT") \ 365850615Sobrien range(0, max_jint) \ 365950615Sobrien \ 366090282Sobrien product(intx, Tier3AOTMinInvocationThreshold, 1000, \ 366190282Sobrien "Minimum invocation to compile at tier 3 if coming from AOT") \ 366250615Sobrien range(0, max_jint) \ 366390282Sobrien \ 366490282Sobrien product(intx, Tier3AOTCompileThreshold, 15000, \ 366590282Sobrien "Threshold at which tier 3 compilation is invoked (invocation " \ 366690282Sobrien "minimum must be satisfied) if coming from AOT") \ 366790282Sobrien range(0, max_jint) \ 366890282Sobrien \ 366990282Sobrien product(intx, Tier3AOTBackEdgeThreshold, 120000, \ 367090282Sobrien "Back edge threshold at which tier 3 OSR compilation is invoked " \ 367150615Sobrien "if coming from AOT") \ 367290282Sobrien range(0, max_jint) \ 367350615Sobrien \ 367450615Sobrien product(intx, Tier4InvocationThreshold, 5000, \ 367550615Sobrien "Compile if number of method invocations crosses this " \ 367690282Sobrien "threshold") \ 367750615Sobrien range(0, max_jint) \ 367850615Sobrien \ 367950615Sobrien product(intx, Tier4MinInvocationThreshold, 600, \ 368050615Sobrien "Minimum invocation to compile at tier 4") \ 368150615Sobrien range(0, max_jint) \ 368252558Sobrien \ 368350615Sobrien product(intx, Tier4CompileThreshold, 15000, \ 368490282Sobrien "Threshold at which tier 4 compilation is invoked (invocation " \ 368590282Sobrien "minimum must be satisfied") \ 368650615Sobrien range(0, max_jint) \ 368790282Sobrien \ 368850615Sobrien product(intx, Tier4BackEdgeThreshold, 40000, \ 368990282Sobrien "Back edge threshold at which tier 4 OSR compilation is invoked") \ 369050615Sobrien range(0, max_jint) \ 369190282Sobrien \ 369290282Sobrien product(intx, Tier3DelayOn, 5, \ 369350615Sobrien "If C2 queue size grows over this amount per compiler thread " \ 369450615Sobrien "stop compiling at tier 3 and start compiling at tier 2") \ 369552558Sobrien range(0, max_jint) \ 369652558Sobrien \ 369752558Sobrien product(intx, Tier3DelayOff, 2, \ 369852558Sobrien "If C2 queue size is less than this amount per compiler thread " \ 369990282Sobrien "allow methods compiled at tier 2 transition to tier 3") \ 370052558Sobrien range(0, max_jint) \ 370190282Sobrien \ 370250615Sobrien product(intx, Tier3LoadFeedback, 5, \ 370350615Sobrien "Tier 3 thresholds will increase twofold when C1 queue size " \ 370450615Sobrien "reaches this amount per compiler thread") \ 370550615Sobrien range(0, max_jint) \ 370650615Sobrien \ 370790282Sobrien product(intx, Tier4LoadFeedback, 3, \ 370850615Sobrien "Tier 4 thresholds will increase twofold when C2 queue size " \ 370950615Sobrien "reaches this amount per compiler thread") \ 371050615Sobrien range(0, max_jint) \ 371190282Sobrien \ 371290282Sobrien product(intx, TieredCompileTaskTimeout, 50, \ 371350615Sobrien "Kill compile task if method was not used within " \ 371450615Sobrien "given timeout in milliseconds") \ 371550615Sobrien range(0, max_intx) \ 371690282Sobrien \ 371750615Sobrien product(intx, TieredStopAtLevel, 4, \ 371850615Sobrien "Stop at given compilation level") \ 371950615Sobrien range(0, 4) \ 372050615Sobrien \ 372190282Sobrien product(intx, Tier0ProfilingStartPercentage, 200, \ 372290282Sobrien "Start profiling in interpreter if the counters exceed tier 3 " \ 372350615Sobrien "thresholds by the specified percentage") \ 372490282Sobrien range(0, max_jint) \ 372590282Sobrien \ 372690282Sobrien product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \ 372790282Sobrien "Increase the compile threshold for C1 compilation if the code " \ 372890282Sobrien "cache is filled by the specified percentage") \ 372990282Sobrien range(0, 99) \ 373090282Sobrien \ 373190282Sobrien product(intx, TieredRateUpdateMinTime, 1, \ 373290282Sobrien "Minimum rate sampling interval (in milliseconds)") \ 373390282Sobrien range(0, max_intx) \ 373490282Sobrien \ 373590282Sobrien product(intx, TieredRateUpdateMaxTime, 25, \ 373690282Sobrien "Maximum rate sampling interval (in milliseconds)") \ 373790282Sobrien range(0, max_intx) \ 373890282Sobrien \ 373950615Sobrien product_pd(bool, TieredCompilation, \ 374090282Sobrien "Enable tiered compilation") \ 374150615Sobrien \ 374250615Sobrien product(bool, PrintTieredEvents, false, \ 374350615Sobrien "Print tiered events notifications") \ 374450615Sobrien \ 374590282Sobrien product_pd(intx, OnStackReplacePercentage, \ 374650615Sobrien "NON_TIERED number of method invocations/branches (expressed as " \ 374750615Sobrien "% of CompileThreshold) before (re-)compiling OSR code") \ 374890282Sobrien constraint(OnStackReplacePercentageConstraintFunc, AfterErgo) \ 374990282Sobrien \ 375090282Sobrien product(intx, InterpreterProfilePercentage, 33, \ 375150615Sobrien "NON_TIERED number of method invocations/branches (expressed as " \ 375290282Sobrien "% of CompileThreshold) before profiling in the interpreter") \ 375390282Sobrien range(0, 100) \ 375450615Sobrien \ 375590282Sobrien develop(intx, MaxRecompilationSearchLength, 10, \ 375650615Sobrien "The maximum number of frames to inspect when searching for " \ 375750615Sobrien "recompilee") \ 375852558Sobrien \ 375952558Sobrien develop(intx, MaxInterpretedSearchLength, 3, \ 376090282Sobrien "The maximum number of interpreted frames to skip when searching "\ 376152558Sobrien "for recompilee") \ 376290282Sobrien \ 376352558Sobrien develop(intx, DesiredMethodLimit, 8000, \ 376450615Sobrien "The desired maximum method size (in bytecodes) after inlining") \ 376590282Sobrien \ 376650615Sobrien develop(intx, HugeMethodLimit, 8000, \ 376790282Sobrien "Don't compile methods larger than this if " \ 376890282Sobrien "+DontCompileHugeMethods") \ 376990282Sobrien \ 377050615Sobrien /* New JDK 1.4 reflection implementation */ \ 377190282Sobrien \ 377290282Sobrien develop(intx, FastSuperclassLimit, 8, \ 377350615Sobrien "Depth of hardwired instanceof accelerator array") \ 377490282Sobrien \ 377550615Sobrien /* Properties for Java libraries */ \ 377650615Sobrien \ 377752558Sobrien product(uint64_t, MaxDirectMemorySize, 0, \ 377852558Sobrien "Maximum total size of NIO direct-buffer allocations") \ 377990282Sobrien range(0, max_jlong) \ 378052558Sobrien \ 378190282Sobrien /* Flags used for temporary code during development */ \ 378252558Sobrien \ 378350615Sobrien diagnostic(bool, UseNewCode, false, \ 378490282Sobrien "Testing Only: Use the new version while testing") \ 378550615Sobrien \ 378650615Sobrien diagnostic(bool, UseNewCode2, false, \ 378750615Sobrien "Testing Only: Use the new version while testing") \ 378852558Sobrien \ 378952558Sobrien diagnostic(bool, UseNewCode3, false, \ 379090282Sobrien "Testing Only: Use the new version while testing") \ 379152558Sobrien \ 379290282Sobrien /* flags for performance data collection */ \ 379352558Sobrien \ 379450615Sobrien product(bool, UsePerfData, true, \ 379550615Sobrien "Flag to disable jvmstat instrumentation for performance testing "\ 379690282Sobrien "and problem isolation purposes") \ 379790282Sobrien \ 379850615Sobrien product(bool, PerfDataSaveToFile, false, \ 379990282Sobrien "Save PerfData memory to hsperfdata_<pid> file on exit") \ 380090282Sobrien \ 380190282Sobrien product(ccstr, PerfDataSaveFile, NULL, \ 380290282Sobrien "Save PerfData memory to the specified absolute pathname. " \ 380390282Sobrien "The string %p in the file name (if present) " \ 380450615Sobrien "will be replaced by pid") \ 380590282Sobrien \ 380690282Sobrien product(intx, PerfDataSamplingInterval, 50, \ 380790282Sobrien "Data sampling interval (in milliseconds)") \ 380890282Sobrien range(PeriodicTask::min_interval, max_jint) \ 380990282Sobrien constraint(PerfDataSamplingIntervalFunc, AfterErgo) \ 381090282Sobrien \ 381190282Sobrien develop(bool, PerfTraceDataCreation, false, \ 381290282Sobrien "Trace creation of Performance Data Entries") \ 381390282Sobrien \ 381490282Sobrien develop(bool, PerfTraceMemOps, false, \ 381590282Sobrien "Trace PerfMemory create/attach/detach calls") \ 381690282Sobrien \ 381790282Sobrien product(bool, PerfDisableSharedMem, false, \ 381890282Sobrien "Store performance data in standard memory") \ 381990282Sobrien \ 382090282Sobrien product(intx, PerfDataMemorySize, 32*K, \ 382190282Sobrien "Size of performance data memory region. Will be rounded " \ 382290282Sobrien "up to a multiple of the native os page size.") \ 382390282Sobrien range(128, 32*64*K) \ 382490282Sobrien \ 382590282Sobrien product(intx, PerfMaxStringConstLength, 1024, \ 382690282Sobrien "Maximum PerfStringConstant string length before truncation") \ 382790282Sobrien range(32, 32*K) \ 382890282Sobrien \ 382990282Sobrien product(bool, PerfAllowAtExitRegistration, false, \ 383090282Sobrien "Allow registration of atexit() methods") \ 383190282Sobrien \ 383290282Sobrien product(bool, PerfBypassFileSystemCheck, false, \ 383390282Sobrien "Bypass Win32 file system criteria checks (Windows Only)") \ 383490282Sobrien \ 383590282Sobrien product(intx, UnguardOnExecutionViolation, 0, \ 383690282Sobrien "Unguard page and retry on no-execute fault (Win32 only) " \ 383790282Sobrien "0=off, 1=conservative, 2=aggressive") \ 383890282Sobrien range(0, 2) \ 383990282Sobrien \ 384090282Sobrien /* Serviceability Support */ \ 384190282Sobrien \ 384290282Sobrien product(bool, ManagementServer, false, \ 384390282Sobrien "Create JMX Management Server") \ 384490282Sobrien \ 384590282Sobrien product(bool, DisableAttachMechanism, false, \ 384690282Sobrien "Disable mechanism that allows tools to attach to this VM") \ 384790282Sobrien \ 384890282Sobrien product(bool, StartAttachListener, false, \ 384990282Sobrien "Always start Attach Listener at VM startup") \ 385090282Sobrien \ 385190282Sobrien product(bool, EnableDynamicAgentLoading, true, \ 385290282Sobrien "Allow tools to load agents with the attach mechanism") \ 385390282Sobrien \ 385450615Sobrien manageable(bool, PrintConcurrentLocks, false, \ 385590282Sobrien "Print java.util.concurrent locks in thread dump") \ 385690282Sobrien \ 385750615Sobrien product(bool, TransmitErrorReport, false, \ 385890282Sobrien "Enable error report transmission on erroneous termination") \ 385990282Sobrien \ 386050615Sobrien product(ccstr, ErrorReportServer, NULL, \ 386190282Sobrien "Override built-in error report server address") \ 386290282Sobrien \ 386350615Sobrien /* Shared spaces */ \ 386490282Sobrien \ 386550615Sobrien product(bool, UseSharedSpaces, true, \ 386690282Sobrien "Use shared spaces for metadata") \ 386790282Sobrien \ 386850615Sobrien product(bool, VerifySharedSpaces, false, \ 386990282Sobrien "Verify shared spaces (false for default archive, true for " \ 387090282Sobrien "archive specified by -XX:SharedArchiveFile)") \ 387190282Sobrien \ 387290282Sobrien product(bool, RequireSharedSpaces, false, \ 387390282Sobrien "Require shared spaces for metadata") \ 387490282Sobrien \ 387590282Sobrien product(bool, DumpSharedSpaces, false, \ 387650615Sobrien "Special mode: JVM reads a class list, loads classes, builds " \ 387718334Speter "shared spaces, and dumps the shared spaces to a file to be " \ 387890282Sobrien "used in future JVM runs") \ 387990282Sobrien \ 388090282Sobrien product(bool, PrintSharedSpaces, false, \ 388190282Sobrien "Print usage of shared spaces") \ 388290282Sobrien \ 388390282Sobrien product(bool, PrintSharedArchiveAndExit, false, \ 388490282Sobrien "Print shared archive file contents") \ 388590282Sobrien \ 388690282Sobrien product(bool, PrintSharedDictionary, false, \ 388790282Sobrien "If PrintSharedArchiveAndExit is true, also print the shared " \ 388890282Sobrien "dictionary") \ 388990282Sobrien \ 389090282Sobrien product(size_t, SharedReadWriteSize, DEFAULT_SHARED_READ_WRITE_SIZE, \ 389190282Sobrien "Size of read-write space for metadata (in bytes)") \ 389290282Sobrien range(MIN_SHARED_READ_WRITE_SIZE, MAX_SHARED_READ_WRITE_SIZE) \ 389318334Speter constraint(SharedReadWriteSizeConstraintFunc,AfterErgo) \ 389490282Sobrien \ 389590282Sobrien product(size_t, SharedReadOnlySize, DEFAULT_SHARED_READ_ONLY_SIZE, \ 389690282Sobrien "Size of read-only space for metadata (in bytes)") \ 389790282Sobrien range(MIN_SHARED_READ_ONLY_SIZE, MAX_SHARED_READ_ONLY_SIZE) \ 389890282Sobrien constraint(SharedReadOnlySizeConstraintFunc,AfterErgo) \ 389990282Sobrien \ 390090282Sobrien product(size_t, SharedMiscDataSize, DEFAULT_SHARED_MISC_DATA_SIZE, \ 390190282Sobrien "Size of the shared miscellaneous data area (in bytes)") \ 390290282Sobrien range(MIN_SHARED_MISC_DATA_SIZE, MAX_SHARED_MISC_DATA_SIZE) \ 390390282Sobrien constraint(SharedMiscDataSizeConstraintFunc,AfterErgo) \ 390490282Sobrien \ 390590282Sobrien product(size_t, SharedMiscCodeSize, DEFAULT_SHARED_MISC_CODE_SIZE, \ 390690282Sobrien "Size of the shared miscellaneous code area (in bytes)") \ 390790282Sobrien range(MIN_SHARED_MISC_CODE_SIZE, MAX_SHARED_MISC_CODE_SIZE) \ 390890282Sobrien constraint(SharedMiscCodeSizeConstraintFunc,AfterErgo) \ 390990282Sobrien \ 391090282Sobrien product(size_t, SharedBaseAddress, LP64_ONLY(32*G) \ 391190282Sobrien NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)), \ 391290282Sobrien "Address to allocate shared memory region for class data") \ 391390282Sobrien range(0, SIZE_MAX) \ 391490282Sobrien \ 391590282Sobrien product(uintx, SharedSymbolTableBucketSize, 4, \ 391690282Sobrien "Average number of symbols per bucket in shared table") \ 391790282Sobrien range(2, 246) \ 391890282Sobrien \ 391990282Sobrien diagnostic(bool, IgnoreUnverifiableClassesDuringDump, false, \ 392090282Sobrien "Do not quit -Xshare:dump even if we encounter unverifiable " \ 392190282Sobrien "classes. Just exclude them from the shared dictionary.") \ 392290282Sobrien \ 392390282Sobrien diagnostic(bool, PrintMethodHandleStubs, false, \ 392490282Sobrien "Print generated stub code for method handles") \ 392590282Sobrien \ 392690282Sobrien develop(bool, TraceMethodHandles, false, \ 392790282Sobrien "trace internal method handle operations") \ 392890282Sobrien \ 392990282Sobrien diagnostic(bool, VerifyMethodHandles, trueInDebug, \ 393090282Sobrien "perform extra checks when constructing method handles") \ 393190282Sobrien \ 393290282Sobrien diagnostic(bool, ShowHiddenFrames, false, \ 393390282Sobrien "show method handle implementation frames (usually hidden)") \ 393490282Sobrien \ 393590282Sobrien experimental(bool, TrustFinalNonStaticFields, false, \ 393690282Sobrien "trust final non-static declarations for constant folding") \ 393790282Sobrien \ 393890282Sobrien diagnostic(bool, FoldStableValues, true, \ 393990282Sobrien "Optimize loads from stable fields (marked w/ @Stable)") \ 394090282Sobrien \ 394190282Sobrien develop(bool, TraceInvokeDynamic, false, \ 394290282Sobrien "trace internal invoke dynamic operations") \ 394390282Sobrien \ 394490282Sobrien diagnostic(bool, PauseAtStartup, false, \ 394590282Sobrien "Causes the VM to pause at startup time and wait for the pause " \ 394690282Sobrien "file to be removed (default: ./vm.paused.<pid>)") \ 394790282Sobrien \ 394890282Sobrien diagnostic(ccstr, PauseAtStartupFile, NULL, \ 394990282Sobrien "The file to create and for whose removal to await when pausing " \ 395018334Speter "at startup. (default: ./vm.paused.<pid>)") \ 395190282Sobrien \ 395290282Sobrien diagnostic(bool, PauseAtExit, false, \ 395318334Speter "Pause and wait for keypress on exit if a debugger is attached") \ 395490282Sobrien \ 395590282Sobrien product(bool, ExtendedDTraceProbes, false, \ 395690282Sobrien "Enable performance-impacting dtrace probes") \ 395718334Speter \ 395890282Sobrien product(bool, DTraceMethodProbes, false, \ 395990282Sobrien "Enable dtrace probes for method-entry and method-exit") \ 396090282Sobrien \ 396190282Sobrien product(bool, DTraceAllocProbes, false, \ 396290282Sobrien "Enable dtrace probes for object allocation") \ 396390282Sobrien \ 396452558Sobrien product(bool, DTraceMonitorProbes, false, \ 396590282Sobrien "Enable dtrace probes for monitor events") \ 396618334Speter \ 396790282Sobrien product(bool, RelaxAccessControlCheck, false, \ 396818334Speter "Relax the access control checks in the verifier") \ 396990282Sobrien \ 397018334Speter product(uintx, StringTableSize, defaultStringTableSize, \ 397190282Sobrien "Number of buckets in the interned String table") \ 397290282Sobrien range(minimumStringTableSize, 111*defaultStringTableSize) \ 397318334Speter \ 397490282Sobrien experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \ 397590282Sobrien "Number of buckets in the JVM internal Symbol table") \ 397690282Sobrien range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \ 397718334Speter \ 397890282Sobrien product(bool, UseStringDeduplication, false, \ 397990282Sobrien "Use string deduplication") \ 398018334Speter \ 398118334Speter product(uintx, StringDeduplicationAgeThreshold, 3, \ 398218334Speter "A string must reach this age (or be promoted to an old region) " \ 398390282Sobrien "to be considered for deduplication") \ 398490282Sobrien range(1, markOopDesc::max_age) \ 398590282Sobrien \ 398690282Sobrien diagnostic(bool, StringDeduplicationResizeALot, false, \ 398790282Sobrien "Force table resize every time the table is scanned") \ 398818334Speter \ 398990282Sobrien diagnostic(bool, StringDeduplicationRehashALot, false, \ 399018334Speter "Force table rehash every time the table is scanned") \ 399190282Sobrien \ 399218334Speter diagnostic(bool, WhiteBoxAPI, false, \ 399390282Sobrien "Enable internal testing APIs") \ 399418334Speter \ 399590282Sobrien experimental(intx, SurvivorAlignmentInBytes, 0, \ 399618334Speter "Default survivor space alignment in bytes") \ 399790282Sobrien constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \ 399818334Speter \ 399990282Sobrien product(bool , AllowNonVirtualCalls, false, \ 400090282Sobrien "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \ 400118334Speter \ 400290282Sobrien product(ccstr, DumpLoadedClassList, NULL, \ 400390282Sobrien "Dump the names all loaded classes, that could be stored into " \ 400450615Sobrien "the CDS archive, in the specified file") \ 400590282Sobrien \ 400690282Sobrien product(ccstr, SharedClassListFile, NULL, \ 400790282Sobrien "Override the default CDS class list") \ 400818334Speter \ 400990282Sobrien diagnostic(ccstr, SharedArchiveFile, NULL, \ 401090282Sobrien "Override the default location of the CDS archive file") \ 401190282Sobrien \ 401290282Sobrien product(ccstr, ExtraSharedClassListFile, NULL, \ 401390282Sobrien "Extra classlist for building the CDS archive file") \ 401490282Sobrien \ 401590282Sobrien experimental(size_t, ArrayAllocatorMallocLimit, \ 401690282Sobrien SOLARIS_ONLY(64*K) NOT_SOLARIS((size_t)-1), \ 401790282Sobrien "Allocation less than this value will be allocated " \ 401890282Sobrien "using malloc. Larger allocations will use mmap.") \ 401990282Sobrien \ 402090282Sobrien experimental(bool, AlwaysAtomicAccesses, false, \ 402190282Sobrien "Accesses to all variables should always be atomic") \ 402290282Sobrien \ 402390282Sobrien product(bool, EnableTracing, false, \ 402490282Sobrien "Enable event-based tracing") \ 402590282Sobrien \ 402690282Sobrien product(bool, UseLockedTracing, false, \ 402790282Sobrien "Use locked-tracing when doing event-based tracing") \ 402890282Sobrien \ 402918334Speter diagnostic(bool, UseUnalignedAccesses, false, \ 403090282Sobrien "Use unaligned memory accesses in Unsafe") \ 403190282Sobrien \ 403290282Sobrien product_pd(bool, PreserveFramePointer, \ 403390282Sobrien "Use the FP register for holding the frame pointer " \ 403490282Sobrien "and not as a general purpose register.") \ 403518334Speter \ 403690282Sobrien diagnostic(bool, CheckIntrinsics, true, \ 403790282Sobrien "When a class C is loaded, check that " \ 403890282Sobrien "(1) all intrinsics defined by the VM for class C are present "\ 403950615Sobrien "in the loaded class file and are marked with the " \ 404090282Sobrien "@HotSpotIntrinsicCandidate annotation, that " \ 404190282Sobrien "(2) there is an intrinsic registered for all loaded methods " \ 404218334Speter "that are annotated with the @HotSpotIntrinsicCandidate " \ 404390282Sobrien "annotation, and that " \ 404490282Sobrien "(3) no orphan methods exist for class C (i.e., methods for " \ 404518334Speter "which the VM declares an intrinsic but that are not declared "\ 404690282Sobrien "in the loaded class C. " \ 404790282Sobrien "Check (3) is available only in debug builds.") \ 404890282Sobrien \ 404990282Sobrien diagnostic_pd(intx, InitArrayShortSize, \ 405018334Speter "Threshold small size (in bytes) for clearing arrays. " \ 405190282Sobrien "Anything this size or smaller may get converted to discrete " \ 405290282Sobrien "scalar stores.") \ 405390282Sobrien range(0, max_intx) \ 405490282Sobrien constraint(InitArrayShortSizeConstraintFunc, AfterErgo) \ 405590282Sobrien \ 405690282Sobrien diagnostic(bool, CompilerDirectivesIgnoreCompileCommands, false, \ 405790282Sobrien "Disable backwards compatibility for compile commands.") \ 405818334Speter \ 405990282Sobrien diagnostic(bool, CompilerDirectivesPrint, false, \ 406018334Speter "Print compiler directives on installation.") \ 406190282Sobrien diagnostic(int, CompilerDirectivesLimit, 50, \ 406290282Sobrien "Limit on number of compiler directives.") 406390282Sobrien 406490282Sobrien 406518334Speter/* 406690282Sobrien * Macros for factoring of globals 406790282Sobrien */ 406818334Speter 406990282Sobrien// Interface macros 407090282Sobrien#define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 407190282Sobrien#define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name; 407290282Sobrien#define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name; 407318334Speter#define DECLARE_PD_DIAGNOSTIC_FLAG(type, name, doc) extern "C" type name; 407418334Speter#define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name; 407590282Sobrien#define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name; 407618334Speter#define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name; 407790282Sobrien#ifdef PRODUCT 407818334Speter#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) const type name = value; 407990282Sobrien#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) const type name = pd_##name; 408018334Speter#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) const type name = value; 408196289Sobrien#else 408290282Sobrien#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name; 408350615Sobrien#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name; 408418334Speter#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name; 408590282Sobrien#endif // PRODUCT 408650615Sobrien// Special LP64 flags, product only needed for now. 408750615Sobrien#ifdef _LP64 408890282Sobrien#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 408990282Sobrien#else 409018334Speter#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) const type name = value; 409190282Sobrien#endif // _LP64 409290282Sobrien 409318334Speter// Implementation macros 409490282Sobrien#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value; 409590282Sobrien#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name; 409690282Sobrien#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value; 409790282Sobrien#define MATERIALIZE_PD_DIAGNOSTIC_FLAG(type, name, doc) type name = pd_##name; 409890282Sobrien#define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value; 409990282Sobrien#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value; 410090282Sobrien#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value; 410190282Sobrien#ifdef PRODUCT 410218334Speter#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) 410390282Sobrien#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) 410490282Sobrien#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) 410590282Sobrien#else 410690282Sobrien#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value; 410790282Sobrien#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name; 410852558Sobrien#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value; 410990282Sobrien#endif // PRODUCT 411090282Sobrien#ifdef _LP64 411190282Sobrien#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value; 411252558Sobrien#else 411390282Sobrien#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */ 411490282Sobrien#endif // _LP64 411590282Sobrien 411690282Sobrien// Only materialize src code for range checking when required, ignore otherwise 411790282Sobrien#define IGNORE_RANGE(a, b) 411890282Sobrien// Only materialize src code for contraint checking when required, ignore otherwise 411918334Speter#define IGNORE_CONSTRAINT(func,type) 412090282Sobrien 412190282Sobrien#define IGNORE_WRITEABLE(type) 412218334Speter 412318334SpeterRUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, \ 412418334Speter DECLARE_PD_DEVELOPER_FLAG, \ 412590282Sobrien DECLARE_PRODUCT_FLAG, \ 412690282Sobrien DECLARE_PD_PRODUCT_FLAG, \ 412718334Speter DECLARE_DIAGNOSTIC_FLAG, \ 412890282Sobrien DECLARE_PD_DIAGNOSTIC_FLAG, \ 412990282Sobrien DECLARE_EXPERIMENTAL_FLAG, \ 413090282Sobrien DECLARE_NOTPRODUCT_FLAG, \ 413190282Sobrien DECLARE_MANAGEABLE_FLAG, \ 413290282Sobrien DECLARE_PRODUCT_RW_FLAG, \ 413390282Sobrien DECLARE_LP64_PRODUCT_FLAG, \ 413490282Sobrien IGNORE_RANGE, \ 413590282Sobrien IGNORE_CONSTRAINT, \ 413690282Sobrien IGNORE_WRITEABLE) 413790282Sobrien 413890282SobrienRUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, \ 413990282Sobrien DECLARE_PD_DEVELOPER_FLAG, \ 414090282Sobrien DECLARE_PRODUCT_FLAG, \ 414190282Sobrien DECLARE_PD_PRODUCT_FLAG, \ 414218334Speter DECLARE_DIAGNOSTIC_FLAG, \ 414390282Sobrien DECLARE_PD_DIAGNOSTIC_FLAG, \ 414490282Sobrien DECLARE_NOTPRODUCT_FLAG, \ 414518334Speter IGNORE_RANGE, \ 414690282Sobrien IGNORE_CONSTRAINT, \ 414790282Sobrien IGNORE_WRITEABLE) 414890282Sobrien 414918334SpeterARCH_FLAGS(DECLARE_DEVELOPER_FLAG, \ 415018334Speter DECLARE_PRODUCT_FLAG, \ 415190282Sobrien DECLARE_DIAGNOSTIC_FLAG, \ 415218334Speter DECLARE_EXPERIMENTAL_FLAG, \ 415390282Sobrien DECLARE_NOTPRODUCT_FLAG, \ 415450615Sobrien IGNORE_RANGE, \ 415590282Sobrien IGNORE_CONSTRAINT, \ 415690282Sobrien IGNORE_WRITEABLE) 415750615Sobrien 415850615Sobrien// Extensions 415990282Sobrien 416050615Sobrien#include "runtime/globals_ext.hpp" 416190282Sobrien 416290282Sobrien#endif // SHARE_VM_RUNTIME_GLOBALS_HPP 416350615Sobrien