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