truffle: src/share/vm/runtime/globals.hpp annotate

annotate src/share/vm/runtime/globals.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	096c224171c4
children	02f27ecb4f3a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8034 bce1ac447f6b 7052429: G1: Avoid unnecessary scanning of humongous regions during concurrent marking johnc parents: 7615 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1544 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1544 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1544 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	25 #ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	26 #define SHARE_VM_RUNTIME_GLOBALS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	28 #include "utilities/debug.hpp"
4868 5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	29
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	30 // use this for flags that are true per default in the tiered build
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	31 // but false in non-tiered builds, and vice versa
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	32 #ifdef TIERED
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	33 #define trueInTiered true
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	34 #define falseInTiered false
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	35 #else
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	36 #define trueInTiered false
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	37 #define falseInTiered true
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	38 #endif
5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4819 diff changeset	39
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	40 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	41 # include "globals_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	42 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	43 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	44 # include "globals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	45 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	46 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	47 # include "globals_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	48 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	49 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	50 # include "globals_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	51 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	52 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	53 # include "globals_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	54 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	55 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	56 # include "globals_linux.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	57 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	58 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	59 # include "globals_solaris.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	60 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	61 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	62 # include "globals_windows.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	63 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	64 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	65 # include "globals_bsd.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	66 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	67 #ifdef TARGET_OS_ARCH_linux_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	68 # include "globals_linux_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	69 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	70 #ifdef TARGET_OS_ARCH_linux_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	71 # include "globals_linux_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	72 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	73 #ifdef TARGET_OS_ARCH_linux_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	74 # include "globals_linux_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	75 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	76 #ifdef TARGET_OS_ARCH_solaris_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	77 # include "globals_solaris_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	78 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	79 #ifdef TARGET_OS_ARCH_solaris_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	80 # include "globals_solaris_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	81 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	82 #ifdef TARGET_OS_ARCH_windows_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	83 # include "globals_windows_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	84 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	85 #ifdef TARGET_OS_ARCH_linux_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	86 # include "globals_linux_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	87 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	88 #ifdef TARGET_OS_ARCH_linux_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	89 # include "globals_linux_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	90 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	91 #ifdef TARGET_OS_ARCH_bsd_x86
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	92 # include "globals_bsd_x86.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	93 #endif
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	94 #ifdef TARGET_OS_ARCH_bsd_zero
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	95 # include "globals_bsd_zero.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	96 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	97 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	98 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	99 # include "c1_globals_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	100 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	101 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	102 # include "c1_globals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	103 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	104 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	105 # include "c1_globals_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	106 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	107 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	108 # include "c1_globals_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	109 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	110 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	111 # include "c1_globals_linux.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	112 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	113 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	114 # include "c1_globals_solaris.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	115 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	116 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	117 # include "c1_globals_windows.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	118 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	119 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	120 # include "c1_globals_bsd.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	121 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	122 #endif
7125 1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	123 #ifdef GRAAL
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	124 #ifdef TARGET_ARCH_x86
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	125 # include "graalGlobals_x86.hpp"
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	126 #endif
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	127 #ifdef TARGET_ARCH_sparc
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	128 # include "graalGlobals_sparc.hpp"
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	129 #endif
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	130 #ifdef TARGET_ARCH_arm
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	131 # include "graalGlobals_arm.hpp"
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	132 #endif
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	133 #ifdef TARGET_ARCH_ppc
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	134 # include "graalGlobals_ppc.hpp"
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	135 #endif
1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	136 #endif // GRAAL
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	137 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	138 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	139 # include "c2_globals_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	140 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	141 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	142 # include "c2_globals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	143 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	144 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	145 # include "c2_globals_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	146 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	147 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	148 # include "c2_globals_linux.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	149 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	150 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	151 # include "c2_globals_solaris.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	152 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	153 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	154 # include "c2_globals_windows.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	155 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	156 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	157 # include "c2_globals_bsd.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3910 diff changeset	158 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	159 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	160 #ifdef SHARK
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	161 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	162 # include "shark_globals_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	163 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	164 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	165
7125 1baf7f1e3f23 decoupled C++ Graal runtime from C1 Doug Simon <doug.simon@oracle.com> parents: 7068 diff changeset	166 #if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK) && !defined(GRAAL)
0 a61af66fc99e Initial load duke parents: diff changeset	167 define_pd_global(bool, BackgroundCompilation, false);
a61af66fc99e Initial load duke parents: diff changeset	168 define_pd_global(bool, UseTLAB, false);
a61af66fc99e Initial load duke parents: diff changeset	169 define_pd_global(bool, CICompileOSR, false);
a61af66fc99e Initial load duke parents: diff changeset	170 define_pd_global(bool, UseTypeProfile, false);
a61af66fc99e Initial load duke parents: diff changeset	171 define_pd_global(bool, UseOnStackReplacement, false);
a61af66fc99e Initial load duke parents: diff changeset	172 define_pd_global(bool, InlineIntrinsics, false);
a61af66fc99e Initial load duke parents: diff changeset	173 define_pd_global(bool, PreferInterpreterNativeStubs, true);
a61af66fc99e Initial load duke parents: diff changeset	174 define_pd_global(bool, ProfileInterpreter, false);
a61af66fc99e Initial load duke parents: diff changeset	175 define_pd_global(bool, ProfileTraps, false);
a61af66fc99e Initial load duke parents: diff changeset	176 define_pd_global(bool, TieredCompilation, false);
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 define_pd_global(intx, CompileThreshold, 0);
a61af66fc99e Initial load duke parents: diff changeset	179 define_pd_global(intx, BackEdgeThreshold, 0);
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 define_pd_global(intx, OnStackReplacePercentage, 0);
a61af66fc99e Initial load duke parents: diff changeset	182 define_pd_global(bool, ResizeTLAB, false);
a61af66fc99e Initial load duke parents: diff changeset	183 define_pd_global(intx, FreqInlineSize, 0);
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	184 define_pd_global(intx, InlineSmallCode, 0);
0 a61af66fc99e Initial load duke parents: diff changeset	185 define_pd_global(intx, NewSizeThreadIncrease, 4*K);
a61af66fc99e Initial load duke parents: diff changeset	186 define_pd_global(intx, InlineClassNatives, true);
a61af66fc99e Initial load duke parents: diff changeset	187 define_pd_global(intx, InlineUnsafeOps, true);
a61af66fc99e Initial load duke parents: diff changeset	188 define_pd_global(intx, InitialCodeCacheSize, 160*K);
a61af66fc99e Initial load duke parents: diff changeset	189 define_pd_global(intx, ReservedCodeCacheSize, 32*M);
a61af66fc99e Initial load duke parents: diff changeset	190 define_pd_global(intx, CodeCacheExpansionSize, 32*K);
a61af66fc99e Initial load duke parents: diff changeset	191 define_pd_global(intx, CodeCacheMinBlockLength, 1);
11106 e50be1620201 8020059: The flag introduced by 8014972 is not defined if Hotspot is built without a compiler (zero, ppc64 core build). goetz parents: 11083 diff changeset	192 define_pd_global(intx, CodeCacheMinimumUseSpace, 200*K);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	193 define_pd_global(uintx,MetaspaceSize, ScaleForWordSize(4*M));
0 a61af66fc99e Initial load duke parents: diff changeset	194 define_pd_global(bool, NeverActAsServerClassMachine, true);
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	195 define_pd_global(uint64_t,MaxRAM, 1ULL*G);
0 a61af66fc99e Initial load duke parents: diff changeset	196 #define CI_COMPILER_COUNT 0
a61af66fc99e Initial load duke parents: diff changeset	197 #else
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	200 #define CI_COMPILER_COUNT 2
a61af66fc99e Initial load duke parents: diff changeset	201 #else
a61af66fc99e Initial load duke parents: diff changeset	202 #define CI_COMPILER_COUNT 1
a61af66fc99e Initial load duke parents: diff changeset	203 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 #endif // no compilers
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 // string type aliases used only in this file
a61af66fc99e Initial load duke parents: diff changeset	208 typedef const char* ccstr;
a61af66fc99e Initial load duke parents: diff changeset	209 typedef const char* ccstrlist; // represents string arguments which accumulate
a61af66fc99e Initial load duke parents: diff changeset	210
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	211 struct Flag {
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	212 enum Flags {
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	213 // value origin
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	214 DEFAULT = 0,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	215 COMMAND_LINE = 1,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	216 ENVIRON_VAR = 2,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	217 CONFIG_FILE = 3,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	218 MANAGEMENT = 4,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	219 ERGONOMIC = 5,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	220 ATTACH_ON_DEMAND = 6,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	221 INTERNAL = 7,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	222
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	223 LAST_VALUE_ORIGIN = INTERNAL,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	224 VALUE_ORIGIN_BITS = 4,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	225 VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS),
0 a61af66fc99e Initial load duke parents: diff changeset	226
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	227 // flag kind
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	228 KIND_PRODUCT = 1 << 4,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	229 KIND_MANAGEABLE = 1 << 5,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	230 KIND_DIAGNOSTIC = 1 << 6,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	231 KIND_EXPERIMENTAL = 1 << 7,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	232 KIND_NOT_PRODUCT = 1 << 8,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	233 KIND_DEVELOP = 1 << 9,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	234 KIND_PLATFORM_DEPENDENT = 1 << 10,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	235 KIND_READ_WRITE = 1 << 11,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	236 KIND_C1 = 1 << 12,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	237 KIND_C2 = 1 << 13,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	238 KIND_ARCH = 1 << 14,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	239 KIND_SHARK = 1 << 15,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	240 KIND_LP64_PRODUCT = 1 << 16,
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	241 KIND_COMMERCIAL = 1 << 17,
12355 cefad50507d8 Merge with hs25-b53 Gilles Duboscq <duboscq@ssw.jku.at> parents: 12057 12326 diff changeset	242 KIND_GRAAL = 1 << 18,
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1749 diff changeset	243
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	244 KIND_MASK = ~VALUE_ORIGIN_MASK
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	245 };
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1749 diff changeset	246
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	247 const char* _type;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	248 const char* _name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	249 void* _addr;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	250 NOT_PRODUCT(const char* _doc;)
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	251 Flags _flags;
0 a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 // points to all Flags static array
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	254 static Flag* flags;
0 a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 // number of flags
a61af66fc99e Initial load duke parents: diff changeset	257 static size_t numFlags;
a61af66fc99e Initial load duke parents: diff changeset	258
11070 6e3634222155 8017611: Auto corrector for mistyped vm options tamao parents: 10405 diff changeset	259 static Flag* find_flag(const char* name, size_t length, bool allow_locked = false);
6e3634222155 8017611: Auto corrector for mistyped vm options tamao parents: 10405 diff changeset	260 static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
0 a61af66fc99e Initial load duke parents: diff changeset	261
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	262 void check_writable();
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	263
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	264 bool is_bool() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	265 bool get_bool() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	266 void set_bool(bool value);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	267
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	268 bool is_intx() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	269 intx get_intx() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	270 void set_intx(intx value);
0 a61af66fc99e Initial load duke parents: diff changeset	271
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	272 bool is_uintx() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	273 uintx get_uintx() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	274 void set_uintx(uintx value);
0 a61af66fc99e Initial load duke parents: diff changeset	275
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	276 bool is_uint64_t() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	277 uint64_t get_uint64_t() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	278 void set_uint64_t(uint64_t value);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	279
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	280 bool is_double() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	281 double get_double() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	282 void set_double(double value);
0 a61af66fc99e Initial load duke parents: diff changeset	283
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	284 bool is_ccstr() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	285 bool ccstr_accumulates() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	286 ccstr get_ccstr() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	287 void set_ccstr(ccstr value);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	288
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	289 Flags get_origin();
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	290 void set_origin(Flags origin);
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	291
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	292 bool is_default();
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	293 bool is_ergonomic();
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	294 bool is_command_line();
0 a61af66fc99e Initial load duke parents: diff changeset	295
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	296 bool is_product() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	297 bool is_manageable() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	298 bool is_diagnostic() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	299 bool is_experimental() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	300 bool is_notproduct() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	301 bool is_develop() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	302 bool is_read_write() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	303 bool is_commercial() const;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	304
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	305 bool is_constant_in_binary() const;
0 a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 bool is_unlocker() const;
a61af66fc99e Initial load duke parents: diff changeset	308 bool is_unlocked() const;
a61af66fc99e Initial load duke parents: diff changeset	309 bool is_writeable() const;
a61af66fc99e Initial load duke parents: diff changeset	310 bool is_external() const;
a61af66fc99e Initial load duke parents: diff changeset	311
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	312 bool is_unlocker_ext() const;
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	313 bool is_unlocked_ext() const;
4715 6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4125 diff changeset	314 bool is_writeable_ext() const;
6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4125 diff changeset	315 bool is_external_ext() const;
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	316
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 5915 diff changeset	317 void get_locked_message(char*, int) const;
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 5915 diff changeset	318 void get_locked_message_ext(char*, int) const;
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 5915 diff changeset	319
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1749 diff changeset	320 void print_on(outputStream* st, bool withComments = false );
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	321 void print_kind(outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	322 void print_as_flag(outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	323 };
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 // debug flags control various aspects of the VM and are global accessible
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 // use FlagSetting to temporarily change some debug flag
a61af66fc99e Initial load duke parents: diff changeset	328 // e.g. FlagSetting fs(DebugThisAndThat, true);
a61af66fc99e Initial load duke parents: diff changeset	329 // restored to previous value upon leaving scope
a61af66fc99e Initial load duke parents: diff changeset	330 class FlagSetting {
a61af66fc99e Initial load duke parents: diff changeset	331 bool val;
a61af66fc99e Initial load duke parents: diff changeset	332 bool* flag;
a61af66fc99e Initial load duke parents: diff changeset	333 public:
a61af66fc99e Initial load duke parents: diff changeset	334 FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }
a61af66fc99e Initial load duke parents: diff changeset	335 ~FlagSetting() { *flag = val; }
a61af66fc99e Initial load duke parents: diff changeset	336 };
a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338
a61af66fc99e Initial load duke parents: diff changeset	339 class CounterSetting {
a61af66fc99e Initial load duke parents: diff changeset	340 intx* counter;
a61af66fc99e Initial load duke parents: diff changeset	341 public:
a61af66fc99e Initial load duke parents: diff changeset	342 CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }
a61af66fc99e Initial load duke parents: diff changeset	343 ~CounterSetting() { (*counter)--; }
a61af66fc99e Initial load duke parents: diff changeset	344 };
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	347 class UIntFlagSetting {
12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	348 uintx val;
12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	349 uintx* flag;
0 a61af66fc99e Initial load duke parents: diff changeset	350 public:
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	351 UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	352 ~UIntFlagSetting() { *flag = val; }
0 a61af66fc99e Initial load duke parents: diff changeset	353 };
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355
a61af66fc99e Initial load duke parents: diff changeset	356 class DoubleFlagSetting {
a61af66fc99e Initial load duke parents: diff changeset	357 double val;
a61af66fc99e Initial load duke parents: diff changeset	358 double* flag;
a61af66fc99e Initial load duke parents: diff changeset	359 public:
a61af66fc99e Initial load duke parents: diff changeset	360 DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }
a61af66fc99e Initial load duke parents: diff changeset	361 ~DoubleFlagSetting() { *flag = val; }
a61af66fc99e Initial load duke parents: diff changeset	362 };
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364
a61af66fc99e Initial load duke parents: diff changeset	365 class CommandLineFlags {
a61af66fc99e Initial load duke parents: diff changeset	366 public:
a61af66fc99e Initial load duke parents: diff changeset	367 static bool boolAt(char* name, size_t len, bool* value);
a61af66fc99e Initial load duke parents: diff changeset	368 static bool boolAt(char* name, bool* value) { return boolAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	369 static bool boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	370 static bool boolAtPut(char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
0 a61af66fc99e Initial load duke parents: diff changeset	371
a61af66fc99e Initial load duke parents: diff changeset	372 static bool intxAt(char* name, size_t len, intx* value);
a61af66fc99e Initial load duke parents: diff changeset	373 static bool intxAt(char* name, intx* value) { return intxAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	374 static bool intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	375 static bool intxAtPut(char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); }
0 a61af66fc99e Initial load duke parents: diff changeset	376
a61af66fc99e Initial load duke parents: diff changeset	377 static bool uintxAt(char* name, size_t len, uintx* value);
a61af66fc99e Initial load duke parents: diff changeset	378 static bool uintxAt(char* name, uintx* value) { return uintxAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	379 static bool uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	380 static bool uintxAtPut(char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
0 a61af66fc99e Initial load duke parents: diff changeset	381
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	382 static bool uint64_tAt(char* name, size_t len, uint64_t* value);
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	383 static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	384 static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	385 static bool uint64_tAtPut(char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	386
0 a61af66fc99e Initial load duke parents: diff changeset	387 static bool doubleAt(char* name, size_t len, double* value);
a61af66fc99e Initial load duke parents: diff changeset	388 static bool doubleAt(char* name, double* value) { return doubleAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	389 static bool doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	390 static bool doubleAtPut(char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }
0 a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 static bool ccstrAt(char* name, size_t len, ccstr* value);
a61af66fc99e Initial load duke parents: diff changeset	393 static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); }
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	394 static bool ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin);
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	395 static bool ccstrAtPut(char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
0 a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 // Returns false if name is not a command line flag.
a61af66fc99e Initial load duke parents: diff changeset	398 static bool wasSetOnCmdline(const char* name, bool* value);
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	399 static void printSetFlags(outputStream* out);
0 a61af66fc99e Initial load duke parents: diff changeset	400
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	401 static void printFlags(outputStream* out, bool withComments);
0 a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 static void verify() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	404 };
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 // use this for flags that are true by default in the debug version but
a61af66fc99e Initial load duke parents: diff changeset	407 // false in the optimized version, and vice versa
a61af66fc99e Initial load duke parents: diff changeset	408 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	409 #define trueInDebug true
a61af66fc99e Initial load duke parents: diff changeset	410 #define falseInDebug false
a61af66fc99e Initial load duke parents: diff changeset	411 #else
a61af66fc99e Initial load duke parents: diff changeset	412 #define trueInDebug false
a61af66fc99e Initial load duke parents: diff changeset	413 #define falseInDebug true
a61af66fc99e Initial load duke parents: diff changeset	414 #endif
a61af66fc99e Initial load duke parents: diff changeset	415
a61af66fc99e Initial load duke parents: diff changeset	416 // use this for flags that are true per default in the product build
a61af66fc99e Initial load duke parents: diff changeset	417 // but false in development builds, and vice versa
a61af66fc99e Initial load duke parents: diff changeset	418 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	419 #define trueInProduct true
a61af66fc99e Initial load duke parents: diff changeset	420 #define falseInProduct false
a61af66fc99e Initial load duke parents: diff changeset	421 #else
a61af66fc99e Initial load duke parents: diff changeset	422 #define trueInProduct false
a61af66fc99e Initial load duke parents: diff changeset	423 #define falseInProduct true
a61af66fc99e Initial load duke parents: diff changeset	424 #endif
a61af66fc99e Initial load duke parents: diff changeset	425
3797 eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	426 #ifdef JAVASE_EMBEDDED
eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	427 #define falseInEmbedded false
eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	428 #else
eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	429 #define falseInEmbedded true
eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	430 #endif
eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	431
0 a61af66fc99e Initial load duke parents: diff changeset	432 // develop flags are settable / visible only during development and are constant in the PRODUCT version
a61af66fc99e Initial load duke parents: diff changeset	433 // product flags are always settable / visible
a61af66fc99e Initial load duke parents: diff changeset	434 // notproduct flags are settable / visible only during development and are not declared in the PRODUCT version
a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 // A flag must be declared with one of the following types:
a61af66fc99e Initial load duke parents: diff changeset	437 // bool, intx, uintx, ccstr.
a61af66fc99e Initial load duke parents: diff changeset	438 // The type "ccstr" is an alias for "const char*" and is used
a61af66fc99e Initial load duke parents: diff changeset	439 // only in this file, because the macrology requires single-token type names.
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 // Note: Diagnostic options not meant for VM tuning or for product modes.
a61af66fc99e Initial load duke parents: diff changeset	442 // They are to be used for VM quality assurance or field diagnosis
a61af66fc99e Initial load duke parents: diff changeset	443 // of VM bugs. They are hidden so that users will not be encouraged to
a61af66fc99e Initial load duke parents: diff changeset	444 // try them as if they were VM ordinary execution options. However, they
a61af66fc99e Initial load duke parents: diff changeset	445 // are available in the product version of the VM. Under instruction
a61af66fc99e Initial load duke parents: diff changeset	446 // from support engineers, VM customers can turn them on to collect
a61af66fc99e Initial load duke parents: diff changeset	447 // diagnostic information about VM problems. To use a VM diagnostic
a61af66fc99e Initial load duke parents: diff changeset	448 // option, you must first specify +UnlockDiagnosticVMOptions.
a61af66fc99e Initial load duke parents: diff changeset	449 // (This master switch also affects the behavior of -Xprintflags.)
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	450 //
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	451 // experimental flags are in support of features that are not
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	452 // part of the officially supported product, but are available
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	453 // for experimenting with. They could, for example, be performance
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	454 // features that may not have undergone full or rigorous QA, but which may
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	455 // help performance in some cases and released for experimentation
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	456 // by the community of users and developers. This flag also allows one to
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	457 // be able to build a fully supported product that nonetheless also
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	458 // ships with some unsupported, lightly tested, experimental features.
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	459 // Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	460 // UnlockExperimentalVMOptions flag, which allows the control and
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	461 // modification of the experimental flags.
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	462 //
1837 c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	463 // Nota bene: neither diagnostic nor experimental options should be used casually,
c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	464 // and they are not supported on production loads, except under explicit
c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	465 // direction from support engineers.
c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	466 //
0 a61af66fc99e Initial load duke parents: diff changeset	467 // manageable flags are writeable external product flags.
a61af66fc99e Initial load duke parents: diff changeset	468 // They are dynamically writeable through the JDK management interface
a61af66fc99e Initial load duke parents: diff changeset	469 // (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
a61af66fc99e Initial load duke parents: diff changeset	470 // These flags are external exported interface (see CCC). The list of
a61af66fc99e Initial load duke parents: diff changeset	471 // manageable flags can be queried programmatically through the management
a61af66fc99e Initial load duke parents: diff changeset	472 // interface.
a61af66fc99e Initial load duke parents: diff changeset	473 //
a61af66fc99e Initial load duke parents: diff changeset	474 // A flag can be made as "manageable" only if
a61af66fc99e Initial load duke parents: diff changeset	475 // - the flag is defined in a CCC as an external exported interface.
a61af66fc99e Initial load duke parents: diff changeset	476 // - the VM implementation supports dynamic setting of the flag.
a61af66fc99e Initial load duke parents: diff changeset	477 // This implies that the VM must always query the flag variable
a61af66fc99e Initial load duke parents: diff changeset	478 // and not reuse state related to the flag state at any given time.
a61af66fc99e Initial load duke parents: diff changeset	479 // - you want the flag to be queried programmatically by the customers.
a61af66fc99e Initial load duke parents: diff changeset	480 //
a61af66fc99e Initial load duke parents: diff changeset	481 // product_rw flags are writeable internal product flags.
a61af66fc99e Initial load duke parents: diff changeset	482 // They are like "manageable" flags but for internal/private use.
a61af66fc99e Initial load duke parents: diff changeset	483 // The list of product_rw flags are internal/private flags which
a61af66fc99e Initial load duke parents: diff changeset	484 // may be changed/removed in a future release. It can be set
a61af66fc99e Initial load duke parents: diff changeset	485 // through the management interface to get/set value
a61af66fc99e Initial load duke parents: diff changeset	486 // when the name of flag is supplied.
a61af66fc99e Initial load duke parents: diff changeset	487 //
a61af66fc99e Initial load duke parents: diff changeset	488 // A flag can be made as "product_rw" only if
a61af66fc99e Initial load duke parents: diff changeset	489 // - the VM implementation supports dynamic setting of the flag.
a61af66fc99e Initial load duke parents: diff changeset	490 // This implies that the VM must always query the flag variable
a61af66fc99e Initial load duke parents: diff changeset	491 // and not reuse state related to the flag state at any given time.
a61af66fc99e Initial load duke parents: diff changeset	492 //
a61af66fc99e Initial load duke parents: diff changeset	493 // Note that when there is a need to support develop flags to be writeable,
a61af66fc99e Initial load duke parents: diff changeset	494 // it can be done in the same way as product_rw.
a61af66fc99e Initial load duke parents: diff changeset	495
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	496 #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	497 \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	498 lp64_product(bool, UseCompressedOops, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	499 "Use 32-bit object references in 64-bit VM. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	500 "lp64_product means flag is always constant in 32 bit VM") \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	501 \
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12154 diff changeset	502 lp64_product(bool, UseCompressedClassPointers, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	503 "Use 32-bit class pointers in 64-bit VM. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	504 "lp64_product means flag is always constant in 32 bit VM") \
0 a61af66fc99e Initial load duke parents: diff changeset	505 \
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 615 diff changeset	506 notproduct(bool, CheckCompressedOops, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	507 "Generate checks in encoding/decoding code in debug VM") \
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 615 diff changeset	508 \
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 615 diff changeset	509 product_pd(uintx, HeapBaseMinAddress, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	510 "OS specific low limit for heap base address") \
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 615 diff changeset	511 \
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 615 diff changeset	512 diagnostic(bool, PrintCompressedOopsMode, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	513 "Print compressed oops base address and encoding mode") \
325 93befa083681 6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page coleenp parents: 300 diff changeset	514 \
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1544 diff changeset	515 lp64_product(intx, ObjectAlignmentInBytes, 8, \
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1544 diff changeset	516 "Default object alignment in bytes, 8 is minimum") \
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 1544 diff changeset	517 \
8845 1b90c7607451 2178143: JVM crashes if the number of bound CPUs changed during runtime minqi parents: 8819 diff changeset	518 product(bool, AssumeMP, false, \
1b90c7607451 2178143: JVM crashes if the number of bound CPUs changed during runtime minqi parents: 8819 diff changeset	519 "Instruct the VM to assume multiple processors are available") \
1b90c7607451 2178143: JVM crashes if the number of bound CPUs changed during runtime minqi parents: 8819 diff changeset	520 \
0 a61af66fc99e Initial load duke parents: diff changeset	521 /* UseMembar is theoretically a temp flag used for memory barrier \
a61af66fc99e Initial load duke parents: diff changeset	522 * removal testing. It was supposed to be removed before FCS but has \
a61af66fc99e Initial load duke parents: diff changeset	523 * been re-added (see 6401008) */ \
1868 3dc12ef8735e 6989297: Integrate additional portability improvements bobv parents: 1796 diff changeset	524 product_pd(bool, UseMembar, \
0 a61af66fc99e Initial load duke parents: diff changeset	525 "(Unstable) Issues membars on thread state transitions") \
a61af66fc99e Initial load duke parents: diff changeset	526 \
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	527 /* Temp PPC Flag to allow disabling the use of lwsync on ppc platforms \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	528 * that don't support it. This will be replaced by processor detection \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	529 * logic. \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	530 */ \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	531 product(bool, UsePPCLWSYNC, true, \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	532 "Use lwsync instruction if true, else use slower sync") \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	533 \
3799 48048b59a551 7061204: clean the chunk table synchronously in embedded builds jcoomes parents: 3797 diff changeset	534 develop(bool, CleanChunkPoolAsync, falseInEmbedded, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	535 "Clean the chunk pool asynchronously") \
3799 48048b59a551 7061204: clean the chunk table synchronously in embedded builds jcoomes parents: 3797 diff changeset	536 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	537 /* Temporary: See 6948537 */ \
1518 3bfae429e2cf 6948537: CMS: BOT walkers observe out-of-thin-air zeros on sun4v sparc/CMT ysr parents: 1490 diff changeset	538 experimental(bool, UseMemSetInBOT, true, \
3bfae429e2cf 6948537: CMS: BOT walkers observe out-of-thin-air zeros on sun4v sparc/CMT ysr parents: 1490 diff changeset	539 "(Unstable) uses memset in BOT updates in GC code") \
3bfae429e2cf 6948537: CMS: BOT walkers observe out-of-thin-air zeros on sun4v sparc/CMT ysr parents: 1490 diff changeset	540 \
0 a61af66fc99e Initial load duke parents: diff changeset	541 diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	542 "Enable normal processing of flags relating to field diagnostics")\
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	543 \
d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	544 experimental(bool, UnlockExperimentalVMOptions, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	545 "Enable normal processing of flags relating to experimental " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	546 "features") \
0 a61af66fc99e Initial load duke parents: diff changeset	547 \
a61af66fc99e Initial load duke parents: diff changeset	548 product(bool, JavaMonitorsInStackTrace, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	549 "Print information about Java monitor locks when the stacks are" \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	550 "dumped") \
0 a61af66fc99e Initial load duke parents: diff changeset	551 \
a61af66fc99e Initial load duke parents: diff changeset	552 product_pd(bool, UseLargePages, \
a61af66fc99e Initial load duke parents: diff changeset	553 "Use large page memory") \
a61af66fc99e Initial load duke parents: diff changeset	554 \
389 ee21eaa8ffe1 6660681: Incrementally reserve pages on win server 2003 for better large page affinity jmasa parents: 377 diff changeset	555 product_pd(bool, UseLargePagesIndividualAllocation, \
ee21eaa8ffe1 6660681: Incrementally reserve pages on win server 2003 for better large page affinity jmasa parents: 377 diff changeset	556 "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	557 \
ee21eaa8ffe1 6660681: Incrementally reserve pages on win server 2003 for better large page affinity jmasa parents: 377 diff changeset	558 develop(bool, LargePagesIndividualAllocationInjectError, false, \
ee21eaa8ffe1 6660681: Incrementally reserve pages on win server 2003 for better large page affinity jmasa parents: 377 diff changeset	559 "Fail large pages individual allocation") \
ee21eaa8ffe1 6660681: Incrementally reserve pages on win server 2003 for better large page affinity jmasa parents: 377 diff changeset	560 \
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12836 diff changeset	561 product(bool, UseLargePagesInMetaspace, false, \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12836 diff changeset	562 "Use large page memory in metaspace. " \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12836 diff changeset	563 "Only used if UseLargePages is enabled.") \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12836 diff changeset	564 \
0 a61af66fc99e Initial load duke parents: diff changeset	565 develop(bool, TracePageSizes, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	566 "Trace page size selection and usage") \
0 a61af66fc99e Initial load duke parents: diff changeset	567 \
a61af66fc99e Initial load duke parents: diff changeset	568 product(bool, UseNUMA, false, \
a61af66fc99e Initial load duke parents: diff changeset	569 "Use NUMA if available") \
a61af66fc99e Initial load duke parents: diff changeset	570 \
3885 3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	571 product(bool, UseNUMAInterleaving, false, \
3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	572 "Interleave memory across NUMA nodes if available") \
3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	573 \
3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	574 product(uintx, NUMAInterleaveGranularity, 2*M, \
3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	575 "Granularity to use for NUMA interleaving on Windows OS") \
3cd0157e1d4d 7082969: NUMA interleaving iveresov parents: 3854 diff changeset	576 \
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 455 diff changeset	577 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	578 "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	579 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	580 product(uintx, NUMAChunkResizeWeight, 20, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	581 "Percentage (0-100) used to weigh the current sample when " \
0 a61af66fc99e Initial load duke parents: diff changeset	582 "computing exponentially decaying average for " \
a61af66fc99e Initial load duke parents: diff changeset	583 "AdaptiveNUMAChunkSizing") \
a61af66fc99e Initial load duke parents: diff changeset	584 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	585 product(uintx, NUMASpaceResizeRate, 1*G, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	586 "Do not reallocate more than this amount per collection") \
0 a61af66fc99e Initial load duke parents: diff changeset	587 \
a61af66fc99e Initial load duke parents: diff changeset	588 product(bool, UseAdaptiveNUMAChunkSizing, true, \
a61af66fc99e Initial load duke parents: diff changeset	589 "Enable adaptive chunk sizing for NUMA") \
a61af66fc99e Initial load duke parents: diff changeset	590 \
a61af66fc99e Initial load duke parents: diff changeset	591 product(bool, NUMAStats, false, \
a61af66fc99e Initial load duke parents: diff changeset	592 "Print NUMA stats in detailed heap information") \
a61af66fc99e Initial load duke parents: diff changeset	593 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	594 product(uintx, NUMAPageScanRate, 256, \
0 a61af66fc99e Initial load duke parents: diff changeset	595 "Maximum number of pages to include in the page scan procedure") \
a61af66fc99e Initial load duke parents: diff changeset	596 \
a61af66fc99e Initial load duke parents: diff changeset	597 product_pd(bool, NeedsDeoptSuspend, \
a61af66fc99e Initial load duke parents: diff changeset	598 "True for register window machines (sparc/ia64)") \
a61af66fc99e Initial load duke parents: diff changeset	599 \
a61af66fc99e Initial load duke parents: diff changeset	600 product(intx, UseSSE, 99, \
a61af66fc99e Initial load duke parents: diff changeset	601 "Highest supported SSE instructions set on x86/x64") \
a61af66fc99e Initial load duke parents: diff changeset	602 \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	603 product(bool, UseAES, false, \
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6853 diff changeset	604 "Control whether AES instructions can be used on x86/x64") \
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6853 diff changeset	605 \
0 a61af66fc99e Initial load duke parents: diff changeset	606 product(uintx, LargePageSizeInBytes, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	607 "Large page size (0 to let VM choose the page size)") \
0 a61af66fc99e Initial load duke parents: diff changeset	608 \
a61af66fc99e Initial load duke parents: diff changeset	609 product(uintx, LargePageHeapSizeThreshold, 128*M, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	610 "Use large pages if maximum heap is at least this big") \
0 a61af66fc99e Initial load duke parents: diff changeset	611 \
a61af66fc99e Initial load duke parents: diff changeset	612 product(bool, ForceTimeHighResolution, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	613 "Using high time resolution (for Win32 only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	614 \
a61af66fc99e Initial load duke parents: diff changeset	615 develop(bool, TraceItables, false, \
a61af66fc99e Initial load duke parents: diff changeset	616 "Trace initialization and use of itables") \
a61af66fc99e Initial load duke parents: diff changeset	617 \
a61af66fc99e Initial load duke parents: diff changeset	618 develop(bool, TracePcPatching, false, \
a61af66fc99e Initial load duke parents: diff changeset	619 "Trace usage of frame::patch_pc") \
a61af66fc99e Initial load duke parents: diff changeset	620 \
a61af66fc99e Initial load duke parents: diff changeset	621 develop(bool, TraceJumps, false, \
a61af66fc99e Initial load duke parents: diff changeset	622 "Trace assembly jumps in thread ring buffer") \
a61af66fc99e Initial load duke parents: diff changeset	623 \
a61af66fc99e Initial load duke parents: diff changeset	624 develop(bool, TraceRelocator, false, \
a61af66fc99e Initial load duke parents: diff changeset	625 "Trace the bytecode relocator") \
a61af66fc99e Initial load duke parents: diff changeset	626 \
a61af66fc99e Initial load duke parents: diff changeset	627 develop(bool, TraceLongCompiles, false, \
a61af66fc99e Initial load duke parents: diff changeset	628 "Print out every time compilation is longer than " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	629 "a given threshold") \
0 a61af66fc99e Initial load duke parents: diff changeset	630 \
a61af66fc99e Initial load duke parents: diff changeset	631 develop(bool, SafepointALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	632 "Generate a lot of safepoints. This works with " \
0 a61af66fc99e Initial load duke parents: diff changeset	633 "GuaranteedSafepointInterval") \
a61af66fc99e Initial load duke parents: diff changeset	634 \
a61af66fc99e Initial load duke parents: diff changeset	635 product_pd(bool, BackgroundCompilation, \
a61af66fc99e Initial load duke parents: diff changeset	636 "A thread requesting compilation is not blocked during " \
a61af66fc99e Initial load duke parents: diff changeset	637 "compilation") \
a61af66fc99e Initial load duke parents: diff changeset	638 \
a61af66fc99e Initial load duke parents: diff changeset	639 product(bool, PrintVMQWaitTime, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	640 "Print out the waiting time in VM operation queue") \
0 a61af66fc99e Initial load duke parents: diff changeset	641 \
a61af66fc99e Initial load duke parents: diff changeset	642 develop(bool, NoYieldsInMicrolock, false, \
a61af66fc99e Initial load duke parents: diff changeset	643 "Disable yields in microlock") \
a61af66fc99e Initial load duke parents: diff changeset	644 \
a61af66fc99e Initial load duke parents: diff changeset	645 develop(bool, TraceOopMapGeneration, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	646 "Show OopMapGeneration") \
0 a61af66fc99e Initial load duke parents: diff changeset	647 \
a61af66fc99e Initial load duke parents: diff changeset	648 product(bool, MethodFlushing, true, \
a61af66fc99e Initial load duke parents: diff changeset	649 "Reclamation of zombie and not-entrant methods") \
a61af66fc99e Initial load duke parents: diff changeset	650 \
a61af66fc99e Initial load duke parents: diff changeset	651 develop(bool, VerifyStack, false, \
a61af66fc99e Initial load duke parents: diff changeset	652 "Verify stack of each thread when it is entering a runtime call") \
a61af66fc99e Initial load duke parents: diff changeset	653 \
4059 44ce519bc3d1 7104960: JSR 292: +VerifyMethodHandles in product JVM can overflow buffer never parents: 4039 diff changeset	654 diagnostic(bool, ForceUnreachable, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	655 "Make all non code cache addresses to be unreachable by " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	656 "forcing use of 64bit literal fixups") \
0 a61af66fc99e Initial load duke parents: diff changeset	657 \
a61af66fc99e Initial load duke parents: diff changeset	658 notproduct(bool, StressDerivedPointers, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	659 "Force scavenge when a derived pointer is detected on stack " \
0 a61af66fc99e Initial load duke parents: diff changeset	660 "after rtm call") \
a61af66fc99e Initial load duke parents: diff changeset	661 \
a61af66fc99e Initial load duke parents: diff changeset	662 develop(bool, TraceDerivedPointers, false, \
a61af66fc99e Initial load duke parents: diff changeset	663 "Trace traversal of derived pointers on stack") \
a61af66fc99e Initial load duke parents: diff changeset	664 \
a61af66fc99e Initial load duke parents: diff changeset	665 notproduct(bool, TraceCodeBlobStacks, false, \
a61af66fc99e Initial load duke parents: diff changeset	666 "Trace stack-walk of codeblobs") \
a61af66fc99e Initial load duke parents: diff changeset	667 \
a61af66fc99e Initial load duke parents: diff changeset	668 product(bool, PrintJNIResolving, false, \
a61af66fc99e Initial load duke parents: diff changeset	669 "Used to implement -v:jni") \
a61af66fc99e Initial load duke parents: diff changeset	670 \
a61af66fc99e Initial load duke parents: diff changeset	671 notproduct(bool, PrintRewrites, false, \
a61af66fc99e Initial load duke parents: diff changeset	672 "Print methods that are being rewritten") \
a61af66fc99e Initial load duke parents: diff changeset	673 \
a61af66fc99e Initial load duke parents: diff changeset	674 product(bool, UseInlineCaches, true, \
a61af66fc99e Initial load duke parents: diff changeset	675 "Use Inline Caches for virtual calls ") \
a61af66fc99e Initial load duke parents: diff changeset	676 \
a61af66fc99e Initial load duke parents: diff changeset	677 develop(bool, InlineArrayCopy, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	678 "Inline arraycopy native that is known to be part of " \
0 a61af66fc99e Initial load duke parents: diff changeset	679 "base library DLL") \
a61af66fc99e Initial load duke parents: diff changeset	680 \
a61af66fc99e Initial load duke parents: diff changeset	681 develop(bool, InlineObjectHash, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	682 "Inline Object::hashCode() native that is known to be part " \
0 a61af66fc99e Initial load duke parents: diff changeset	683 "of base library DLL") \
a61af66fc99e Initial load duke parents: diff changeset	684 \
a61af66fc99e Initial load duke parents: diff changeset	685 develop(bool, InlineNatives, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	686 "Inline natives that are known to be part of base library DLL") \
0 a61af66fc99e Initial load duke parents: diff changeset	687 \
a61af66fc99e Initial load duke parents: diff changeset	688 develop(bool, InlineMathNatives, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	689 "Inline SinD, CosD, etc.") \
0 a61af66fc99e Initial load duke parents: diff changeset	690 \
a61af66fc99e Initial load duke parents: diff changeset	691 develop(bool, InlineClassNatives, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	692 "Inline Class.isInstance, etc") \
0 a61af66fc99e Initial load duke parents: diff changeset	693 \
a61af66fc99e Initial load duke parents: diff changeset	694 develop(bool, InlineThreadNatives, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	695 "Inline Thread.currentThread, etc") \
0 a61af66fc99e Initial load duke parents: diff changeset	696 \
a61af66fc99e Initial load duke parents: diff changeset	697 develop(bool, InlineUnsafeOps, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	698 "Inline memory ops (native methods) from sun.misc.Unsafe") \
0 a61af66fc99e Initial load duke parents: diff changeset	699 \
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4872 diff changeset	700 product(bool, CriticalJNINatives, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	701 "Check for critical JNI entry points") \
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4872 diff changeset	702 \
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4872 diff changeset	703 notproduct(bool, StressCriticalJNINatives, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	704 "Exercise register saving code in critical natives") \
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4872 diff changeset	705 \
681 fbde8ec322d0 6761600: Use sse 4.2 in intrinsics cfang parents: 675 diff changeset	706 product(bool, UseSSE42Intrinsics, false, \
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics cfang parents: 675 diff changeset	707 "SSE4.2 versions of intrinsics") \
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics cfang parents: 675 diff changeset	708 \
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6853 diff changeset	709 product(bool, UseAESIntrinsics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	710 "Use intrinsics for AES versions of crypto") \
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6853 diff changeset	711 \
11080 b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 11079 diff changeset	712 product(bool, UseCRC32Intrinsics, false, \
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 11079 diff changeset	713 "use intrinsics for java.util.zip.CRC32") \
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 11079 diff changeset	714 \
0 a61af66fc99e Initial load duke parents: diff changeset	715 develop(bool, TraceCallFixup, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	716 "Trace all call fixups") \
0 a61af66fc99e Initial load duke parents: diff changeset	717 \
a61af66fc99e Initial load duke parents: diff changeset	718 develop(bool, DeoptimizeALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	719 "Deoptimize at every exit from the runtime system") \
0 a61af66fc99e Initial load duke parents: diff changeset	720 \
434 de78b80cedec 6772413: code cleanup kvn parents: 431 diff changeset	721 notproduct(ccstrlist, DeoptimizeOnlyAt, "", \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	722 "A comma separated list of bcis to deoptimize at") \
0 a61af66fc99e Initial load duke parents: diff changeset	723 \
a61af66fc99e Initial load duke parents: diff changeset	724 product(bool, DeoptimizeRandom, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	725 "Deoptimize random frames on random exit from the runtime system")\
0 a61af66fc99e Initial load duke parents: diff changeset	726 \
a61af66fc99e Initial load duke parents: diff changeset	727 notproduct(bool, ZombieALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	728 "Create zombies (non-entrant) at exit from the runtime system") \
0 a61af66fc99e Initial load duke parents: diff changeset	729 \
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2125 diff changeset	730 product(bool, UnlinkSymbolsALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	731 "Unlink unreferenced symbols from the symbol table at safepoints")\
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2125 diff changeset	732 \
0 a61af66fc99e Initial load duke parents: diff changeset	733 notproduct(bool, WalkStackALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	734 "Trace stack (no print) at every exit from the runtime system") \
0 a61af66fc99e Initial load duke parents: diff changeset	735 \
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3964 diff changeset	736 product(bool, Debugging, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	737 "Set when executing debug methods in debug.cpp " \
0 a61af66fc99e Initial load duke parents: diff changeset	738 "(to prevent triggering assertions)") \
a61af66fc99e Initial load duke parents: diff changeset	739 \
a61af66fc99e Initial load duke parents: diff changeset	740 notproduct(bool, StrictSafepointChecks, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	741 "Enable strict checks that safepoints cannot happen for threads " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	742 "that use No_Safepoint_Verifier") \
0 a61af66fc99e Initial load duke parents: diff changeset	743 \
a61af66fc99e Initial load duke parents: diff changeset	744 notproduct(bool, VerifyLastFrame, false, \
a61af66fc99e Initial load duke parents: diff changeset	745 "Verify oops on last frame on entry to VM") \
a61af66fc99e Initial load duke parents: diff changeset	746 \
a61af66fc99e Initial load duke parents: diff changeset	747 develop(bool, TraceHandleAllocation, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	748 "Print out warnings when suspiciously many handles are allocated")\
0 a61af66fc99e Initial load duke parents: diff changeset	749 \
a61af66fc99e Initial load duke parents: diff changeset	750 product(bool, UseCompilerSafepoints, true, \
a61af66fc99e Initial load duke parents: diff changeset	751 "Stop at safepoints in compiled code") \
a61af66fc99e Initial load duke parents: diff changeset	752 \
a61af66fc99e Initial load duke parents: diff changeset	753 product(bool, FailOverToOldVerifier, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	754 "Fail over to old verifier when split verifier fails") \
0 a61af66fc99e Initial load duke parents: diff changeset	755 \
a61af66fc99e Initial load duke parents: diff changeset	756 develop(bool, ShowSafepointMsgs, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	757 "Show message about safepoint synchronization") \
0 a61af66fc99e Initial load duke parents: diff changeset	758 \
a61af66fc99e Initial load duke parents: diff changeset	759 product(bool, SafepointTimeout, false, \
a61af66fc99e Initial load duke parents: diff changeset	760 "Time out and warn or fail after SafepointTimeoutDelay " \
a61af66fc99e Initial load duke parents: diff changeset	761 "milliseconds if failed to reach safepoint") \
a61af66fc99e Initial load duke parents: diff changeset	762 \
a61af66fc99e Initial load duke parents: diff changeset	763 develop(bool, DieOnSafepointTimeout, false, \
a61af66fc99e Initial load duke parents: diff changeset	764 "Die upon failure to reach safepoint (see SafepointTimeout)") \
a61af66fc99e Initial load duke parents: diff changeset	765 \
a61af66fc99e Initial load duke parents: diff changeset	766 /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */ \
a61af66fc99e Initial load duke parents: diff changeset	767 /* typically, at most a few retries are needed */ \
a61af66fc99e Initial load duke parents: diff changeset	768 product(intx, SuspendRetryCount, 50, \
a61af66fc99e Initial load duke parents: diff changeset	769 "Maximum retry count for an external suspend request") \
a61af66fc99e Initial load duke parents: diff changeset	770 \
a61af66fc99e Initial load duke parents: diff changeset	771 product(intx, SuspendRetryDelay, 5, \
a61af66fc99e Initial load duke parents: diff changeset	772 "Milliseconds to delay per retry (* current_retry_count)") \
a61af66fc99e Initial load duke parents: diff changeset	773 \
a61af66fc99e Initial load duke parents: diff changeset	774 product(bool, AssertOnSuspendWaitFailure, false, \
a61af66fc99e Initial load duke parents: diff changeset	775 "Assert/Guarantee on external suspend wait failure") \
a61af66fc99e Initial load duke parents: diff changeset	776 \
a61af66fc99e Initial load duke parents: diff changeset	777 product(bool, TraceSuspendWaitFailures, false, \
a61af66fc99e Initial load duke parents: diff changeset	778 "Trace external suspend wait failures") \
a61af66fc99e Initial load duke parents: diff changeset	779 \
a61af66fc99e Initial load duke parents: diff changeset	780 product(bool, MaxFDLimit, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	781 "Bump the number of file descriptors to maximum in Solaris") \
0 a61af66fc99e Initial load duke parents: diff changeset	782 \
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4868 diff changeset	783 diagnostic(bool, LogEvents, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	784 "Enable the various ring buffer event logs") \
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4868 diff changeset	785 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	786 diagnostic(uintx, LogEventsBufferEntries, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	787 "Number of ring buffer event logs") \
0 a61af66fc99e Initial load duke parents: diff changeset	788 \
a61af66fc99e Initial load duke parents: diff changeset	789 product(bool, BytecodeVerificationRemote, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	790 "Enable the Java bytecode verifier for remote classes") \
0 a61af66fc99e Initial load duke parents: diff changeset	791 \
a61af66fc99e Initial load duke parents: diff changeset	792 product(bool, BytecodeVerificationLocal, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	793 "Enable the Java bytecode verifier for local classes") \
0 a61af66fc99e Initial load duke parents: diff changeset	794 \
a61af66fc99e Initial load duke parents: diff changeset	795 develop(bool, ForceFloatExceptions, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	796 "Force exceptions on FP stack under/overflow") \
a61af66fc99e Initial load duke parents: diff changeset	797 \
a61af66fc99e Initial load duke parents: diff changeset	798 develop(bool, VerifyStackAtCalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	799 "Verify that the stack pointer is unchanged after calls") \
a61af66fc99e Initial load duke parents: diff changeset	800 \
a61af66fc99e Initial load duke parents: diff changeset	801 develop(bool, TraceJavaAssertions, false, \
a61af66fc99e Initial load duke parents: diff changeset	802 "Trace java language assertions") \
a61af66fc99e Initial load duke parents: diff changeset	803 \
a61af66fc99e Initial load duke parents: diff changeset	804 notproduct(bool, CheckAssertionStatusDirectives, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	805 "Temporary - see javaClasses.cpp") \
0 a61af66fc99e Initial load duke parents: diff changeset	806 \
a61af66fc99e Initial load duke parents: diff changeset	807 notproduct(bool, PrintMallocFree, false, \
a61af66fc99e Initial load duke parents: diff changeset	808 "Trace calls to C heap malloc/free allocation") \
a61af66fc99e Initial load duke parents: diff changeset	809 \
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1660 diff changeset	810 product(bool, PrintOopAddress, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	811 "Always print the location of the oop") \
a61af66fc99e Initial load duke parents: diff changeset	812 \
a61af66fc99e Initial load duke parents: diff changeset	813 notproduct(bool, VerifyCodeCacheOften, false, \
a61af66fc99e Initial load duke parents: diff changeset	814 "Verify compiled-code cache often") \
a61af66fc99e Initial load duke parents: diff changeset	815 \
a61af66fc99e Initial load duke parents: diff changeset	816 develop(bool, ZapDeadCompiledLocals, false, \
a61af66fc99e Initial load duke parents: diff changeset	817 "Zap dead locals in compiler frames") \
a61af66fc99e Initial load duke parents: diff changeset	818 \
a61af66fc99e Initial load duke parents: diff changeset	819 notproduct(bool, ZapDeadLocalsOld, false, \
a61af66fc99e Initial load duke parents: diff changeset	820 "Zap dead locals (old version, zaps all frames when " \
a61af66fc99e Initial load duke parents: diff changeset	821 "entering the VM") \
a61af66fc99e Initial load duke parents: diff changeset	822 \
a61af66fc99e Initial load duke parents: diff changeset	823 notproduct(bool, CheckOopishValues, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	824 "Warn if value contains oop (requires ZapDeadLocals)") \
0 a61af66fc99e Initial load duke parents: diff changeset	825 \
a61af66fc99e Initial load duke parents: diff changeset	826 develop(bool, UseMallocOnly, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	827 "Use only malloc/free for allocation (no resource area/arena)") \
0 a61af66fc99e Initial load duke parents: diff changeset	828 \
a61af66fc99e Initial load duke parents: diff changeset	829 develop(bool, PrintMalloc, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	830 "Print all malloc/free calls") \
0 a61af66fc99e Initial load duke parents: diff changeset	831 \
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2177 diff changeset	832 develop(bool, PrintMallocStatistics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	833 "Print malloc/free statistics") \
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2177 diff changeset	834 \
0 a61af66fc99e Initial load duke parents: diff changeset	835 develop(bool, ZapResourceArea, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	836 "Zap freed resource/arena space with 0xABABABAB") \
a61af66fc99e Initial load duke parents: diff changeset	837 \
a61af66fc99e Initial load duke parents: diff changeset	838 notproduct(bool, ZapVMHandleArea, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	839 "Zap freed VM handle space with 0xBCBCBCBC") \
a61af66fc99e Initial load duke parents: diff changeset	840 \
a61af66fc99e Initial load duke parents: diff changeset	841 develop(bool, ZapJNIHandleArea, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	842 "Zap freed JNI handle space with 0xFEFEFEFE") \
a61af66fc99e Initial load duke parents: diff changeset	843 \
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1778 diff changeset	844 notproduct(bool, ZapStackSegments, trueInDebug, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	845 "Zap allocated/freed stack segments with 0xFADFADED") \
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1778 diff changeset	846 \
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 219 diff changeset	847 develop(bool, ZapUnusedHeapArea, trueInDebug, \
0 a61af66fc99e Initial load duke parents: diff changeset	848 "Zap unused heap space with 0xBAADBABE") \
a61af66fc99e Initial load duke parents: diff changeset	849 \
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 219 diff changeset	850 develop(bool, TraceZapUnusedHeapArea, false, \
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 219 diff changeset	851 "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	852 \
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 219 diff changeset	853 develop(bool, CheckZapUnusedHeapArea, false, \
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 219 diff changeset	854 "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	855 \
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 462 diff changeset	856 develop(bool, ZapFillerObjects, trueInDebug, \
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 462 diff changeset	857 "Zap filler objects with 0xDEAFBABE") \
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 462 diff changeset	858 \
0 a61af66fc99e Initial load duke parents: diff changeset	859 develop(bool, PrintVMMessages, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	860 "Print VM messages on console") \
0 a61af66fc99e Initial load duke parents: diff changeset	861 \
a61af66fc99e Initial load duke parents: diff changeset	862 product(bool, PrintGCApplicationConcurrentTime, false, \
a61af66fc99e Initial load duke parents: diff changeset	863 "Print the time the application has been running") \
a61af66fc99e Initial load duke parents: diff changeset	864 \
a61af66fc99e Initial load duke parents: diff changeset	865 product(bool, PrintGCApplicationStoppedTime, false, \
a61af66fc99e Initial load duke parents: diff changeset	866 "Print the time the application has been stopped") \
a61af66fc99e Initial load duke parents: diff changeset	867 \
6605 4ee06e614636 7116786: RFE: Detailed information on VerifyErrors kamg parents: 6199 diff changeset	868 diagnostic(bool, VerboseVerification, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	869 "Display detailed verification details") \
6605 4ee06e614636 7116786: RFE: Detailed information on VerifyErrors kamg parents: 6199 diff changeset	870 \
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1367 diff changeset	871 notproduct(uintx, ErrorHandlerTest, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	872 "If > 0, provokes an error after VM initialization; the value " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	873 "determines which error to provoke. See test_error_handler() " \
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1367 diff changeset	874 "in debug.cpp.") \
f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1367 diff changeset	875 \
0 a61af66fc99e Initial load duke parents: diff changeset	876 develop(bool, Verbose, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	877 "Print additional debugging information from other modes") \
0 a61af66fc99e Initial load duke parents: diff changeset	878 \
a61af66fc99e Initial load duke parents: diff changeset	879 develop(bool, PrintMiscellaneous, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	880 "Print uncategorized debugging information (requires +Verbose)") \
0 a61af66fc99e Initial load duke parents: diff changeset	881 \
a61af66fc99e Initial load duke parents: diff changeset	882 develop(bool, WizardMode, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	883 "Print much more debugging information") \
0 a61af66fc99e Initial load duke parents: diff changeset	884 \
a61af66fc99e Initial load duke parents: diff changeset	885 product(bool, ShowMessageBoxOnError, false, \
a61af66fc99e Initial load duke parents: diff changeset	886 "Keep process alive on VM fatal error") \
a61af66fc99e Initial load duke parents: diff changeset	887 \
2204 63d374c54045 7014918: Improve core/minidump handling in Hotspot ctornqvi parents: 2199 diff changeset	888 product(bool, CreateMinidumpOnCrash, false, \
63d374c54045 7014918: Improve core/minidump handling in Hotspot ctornqvi parents: 2199 diff changeset	889 "Create minidump on VM fatal error") \
63d374c54045 7014918: Improve core/minidump handling in Hotspot ctornqvi parents: 2199 diff changeset	890 \
0 a61af66fc99e Initial load duke parents: diff changeset	891 product_pd(bool, UseOSErrorReporting, \
a61af66fc99e Initial load duke parents: diff changeset	892 "Let VM fatal error propagate to the OS (ie. WER on Windows)") \
a61af66fc99e Initial load duke parents: diff changeset	893 \
a61af66fc99e Initial load duke parents: diff changeset	894 product(bool, SuppressFatalErrorMessage, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	895 "Report NO fatal error message (avoid deadlock)") \
0 a61af66fc99e Initial load duke parents: diff changeset	896 \
a61af66fc99e Initial load duke parents: diff changeset	897 product(ccstrlist, OnError, "", \
a61af66fc99e Initial load duke parents: diff changeset	898 "Run user-defined commands on fatal error; see VMError.cpp " \
a61af66fc99e Initial load duke parents: diff changeset	899 "for examples") \
a61af66fc99e Initial load duke parents: diff changeset	900 \
a61af66fc99e Initial load duke parents: diff changeset	901 product(ccstrlist, OnOutOfMemoryError, "", \
a61af66fc99e Initial load duke parents: diff changeset	902 "Run user-defined commands on first java.lang.OutOfMemoryError") \
a61af66fc99e Initial load duke parents: diff changeset	903 \
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	904 manageable(bool, HeapDumpBeforeFullGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	905 "Dump heap to file before any major stop-the-world GC") \
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	906 \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	907 manageable(bool, HeapDumpAfterFullGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	908 "Dump heap to file after any major stop-the-world GC") \
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	909 \
0 a61af66fc99e Initial load duke parents: diff changeset	910 manageable(bool, HeapDumpOnOutOfMemoryError, false, \
a61af66fc99e Initial load duke parents: diff changeset	911 "Dump heap to file when java.lang.OutOfMemoryError is thrown") \
a61af66fc99e Initial load duke parents: diff changeset	912 \
a61af66fc99e Initial load duke parents: diff changeset	913 manageable(ccstr, HeapDumpPath, NULL, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	914 "When HeapDumpOnOutOfMemoryError is on, the path (filename or " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	915 "directory) of the dump file (defaults to java_pid<pid>.hprof " \
0 a61af66fc99e Initial load duke parents: diff changeset	916 "in the working directory)") \
a61af66fc99e Initial load duke parents: diff changeset	917 \
a61af66fc99e Initial load duke parents: diff changeset	918 develop(uintx, SegmentedHeapDumpThreshold, 2*G, \
a61af66fc99e Initial load duke parents: diff changeset	919 "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) " \
a61af66fc99e Initial load duke parents: diff changeset	920 "when the heap usage is larger than this") \
a61af66fc99e Initial load duke parents: diff changeset	921 \
a61af66fc99e Initial load duke parents: diff changeset	922 develop(uintx, HeapDumpSegmentSize, 1*G, \
a61af66fc99e Initial load duke parents: diff changeset	923 "Approximate segment size when generating a segmented heap dump") \
a61af66fc99e Initial load duke parents: diff changeset	924 \
a61af66fc99e Initial load duke parents: diff changeset	925 develop(bool, BreakAtWarning, false, \
a61af66fc99e Initial load duke parents: diff changeset	926 "Execute breakpoint upon encountering VM warning") \
a61af66fc99e Initial load duke parents: diff changeset	927 \
a61af66fc99e Initial load duke parents: diff changeset	928 develop(bool, TraceVMOperation, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	929 "Trace VM operations") \
0 a61af66fc99e Initial load duke parents: diff changeset	930 \
a61af66fc99e Initial load duke parents: diff changeset	931 develop(bool, UseFakeTimers, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	932 "Tell whether the VM should use system time or a fake timer") \
0 a61af66fc99e Initial load duke parents: diff changeset	933 \
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6166 diff changeset	934 product(ccstr, NativeMemoryTracking, "off", \
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6166 diff changeset	935 "Native memory tracking options") \
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6166 diff changeset	936 \
6770 9a86ddfc6c8f 7188594: Print statistic collected by NMT with VM flag zgu parents: 6736 diff changeset	937 diagnostic(bool, PrintNMTStatistics, false, \
9a86ddfc6c8f 7188594: Print statistic collected by NMT with VM flag zgu parents: 6736 diff changeset	938 "Print native memory tracking summary data if it is on") \
9a86ddfc6c8f 7188594: Print statistic collected by NMT with VM flag zgu parents: 6736 diff changeset	939 \
8810 06db4c0afbf3 8009298: NMT: Special version of class loading/unloading with runThese stresses out NMT zgu parents: 8802 diff changeset	940 diagnostic(bool, AutoShutdownNMT, true, \
06db4c0afbf3 8009298: NMT: Special version of class loading/unloading with runThese stresses out NMT zgu parents: 8802 diff changeset	941 "Automatically shutdown native memory tracking under stress " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	942 "situations. When set to false, native memory tracking tries to " \
8810 06db4c0afbf3 8009298: NMT: Special version of class loading/unloading with runThese stresses out NMT zgu parents: 8802 diff changeset	943 "stay alive at the expense of JVM performance") \
06db4c0afbf3 8009298: NMT: Special version of class loading/unloading with runThese stresses out NMT zgu parents: 8802 diff changeset	944 \
0 a61af66fc99e Initial load duke parents: diff changeset	945 diagnostic(bool, LogCompilation, false, \
12257 01b268b3080a 8023134: Rename VM LogFile to hotspot_pid{pid}.log (was hotspot.log) vlivanov parents: 12190 diff changeset	946 "Log compilation activity in detail to LogFile") \
0 a61af66fc99e Initial load duke parents: diff changeset	947 \
a61af66fc99e Initial load duke parents: diff changeset	948 product(bool, PrintCompilation, false, \
a61af66fc99e Initial load duke parents: diff changeset	949 "Print compilations") \
a61af66fc99e Initial load duke parents: diff changeset	950 \
a61af66fc99e Initial load duke parents: diff changeset	951 diagnostic(bool, TraceNMethodInstalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	952 "Trace nmethod installation") \
0 a61af66fc99e Initial load duke parents: diff changeset	953 \
4119 7793051af7d6 7110058: change default for ScavengeRootsInCode to 2 twisti parents: 4065 diff changeset	954 diagnostic(intx, ScavengeRootsInCode, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	955 "0: do not allow scavengable oops in the code cache; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	956 "1: allow scavenging from the code cache; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	957 "2: emit as many constants as the compiler can see") \
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 910 diff changeset	958 \
0 a61af66fc99e Initial load duke parents: diff changeset	959 product(bool, AlwaysRestoreFPU, false, \
a61af66fc99e Initial load duke parents: diff changeset	960 "Restore the FPU control word after every JNI call (expensive)") \
a61af66fc99e Initial load duke parents: diff changeset	961 \
4064 670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 4059 diff changeset	962 diagnostic(bool, PrintCompilation2, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	963 "Print additional statistics per compilation") \
a61af66fc99e Initial load duke parents: diff changeset	964 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	965 diagnostic(bool, PrintAdapterHandlers, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	966 "Print code generated for i2c/c2i adapters") \
a61af66fc99e Initial load duke parents: diff changeset	967 \
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6199 diff changeset	968 diagnostic(bool, VerifyAdapterCalls, trueInDebug, \
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6199 diff changeset	969 "Verify that i2c/c2i adapters are called properly") \
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6199 diff changeset	970 \
1207 74c848d437ab 6921922: fix for 6911204 breaks tagged stack interpreter never parents: 1206 diff changeset	971 develop(bool, VerifyAdapterSharing, false, \
74c848d437ab 6921922: fix for 6911204 breaks tagged stack interpreter never parents: 1206 diff changeset	972 "Verify that the code for shared adapters is the equivalent") \
74c848d437ab 6921922: fix for 6911204 breaks tagged stack interpreter never parents: 1206 diff changeset	973 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	974 diagnostic(bool, PrintAssembly, false, \
c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	975 "Print assembly code (using external disassembler.so)") \
c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	976 \
370 885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 325 diff changeset	977 diagnostic(ccstr, PrintAssemblyOptions, NULL, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	978 "Print options string passed to disassembler.so") \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	979 \
12356 359f7e70ae7f Reduce HotSpot diff and fix previous merge Gilles Duboscq <duboscq@ssw.jku.at> parents: 12355 diff changeset	980 product(bool, PrintNMethodStatistics, false, \
359f7e70ae7f Reduce HotSpot diff and fix previous merge Gilles Duboscq <duboscq@ssw.jku.at> parents: 12355 diff changeset	981 "Print a summary statistic for the generated nmethods") \
359f7e70ae7f Reduce HotSpot diff and fix previous merge Gilles Duboscq <duboscq@ssw.jku.at> parents: 12355 diff changeset	982 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	983 diagnostic(bool, PrintNMethods, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	984 "Print assembly code for nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	985 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	986 diagnostic(bool, PrintNativeNMethods, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	987 "Print assembly code for native nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	988 \
a61af66fc99e Initial load duke parents: diff changeset	989 develop(bool, PrintDebugInfo, false, \
a61af66fc99e Initial load duke parents: diff changeset	990 "Print debug information for all nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	991 \
a61af66fc99e Initial load duke parents: diff changeset	992 develop(bool, PrintRelocations, false, \
a61af66fc99e Initial load duke parents: diff changeset	993 "Print relocation information for all nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	994 \
a61af66fc99e Initial load duke parents: diff changeset	995 develop(bool, PrintDependencies, false, \
a61af66fc99e Initial load duke parents: diff changeset	996 "Print dependency information for all nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	997 \
a61af66fc99e Initial load duke parents: diff changeset	998 develop(bool, PrintExceptionHandlers, false, \
a61af66fc99e Initial load duke parents: diff changeset	999 "Print exception handler tables for all nmethods when generated") \
a61af66fc99e Initial load duke parents: diff changeset	1000 \
7428 2d6c433b1f38 8004741: Missing compiled exception handle table entry for multidimensional array allocation kvn parents: 6985 diff changeset	1001 develop(bool, StressCompiledExceptionHandlers, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1002 "Exercise compiled exception handlers") \
7428 2d6c433b1f38 8004741: Missing compiled exception handle table entry for multidimensional array allocation kvn parents: 6985 diff changeset	1003 \
0 a61af66fc99e Initial load duke parents: diff changeset	1004 develop(bool, InterceptOSException, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1005 "Start debugger when an implicit OS (e.g. NULL) " \
0 a61af66fc99e Initial load duke parents: diff changeset	1006 "exception happens") \
a61af66fc99e Initial load duke parents: diff changeset	1007 \
7595 9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 7467 diff changeset	1008 product(bool, PrintCodeCache, false, \
9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 7467 diff changeset	1009 "Print the code cache memory usage when exiting") \
0 a61af66fc99e Initial load duke parents: diff changeset	1010 \
a61af66fc99e Initial load duke parents: diff changeset	1011 develop(bool, PrintCodeCache2, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1012 "Print detailed usage information on the code cache when exiting")\
7595 9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 7467 diff changeset	1013 \
9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 7467 diff changeset	1014 product(bool, PrintCodeCacheOnCompilation, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1015 "Print the code cache memory usage each time a method is " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1016 "compiled") \
0 a61af66fc99e Initial load duke parents: diff changeset	1017 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	1018 diagnostic(bool, PrintStubCode, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	1019 "Print generated stub code") \
a61af66fc99e Initial load duke parents: diff changeset	1020 \
a61af66fc99e Initial load duke parents: diff changeset	1021 product(bool, StackTraceInThrowable, true, \
a61af66fc99e Initial load duke parents: diff changeset	1022 "Collect backtrace in throwable when exception happens") \
a61af66fc99e Initial load duke parents: diff changeset	1023 \
a61af66fc99e Initial load duke parents: diff changeset	1024 product(bool, OmitStackTraceInFastThrow, true, \
a61af66fc99e Initial load duke parents: diff changeset	1025 "Omit backtraces for some 'hot' exceptions in optimized code") \
a61af66fc99e Initial load duke parents: diff changeset	1026 \
a61af66fc99e Initial load duke parents: diff changeset	1027 product(bool, ProfilerPrintByteCodeStatistics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1028 "Print bytecode statistics when dumping profiler output") \
0 a61af66fc99e Initial load duke parents: diff changeset	1029 \
a61af66fc99e Initial load duke parents: diff changeset	1030 product(bool, ProfilerRecordPC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1031 "Collect ticks for each 16 byte interval of compiled code") \
0 a61af66fc99e Initial load duke parents: diff changeset	1032 \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1033 product(bool, ProfileVM, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1034 "Profile ticks that fall within VM (either in the VM Thread " \
0 a61af66fc99e Initial load duke parents: diff changeset	1035 "or VM code called through stubs)") \
a61af66fc99e Initial load duke parents: diff changeset	1036 \
a61af66fc99e Initial load duke parents: diff changeset	1037 product(bool, ProfileIntervals, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1038 "Print profiles for each interval (see ProfileIntervalsTicks)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1039 \
a61af66fc99e Initial load duke parents: diff changeset	1040 notproduct(bool, ProfilerCheckIntervals, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1041 "Collect and print information on spacing of profiler ticks") \
0 a61af66fc99e Initial load duke parents: diff changeset	1042 \
a61af66fc99e Initial load duke parents: diff changeset	1043 develop(bool, PrintJVMWarnings, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1044 "Print warnings for unimplemented JVM functions") \
0 a61af66fc99e Initial load duke parents: diff changeset	1045 \
1870 c77b5c592eab 6392697: Additional flag needed to supress Hotspot warning messages kamg parents: 1868 diff changeset	1046 product(bool, PrintWarnings, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1047 "Print JVM warnings to output stream") \
1870 c77b5c592eab 6392697: Additional flag needed to supress Hotspot warning messages kamg parents: 1868 diff changeset	1048 \
0 a61af66fc99e Initial load duke parents: diff changeset	1049 notproduct(uintx, WarnOnStalledSpinLock, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1050 "Print warnings for stalled SpinLocks") \
0 a61af66fc99e Initial load duke parents: diff changeset	1051 \
a61af66fc99e Initial load duke parents: diff changeset	1052 product(bool, RegisterFinalizersAtInit, true, \
a61af66fc99e Initial load duke parents: diff changeset	1053 "Register finalizable objects at end of Object.<init> or " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1054 "after allocation") \
0 a61af66fc99e Initial load duke parents: diff changeset	1055 \
a61af66fc99e Initial load duke parents: diff changeset	1056 develop(bool, RegisterReferences, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1057 "Tell whether the VM should register soft/weak/final/phantom " \
0 a61af66fc99e Initial load duke parents: diff changeset	1058 "references") \
a61af66fc99e Initial load duke parents: diff changeset	1059 \
a61af66fc99e Initial load duke parents: diff changeset	1060 develop(bool, IgnoreRewrites, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1061 "Suppress rewrites of bytecodes in the oopmap generator. " \
0 a61af66fc99e Initial load duke parents: diff changeset	1062 "This is unsafe!") \
a61af66fc99e Initial load duke parents: diff changeset	1063 \
a61af66fc99e Initial load duke parents: diff changeset	1064 develop(bool, PrintCodeCacheExtension, false, \
a61af66fc99e Initial load duke parents: diff changeset	1065 "Print extension of code cache") \
a61af66fc99e Initial load duke parents: diff changeset	1066 \
a61af66fc99e Initial load duke parents: diff changeset	1067 develop(bool, UsePrivilegedStack, true, \
a61af66fc99e Initial load duke parents: diff changeset	1068 "Enable the security JVM functions") \
a61af66fc99e Initial load duke parents: diff changeset	1069 \
a61af66fc99e Initial load duke parents: diff changeset	1070 develop(bool, ProtectionDomainVerification, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1071 "Verify protection domain before resolution in system dictionary")\
0 a61af66fc99e Initial load duke parents: diff changeset	1072 \
a61af66fc99e Initial load duke parents: diff changeset	1073 product(bool, ClassUnloading, true, \
a61af66fc99e Initial load duke parents: diff changeset	1074 "Do unloading of classes") \
a61af66fc99e Initial load duke parents: diff changeset	1075 \
a61af66fc99e Initial load duke parents: diff changeset	1076 develop(bool, DisableStartThread, false, \
a61af66fc99e Initial load duke parents: diff changeset	1077 "Disable starting of additional Java threads " \
a61af66fc99e Initial load duke parents: diff changeset	1078 "(for debugging only)") \
a61af66fc99e Initial load duke parents: diff changeset	1079 \
a61af66fc99e Initial load duke parents: diff changeset	1080 develop(bool, MemProfiling, false, \
a61af66fc99e Initial load duke parents: diff changeset	1081 "Write memory usage profiling to log file") \
a61af66fc99e Initial load duke parents: diff changeset	1082 \
a61af66fc99e Initial load duke parents: diff changeset	1083 notproduct(bool, PrintSystemDictionaryAtExit, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1084 "Print the system dictionary at exit") \
0 a61af66fc99e Initial load duke parents: diff changeset	1085 \
4864 b2cd0ee8f778 7114376: Make system dictionary hashtable bucket array size configurable acorn parents: 4854 diff changeset	1086 experimental(intx, PredictedLoadedClassCount, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1087 "Experimental: Tune loaded class cache starting size") \
4864 b2cd0ee8f778 7114376: Make system dictionary hashtable bucket array size configurable acorn parents: 4854 diff changeset	1088 \
0 a61af66fc99e Initial load duke parents: diff changeset	1089 diagnostic(bool, UnsyncloadClass, false, \
514 c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1090 "Unstable: VM calls loadClass unsynchronized. Custom " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1091 "class loader must call VM synchronized for findClass " \
514 c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1092 "and defineClass.") \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1093 \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1094 product(bool, AlwaysLockClassLoader, false, \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1095 "Require the VM to acquire the class loader lock before calling " \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1096 "loadClass() even for class loaders registering " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1097 "as parallel capable") \
514 c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1098 \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1099 product(bool, AllowParallelDefineClass, false, \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1100 "Allow parallel defineClass requests for class loaders " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1101 "registering as parallel capable") \
514 c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1102 \
c81d2ef51ca3 4670071: loadClassInternal is too restrictive. acorn parents: 484 diff changeset	1103 product(bool, MustCallLoadClassInternal, false, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1104 "Call loadClassInternal() rather than loadClass()") \
0 a61af66fc99e Initial load duke parents: diff changeset	1105 \
a61af66fc99e Initial load duke parents: diff changeset	1106 product_pd(bool, DontYieldALot, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1107 "Throw away obvious excess yield calls (for Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1108 \
a61af66fc99e Initial load duke parents: diff changeset	1109 product_pd(bool, ConvertSleepToYield, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1110 "Convert sleep(0) to thread yield " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1111 "(may be off for Solaris to improve GUI)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1112 \
a61af66fc99e Initial load duke parents: diff changeset	1113 product(bool, ConvertYieldToSleep, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1114 "Convert yield to a sleep of MinSleepInterval to simulate Win32 " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1115 "behavior (Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1116 \
a61af66fc99e Initial load duke parents: diff changeset	1117 product(bool, UseBoundThreads, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1118 "Bind user level threads to kernel threads (for Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1119 \
a61af66fc99e Initial load duke parents: diff changeset	1120 develop(bool, UseDetachedThreads, true, \
a61af66fc99e Initial load duke parents: diff changeset	1121 "Use detached threads that are recycled upon termination " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1122 "(for Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1123 \
a61af66fc99e Initial load duke parents: diff changeset	1124 product(bool, UseLWPSynchronization, true, \
a61af66fc99e Initial load duke parents: diff changeset	1125 "Use LWP-based instead of libthread-based synchronization " \
a61af66fc99e Initial load duke parents: diff changeset	1126 "(SPARC only)") \
a61af66fc99e Initial load duke parents: diff changeset	1127 \
370 885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 325 diff changeset	1128 product(ccstr, SyncKnobs, NULL, \
0 a61af66fc99e Initial load duke parents: diff changeset	1129 "(Unstable) Various monitor synchronization tunables") \
a61af66fc99e Initial load duke parents: diff changeset	1130 \
a61af66fc99e Initial load duke parents: diff changeset	1131 product(intx, EmitSync, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1132 "(Unsafe, Unstable) " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1133 "Control emission of inline sync fast-path code") \
0 a61af66fc99e Initial load duke parents: diff changeset	1134 \
1587 b96a3e44582f 6852873: Reduce safepoint cleanup time acorn parents: 1544 diff changeset	1135 product(intx, MonitorBound, 0, "Bound Monitor population") \
b96a3e44582f 6852873: Reduce safepoint cleanup time acorn parents: 1544 diff changeset	1136 \
b96a3e44582f 6852873: Reduce safepoint cleanup time acorn parents: 1544 diff changeset	1137 product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
b96a3e44582f 6852873: Reduce safepoint cleanup time acorn parents: 1544 diff changeset	1138 \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1139 product(intx, SyncFlags, 0, "(Unsafe, Unstable) Experimental Sync flags") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1140 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1141 product(intx, SyncVerbose, 0, "(Unstable)") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1142 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1143 product(intx, ClearFPUAtPark, 0, "(Unsafe, Unstable)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1144 \
7587 4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1145 product(intx, hashCode, 5, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1146 "(Unstable) select hashCode generation algorithm") \
0 a61af66fc99e Initial load duke parents: diff changeset	1147 \
a61af66fc99e Initial load duke parents: diff changeset	1148 product(intx, WorkAroundNPTLTimedWaitHang, 1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1149 "(Unstable, Linux-specific) " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1150 "avoid NPTL-FUTEX hang pthread_cond_timedwait") \
0 a61af66fc99e Initial load duke parents: diff changeset	1151 \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1152 product(bool, FilterSpuriousWakeups, true, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1153 "Prevent spurious or premature wakeups from object.wait " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1154 "(Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1155 \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1156 product(intx, NativeMonitorTimeout, -1, "(Unstable)") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1157 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1158 product(intx, NativeMonitorFlags, 0, "(Unstable)") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1159 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1160 product(intx, NativeMonitorSpinLimit, 20, "(Unstable)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1161 \
a61af66fc99e Initial load duke parents: diff changeset	1162 develop(bool, UsePthreads, false, \
a61af66fc99e Initial load duke parents: diff changeset	1163 "Use pthread-based instead of libthread-based synchronization " \
a61af66fc99e Initial load duke parents: diff changeset	1164 "(SPARC only)") \
a61af66fc99e Initial load duke parents: diff changeset	1165 \
a61af66fc99e Initial load duke parents: diff changeset	1166 product(bool, AdjustConcurrency, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1167 "Call thr_setconcurrency at thread creation time to avoid " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1168 "LWP starvation on MP systems (for Solaris Only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1169 \
a61af66fc99e Initial load duke parents: diff changeset	1170 product(bool, ReduceSignalUsage, false, \
a61af66fc99e Initial load duke parents: diff changeset	1171 "Reduce the use of OS signals in Java and/or the VM") \
a61af66fc99e Initial load duke parents: diff changeset	1172 \
a61af66fc99e Initial load duke parents: diff changeset	1173 develop_pd(bool, ShareVtableStubs, \
a61af66fc99e Initial load duke parents: diff changeset	1174 "Share vtable stubs (smaller code but worse branch prediction") \
a61af66fc99e Initial load duke parents: diff changeset	1175 \
a61af66fc99e Initial load duke parents: diff changeset	1176 develop(bool, LoadLineNumberTables, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1177 "Tell whether the class file parser loads line number tables") \
0 a61af66fc99e Initial load duke parents: diff changeset	1178 \
a61af66fc99e Initial load duke parents: diff changeset	1179 develop(bool, LoadLocalVariableTables, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1180 "Tell whether the class file parser loads local variable tables") \
0 a61af66fc99e Initial load duke parents: diff changeset	1181 \
a61af66fc99e Initial load duke parents: diff changeset	1182 develop(bool, LoadLocalVariableTypeTables, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1183 "Tell whether the class file parser loads local variable type" \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1184 "tables") \
0 a61af66fc99e Initial load duke parents: diff changeset	1185 \
a61af66fc99e Initial load duke parents: diff changeset	1186 product(bool, AllowUserSignalHandlers, false, \
a61af66fc99e Initial load duke parents: diff changeset	1187 "Do not complain if the application installs signal handlers " \
a61af66fc99e Initial load duke parents: diff changeset	1188 "(Solaris & Linux only)") \
a61af66fc99e Initial load duke parents: diff changeset	1189 \
a61af66fc99e Initial load duke parents: diff changeset	1190 product(bool, UseSignalChaining, true, \
a61af66fc99e Initial load duke parents: diff changeset	1191 "Use signal-chaining to invoke signal handlers installed " \
a61af66fc99e Initial load duke parents: diff changeset	1192 "by the application (Solaris & Linux only)") \
a61af66fc99e Initial load duke parents: diff changeset	1193 \
a61af66fc99e Initial load duke parents: diff changeset	1194 product(bool, UseAltSigs, false, \
a61af66fc99e Initial load duke parents: diff changeset	1195 "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1196 "internal signals (Solaris only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1197 \
a61af66fc99e Initial load duke parents: diff changeset	1198 product(bool, AllowJNIEnvProxy, false, \
a61af66fc99e Initial load duke parents: diff changeset	1199 "Allow JNIEnv proxies for jdbx") \
a61af66fc99e Initial load duke parents: diff changeset	1200 \
a61af66fc99e Initial load duke parents: diff changeset	1201 product(bool, JNIDetachReleasesMonitors, true, \
a61af66fc99e Initial load duke parents: diff changeset	1202 "JNI DetachCurrentThread releases monitors owned by thread") \
a61af66fc99e Initial load duke parents: diff changeset	1203 \
a61af66fc99e Initial load duke parents: diff changeset	1204 product(bool, RestoreMXCSROnJNICalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	1205 "Restore MXCSR when returning from JNI calls") \
a61af66fc99e Initial load duke parents: diff changeset	1206 \
a61af66fc99e Initial load duke parents: diff changeset	1207 product(bool, CheckJNICalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	1208 "Verify all arguments to JNI calls") \
a61af66fc99e Initial load duke parents: diff changeset	1209 \
a61af66fc99e Initial load duke parents: diff changeset	1210 product(bool, UseFastJNIAccessors, true, \
a61af66fc99e Initial load duke parents: diff changeset	1211 "Use optimized versions of Get<Primitive>Field") \
a61af66fc99e Initial load duke parents: diff changeset	1212 \
a61af66fc99e Initial load duke parents: diff changeset	1213 product(bool, EagerXrunInit, false, \
a61af66fc99e Initial load duke parents: diff changeset	1214 "Eagerly initialize -Xrun libraries; allows startup profiling, " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1215 "but not all -Xrun libraries may support the state of the VM " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1216 "at this time") \
0 a61af66fc99e Initial load duke parents: diff changeset	1217 \
a61af66fc99e Initial load duke parents: diff changeset	1218 product(bool, PreserveAllAnnotations, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1219 "Preserve RuntimeInvisibleAnnotations as well " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1220 "as RuntimeVisibleAnnotations") \
0 a61af66fc99e Initial load duke parents: diff changeset	1221 \
a61af66fc99e Initial load duke parents: diff changeset	1222 develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
a61af66fc99e Initial load duke parents: diff changeset	1223 "Number of OutOfMemoryErrors preallocated with backtrace") \
a61af66fc99e Initial load duke parents: diff changeset	1224 \
a61af66fc99e Initial load duke parents: diff changeset	1225 product(bool, LazyBootClassLoader, true, \
a61af66fc99e Initial load duke parents: diff changeset	1226 "Enable/disable lazy opening of boot class path entries") \
a61af66fc99e Initial load duke parents: diff changeset	1227 \
405 2649e5276dd7 6532536: Optimize arraycopy stubs for Intel cpus kvn parents: 402 diff changeset	1228 product(bool, UseXMMForArrayCopy, false, \
2649e5276dd7 6532536: Optimize arraycopy stubs for Intel cpus kvn parents: 402 diff changeset	1229 "Use SSE2 MOVQ instruction for Arraycopy") \
2649e5276dd7 6532536: Optimize arraycopy stubs for Intel cpus kvn parents: 402 diff changeset	1230 \
0 a61af66fc99e Initial load duke parents: diff changeset	1231 product(intx, FieldsAllocationStyle, 1, \
1366 b9d85fcdf743 6940733: allocate non static oop fields in super and sub classes together kvn parents: 1365 diff changeset	1232 "0 - type based with oops first, 1 - with oops last, " \
b9d85fcdf743 6940733: allocate non static oop fields in super and sub classes together kvn parents: 1365 diff changeset	1233 "2 - oops in super and sub classes are together") \
0 a61af66fc99e Initial load duke parents: diff changeset	1234 \
a61af66fc99e Initial load duke parents: diff changeset	1235 product(bool, CompactFields, true, \
a61af66fc99e Initial load duke parents: diff changeset	1236 "Allocate nonstatic fields in gaps between previous fields") \
a61af66fc99e Initial load duke parents: diff changeset	1237 \
7587 4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1238 notproduct(bool, PrintFieldLayout, false, \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1239 "Print field layout for each class") \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1240 \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1241 product(intx, ContendedPaddingWidth, 128, \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1242 "How many bytes to pad the fields/classes marked @Contended with")\
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1243 \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1244 product(bool, EnableContended, true, \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1245 "Enable @Contended annotation support") \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1246 \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1247 product(bool, RestrictContended, true, \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1248 "Restrict @Contended to trusted classes") \
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7461 diff changeset	1249 \
0 a61af66fc99e Initial load duke parents: diff changeset	1250 product(bool, UseBiasedLocking, true, \
a61af66fc99e Initial load duke parents: diff changeset	1251 "Enable biased locking in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	1252 \
a61af66fc99e Initial load duke parents: diff changeset	1253 product(intx, BiasedLockingStartupDelay, 4000, \
a61af66fc99e Initial load duke parents: diff changeset	1254 "Number of milliseconds to wait before enabling biased locking") \
a61af66fc99e Initial load duke parents: diff changeset	1255 \
a61af66fc99e Initial load duke parents: diff changeset	1256 diagnostic(bool, PrintBiasedLockingStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	1257 "Print statistics of biased locking in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	1258 \
a61af66fc99e Initial load duke parents: diff changeset	1259 product(intx, BiasedLockingBulkRebiasThreshold, 20, \
a61af66fc99e Initial load duke parents: diff changeset	1260 "Threshold of number of revocations per type to try to " \
a61af66fc99e Initial load duke parents: diff changeset	1261 "rebias all objects in the heap of that type") \
a61af66fc99e Initial load duke parents: diff changeset	1262 \
a61af66fc99e Initial load duke parents: diff changeset	1263 product(intx, BiasedLockingBulkRevokeThreshold, 40, \
a61af66fc99e Initial load duke parents: diff changeset	1264 "Threshold of number of revocations per type to permanently " \
a61af66fc99e Initial load duke parents: diff changeset	1265 "revoke biases of all objects in the heap of that type") \
a61af66fc99e Initial load duke parents: diff changeset	1266 \
a61af66fc99e Initial load duke parents: diff changeset	1267 product(intx, BiasedLockingDecayTime, 25000, \
a61af66fc99e Initial load duke parents: diff changeset	1268 "Decay time (in milliseconds) to re-enable bulk rebiasing of a " \
a61af66fc99e Initial load duke parents: diff changeset	1269 "type after previous bulk rebias") \
a61af66fc99e Initial load duke parents: diff changeset	1270 \
a61af66fc99e Initial load duke parents: diff changeset	1271 /* tracing */ \
a61af66fc99e Initial load duke parents: diff changeset	1272 \
a61af66fc99e Initial load duke parents: diff changeset	1273 notproduct(bool, TraceRuntimeCalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	1274 "Trace run-time calls") \
a61af66fc99e Initial load duke parents: diff changeset	1275 \
a61af66fc99e Initial load duke parents: diff changeset	1276 develop(bool, TraceJNICalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	1277 "Trace JNI calls") \
a61af66fc99e Initial load duke parents: diff changeset	1278 \
a61af66fc99e Initial load duke parents: diff changeset	1279 notproduct(bool, TraceJVMCalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	1280 "Trace JVM calls") \
a61af66fc99e Initial load duke parents: diff changeset	1281 \
370 885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 325 diff changeset	1282 product(ccstr, TraceJVMTI, NULL, \
0 a61af66fc99e Initial load duke parents: diff changeset	1283 "Trace flags for JVMTI functions and events") \
a61af66fc99e Initial load duke parents: diff changeset	1284 \
a61af66fc99e Initial load duke parents: diff changeset	1285 /* This option can change an EMCP method into an obsolete method. */ \
a61af66fc99e Initial load duke parents: diff changeset	1286 /* This can affect tests that except specific methods to be EMCP. */ \
a61af66fc99e Initial load duke parents: diff changeset	1287 /* This option should be used with caution. */ \
a61af66fc99e Initial load duke parents: diff changeset	1288 product(bool, StressLdcRewrite, false, \
a61af66fc99e Initial load duke parents: diff changeset	1289 "Force ldc -> ldc_w rewrite during RedefineClasses") \
a61af66fc99e Initial load duke parents: diff changeset	1290 \
a61af66fc99e Initial load duke parents: diff changeset	1291 product(intx, TraceRedefineClasses, 0, \
a61af66fc99e Initial load duke parents: diff changeset	1292 "Trace level for JVMTI RedefineClasses") \
a61af66fc99e Initial load duke parents: diff changeset	1293 \
1574 1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1571 diff changeset	1294 develop(bool, StressMethodComparator, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1295 "Run the MethodComparator on all loaded methods") \
1574 1eb493f33423 6957080: MethodComparator needs stress testing jrose parents: 1571 diff changeset	1296 \
0 a61af66fc99e Initial load duke parents: diff changeset	1297 /* change to false by default sometime after Mustang */ \
a61af66fc99e Initial load duke parents: diff changeset	1298 product(bool, VerifyMergedCPBytecodes, true, \
a61af66fc99e Initial load duke parents: diff changeset	1299 "Verify bytecodes after RedefineClasses constant pool merging") \
a61af66fc99e Initial load duke parents: diff changeset	1300 \
a61af66fc99e Initial load duke parents: diff changeset	1301 develop(bool, TraceJNIHandleAllocation, false, \
a61af66fc99e Initial load duke parents: diff changeset	1302 "Trace allocation/deallocation of JNI handle blocks") \
a61af66fc99e Initial load duke parents: diff changeset	1303 \
a61af66fc99e Initial load duke parents: diff changeset	1304 develop(bool, TraceThreadEvents, false, \
a61af66fc99e Initial load duke parents: diff changeset	1305 "Trace all thread events") \
a61af66fc99e Initial load duke parents: diff changeset	1306 \
a61af66fc99e Initial load duke parents: diff changeset	1307 develop(bool, TraceBytecodes, false, \
a61af66fc99e Initial load duke parents: diff changeset	1308 "Trace bytecode execution") \
a61af66fc99e Initial load duke parents: diff changeset	1309 \
a61af66fc99e Initial load duke parents: diff changeset	1310 develop(bool, TraceClassInitialization, false, \
a61af66fc99e Initial load duke parents: diff changeset	1311 "Trace class initialization") \
a61af66fc99e Initial load duke parents: diff changeset	1312 \
a61af66fc99e Initial load duke parents: diff changeset	1313 develop(bool, TraceExceptions, false, \
a61af66fc99e Initial load duke parents: diff changeset	1314 "Trace exceptions") \
a61af66fc99e Initial load duke parents: diff changeset	1315 \
a61af66fc99e Initial load duke parents: diff changeset	1316 develop(bool, TraceICs, false, \
a61af66fc99e Initial load duke parents: diff changeset	1317 "Trace inline cache changes") \
a61af66fc99e Initial load duke parents: diff changeset	1318 \
a61af66fc99e Initial load duke parents: diff changeset	1319 notproduct(bool, TraceInvocationCounterOverflow, false, \
a61af66fc99e Initial load duke parents: diff changeset	1320 "Trace method invocation counter overflow") \
a61af66fc99e Initial load duke parents: diff changeset	1321 \
a61af66fc99e Initial load duke parents: diff changeset	1322 develop(bool, TraceInlineCacheClearing, false, \
a61af66fc99e Initial load duke parents: diff changeset	1323 "Trace clearing of inline caches in nmethods") \
a61af66fc99e Initial load duke parents: diff changeset	1324 \
a61af66fc99e Initial load duke parents: diff changeset	1325 develop(bool, TraceDependencies, false, \
a61af66fc99e Initial load duke parents: diff changeset	1326 "Trace dependencies") \
a61af66fc99e Initial load duke parents: diff changeset	1327 \
a61af66fc99e Initial load duke parents: diff changeset	1328 develop(bool, VerifyDependencies, trueInDebug, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1329 "Exercise and verify the compilation dependency mechanism") \
0 a61af66fc99e Initial load duke parents: diff changeset	1330 \
a61af66fc99e Initial load duke parents: diff changeset	1331 develop(bool, TraceNewOopMapGeneration, false, \
a61af66fc99e Initial load duke parents: diff changeset	1332 "Trace OopMapGeneration") \
a61af66fc99e Initial load duke parents: diff changeset	1333 \
a61af66fc99e Initial load duke parents: diff changeset	1334 develop(bool, TraceNewOopMapGenerationDetailed, false, \
a61af66fc99e Initial load duke parents: diff changeset	1335 "Trace OopMapGeneration: print detailed cell states") \
a61af66fc99e Initial load duke parents: diff changeset	1336 \
a61af66fc99e Initial load duke parents: diff changeset	1337 develop(bool, TimeOopMap, false, \
a61af66fc99e Initial load duke parents: diff changeset	1338 "Time calls to GenerateOopMap::compute_map() in sum") \
a61af66fc99e Initial load duke parents: diff changeset	1339 \
a61af66fc99e Initial load duke parents: diff changeset	1340 develop(bool, TimeOopMap2, false, \
a61af66fc99e Initial load duke parents: diff changeset	1341 "Time calls to GenerateOopMap::compute_map() individually") \
a61af66fc99e Initial load duke parents: diff changeset	1342 \
a61af66fc99e Initial load duke parents: diff changeset	1343 develop(bool, TraceMonitorMismatch, false, \
a61af66fc99e Initial load duke parents: diff changeset	1344 "Trace monitor matching failures during OopMapGeneration") \
a61af66fc99e Initial load duke parents: diff changeset	1345 \
a61af66fc99e Initial load duke parents: diff changeset	1346 develop(bool, TraceOopMapRewrites, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1347 "Trace rewriting of method oops during oop map generation") \
0 a61af66fc99e Initial load duke parents: diff changeset	1348 \
a61af66fc99e Initial load duke parents: diff changeset	1349 develop(bool, TraceSafepoint, false, \
a61af66fc99e Initial load duke parents: diff changeset	1350 "Trace safepoint operations") \
a61af66fc99e Initial load duke parents: diff changeset	1351 \
a61af66fc99e Initial load duke parents: diff changeset	1352 develop(bool, TraceICBuffer, false, \
a61af66fc99e Initial load duke parents: diff changeset	1353 "Trace usage of IC buffer") \
a61af66fc99e Initial load duke parents: diff changeset	1354 \
a61af66fc99e Initial load duke parents: diff changeset	1355 develop(bool, TraceCompiledIC, false, \
a61af66fc99e Initial load duke parents: diff changeset	1356 "Trace changes of compiled IC") \
a61af66fc99e Initial load duke parents: diff changeset	1357 \
a61af66fc99e Initial load duke parents: diff changeset	1358 notproduct(bool, TraceZapDeadLocals, false, \
a61af66fc99e Initial load duke parents: diff changeset	1359 "Trace zapping dead locals") \
a61af66fc99e Initial load duke parents: diff changeset	1360 \
a61af66fc99e Initial load duke parents: diff changeset	1361 develop(bool, TraceStartupTime, false, \
a61af66fc99e Initial load duke parents: diff changeset	1362 "Trace setup time") \
a61af66fc99e Initial load duke parents: diff changeset	1363 \
a61af66fc99e Initial load duke parents: diff changeset	1364 develop(bool, TraceProtectionDomainVerification, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1365 "Trace protection domain verification") \
0 a61af66fc99e Initial load duke parents: diff changeset	1366 \
a61af66fc99e Initial load duke parents: diff changeset	1367 develop(bool, TraceClearedExceptions, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1368 "Print when an exception is forcibly cleared") \
0 a61af66fc99e Initial load duke parents: diff changeset	1369 \
a61af66fc99e Initial load duke parents: diff changeset	1370 product(bool, TraceClassResolution, false, \
a61af66fc99e Initial load duke parents: diff changeset	1371 "Trace all constant pool resolutions (for debugging)") \
a61af66fc99e Initial load duke parents: diff changeset	1372 \
a61af66fc99e Initial load duke parents: diff changeset	1373 product(bool, TraceBiasedLocking, false, \
a61af66fc99e Initial load duke parents: diff changeset	1374 "Trace biased locking in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	1375 \
a61af66fc99e Initial load duke parents: diff changeset	1376 product(bool, TraceMonitorInflation, false, \
a61af66fc99e Initial load duke parents: diff changeset	1377 "Trace monitor inflation in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	1378 \
a61af66fc99e Initial load duke parents: diff changeset	1379 /* gc */ \
a61af66fc99e Initial load duke parents: diff changeset	1380 \
a61af66fc99e Initial load duke parents: diff changeset	1381 product(bool, UseSerialGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1382 "Use the Serial garbage collector") \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	1383 \
1193 c81fa70144aa 6919980: G1: remove +UseG1GC from under experimental options (second attempt) tonyp parents: 1179 diff changeset	1384 product(bool, UseG1GC, false, \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	1385 "Use the Garbage-First garbage collector") \
0 a61af66fc99e Initial load duke parents: diff changeset	1386 \
a61af66fc99e Initial load duke parents: diff changeset	1387 product(bool, UseParallelGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	1388 "Use the Parallel Scavenge garbage collector") \
a61af66fc99e Initial load duke parents: diff changeset	1389 \
a61af66fc99e Initial load duke parents: diff changeset	1390 product(bool, UseParallelOldGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	1391 "Use the Parallel Old garbage collector") \
a61af66fc99e Initial load duke parents: diff changeset	1392 \
a61af66fc99e Initial load duke parents: diff changeset	1393 product(uintx, HeapMaximumCompactionInterval, 20, \
a61af66fc99e Initial load duke parents: diff changeset	1394 "How often should we maximally compact the heap (not allowing " \
a61af66fc99e Initial load duke parents: diff changeset	1395 "any dead space)") \
a61af66fc99e Initial load duke parents: diff changeset	1396 \
a61af66fc99e Initial load duke parents: diff changeset	1397 product(uintx, HeapFirstMaximumCompactionCount, 3, \
a61af66fc99e Initial load duke parents: diff changeset	1398 "The collection count for the first maximum compaction") \
a61af66fc99e Initial load duke parents: diff changeset	1399 \
a61af66fc99e Initial load duke parents: diff changeset	1400 product(bool, UseMaximumCompactionOnSystemGC, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1401 "Use maximum compaction in the Parallel Old garbage collector " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1402 "for a system GC") \
0 a61af66fc99e Initial load duke parents: diff changeset	1403 \
a61af66fc99e Initial load duke parents: diff changeset	1404 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1405 "The mean used by the parallel compact dead wood " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1406 "limiter (a number between 0-100)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1407 \
a61af66fc99e Initial load duke parents: diff changeset	1408 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1409 "The standard deviation used by the parallel compact dead wood " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1410 "limiter (a number between 0-100)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1411 \
a61af66fc99e Initial load duke parents: diff changeset	1412 product(uintx, ParallelGCThreads, 0, \
a61af66fc99e Initial load duke parents: diff changeset	1413 "Number of parallel threads parallel gc will use") \
a61af66fc99e Initial load duke parents: diff changeset	1414 \
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1415 product(bool, UseDynamicNumberOfGCThreads, false, \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1416 "Dynamically choose the number of parallel threads " \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1417 "parallel gc will use") \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1418 \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1419 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1420 "Force dynamic selection of the number of " \
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1421 "parallel threads parallel gc will use to aid debugging") \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1422 \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1423 product(uintx, HeapSizePerGCThread, ScaleForWordSize(64*M), \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1424 "Size of heap (bytes) per GC thread used in calculating the " \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1425 "number of GC threads") \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1426 \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1427 product(bool, TraceDynamicGCThreads, false, \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1428 "Trace the dynamic GC thread usage") \
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 4067 diff changeset	1429 \
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 481 diff changeset	1430 develop(bool, ParallelOldGCSplitALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1431 "Provoke splitting (copying data from a young gen space to " \
483 0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 481 diff changeset	1432 "multiple destination spaces)") \
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 481 diff changeset	1433 \
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 481 diff changeset	1434 develop(uintx, ParallelOldGCSplitInterval, 3, \
0f773163217d 6765954: par compact - stress mode for splitting young gen spaces jcoomes parents: 481 diff changeset	1435 "How often to provoke splitting a young gen space") \
0 a61af66fc99e Initial load duke parents: diff changeset	1436 \
1284 5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1437 product(uintx, ConcGCThreads, 0, \
5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1438 "Number of threads concurrent gc will use") \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	1439 \
0 a61af66fc99e Initial load duke parents: diff changeset	1440 product(uintx, YoungPLABSize, 4096, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1441 "Size of young gen promotion LAB's (in HeapWords)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1442 \
a61af66fc99e Initial load duke parents: diff changeset	1443 product(uintx, OldPLABSize, 1024, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1444 "Size of old gen promotion LAB's (in HeapWords)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1445 \
a61af66fc99e Initial load duke parents: diff changeset	1446 product(uintx, GCTaskTimeStampEntries, 200, \
a61af66fc99e Initial load duke parents: diff changeset	1447 "Number of time stamp entries per gc worker thread") \
a61af66fc99e Initial load duke parents: diff changeset	1448 \
a61af66fc99e Initial load duke parents: diff changeset	1449 product(bool, AlwaysTenure, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1450 "Always tenure objects in eden (ParallelGC only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1451 \
a61af66fc99e Initial load duke parents: diff changeset	1452 product(bool, NeverTenure, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1453 "Never tenure objects in eden, may tenure on overflow " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1454 "(ParallelGC only)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1455 \
a61af66fc99e Initial load duke parents: diff changeset	1456 product(bool, ScavengeBeforeFullGC, true, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1457 "Scavenge youngest generation before each full GC, " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1458 "used with UseParallelGC") \
0 a61af66fc99e Initial load duke parents: diff changeset	1459 \
a61af66fc99e Initial load duke parents: diff changeset	1460 develop(bool, ScavengeWithObjectsInToSpace, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1461 "Allow scavenges to occur when to-space contains objects") \
0 a61af66fc99e Initial load duke parents: diff changeset	1462 \
a61af66fc99e Initial load duke parents: diff changeset	1463 product(bool, UseConcMarkSweepGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	1464 "Use Concurrent Mark-Sweep GC in the old generation") \
a61af66fc99e Initial load duke parents: diff changeset	1465 \
a61af66fc99e Initial load duke parents: diff changeset	1466 product(bool, ExplicitGCInvokesConcurrent, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1467 "A System.gc() request invokes a concurrent collection; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1468 "(effective only when UseConcMarkSweepGC)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1469 \
a61af66fc99e Initial load duke parents: diff changeset	1470 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1471 "A System.gc() request invokes a concurrent collection and " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1472 "also unloads classes during such a concurrent gc cycle " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1473 "(effective only when UseConcMarkSweepGC)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1474 \
1520 bb843ebc7c55 6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker ysr parents: 1518 diff changeset	1475 product(bool, GCLockerInvokesConcurrent, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1476 "The exit of a JNI critical section necessitating a scavenge, " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1477 "also kicks off a background concurrent collection") \
1520 bb843ebc7c55 6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker ysr parents: 1518 diff changeset	1478 \
1991 016a3628c885 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen tonyp parents: 1972 diff changeset	1479 product(uintx, GCLockerEdenExpansionPercent, 5, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1480 "How much the GC can expand the eden by while the GC locker " \
1991 016a3628c885 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen tonyp parents: 1972 diff changeset	1481 "is active (as a percentage)") \
016a3628c885 6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen tonyp parents: 1972 diff changeset	1482 \
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8706 diff changeset	1483 diagnostic(intx, GCLockerRetryAllocationCount, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1484 "Number of times to retry allocations when " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1485 "blocked by the GC locker") \
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8706 diff changeset	1486 \
0 a61af66fc99e Initial load duke parents: diff changeset	1487 develop(bool, UseCMSAdaptiveFreeLists, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1488 "Use adaptive free lists in the CMS generation") \
0 a61af66fc99e Initial load duke parents: diff changeset	1489 \
a61af66fc99e Initial load duke parents: diff changeset	1490 develop(bool, UseAsyncConcMarkSweepGC, true, \
a61af66fc99e Initial load duke parents: diff changeset	1491 "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
a61af66fc99e Initial load duke parents: diff changeset	1492 \
a61af66fc99e Initial load duke parents: diff changeset	1493 develop(bool, RotateCMSCollectionTypes, false, \
a61af66fc99e Initial load duke parents: diff changeset	1494 "Rotate the CMS collections among concurrent and STW") \
a61af66fc99e Initial load duke parents: diff changeset	1495 \
a61af66fc99e Initial load duke parents: diff changeset	1496 product(bool, UseCMSBestFit, true, \
a61af66fc99e Initial load duke parents: diff changeset	1497 "Use CMS best fit allocation strategy") \
a61af66fc99e Initial load duke parents: diff changeset	1498 \
a61af66fc99e Initial load duke parents: diff changeset	1499 product(bool, UseCMSCollectionPassing, true, \
a61af66fc99e Initial load duke parents: diff changeset	1500 "Use passing of collection from background to foreground") \
a61af66fc99e Initial load duke parents: diff changeset	1501 \
a61af66fc99e Initial load duke parents: diff changeset	1502 product(bool, UseParNewGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1503 "Use parallel threads in the new generation") \
0 a61af66fc99e Initial load duke parents: diff changeset	1504 \
a61af66fc99e Initial load duke parents: diff changeset	1505 product(bool, ParallelGCVerbose, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1506 "Verbose output for parallel gc") \
0 a61af66fc99e Initial load duke parents: diff changeset	1507 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1508 product(uintx, ParallelGCBufferWastePct, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1509 "Wasted fraction of parallel allocation buffer") \
0 a61af66fc99e Initial load duke parents: diff changeset	1510 \
3357 fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1511 diagnostic(bool, ParallelGCRetainPLAB, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1512 "Retain parallel allocation buffers across scavenges; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1513 "it is disabled because this currently conflicts with " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1514 "parallel card scanning under certain conditions.") \
0 a61af66fc99e Initial load duke parents: diff changeset	1515 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1516 product(uintx, TargetPLABWastePct, 10, \
12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1517 "Target wasted space in last buffer as percent of overall " \
12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1518 "allocation") \
0 a61af66fc99e Initial load duke parents: diff changeset	1519 \
a61af66fc99e Initial load duke parents: diff changeset	1520 product(uintx, PLABWeight, 75, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1521 "Percentage (0-100) used to weigh the current sample when " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1522 "computing exponentially decaying average for ResizePLAB") \
0 a61af66fc99e Initial load duke parents: diff changeset	1523 \
a61af66fc99e Initial load duke parents: diff changeset	1524 product(bool, ResizePLAB, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1525 "Dynamically resize (survivor space) promotion LAB's") \
0 a61af66fc99e Initial load duke parents: diff changeset	1526 \
a61af66fc99e Initial load duke parents: diff changeset	1527 product(bool, PrintPLAB, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1528 "Print (survivor space) promotion LAB's sizing decisions") \
0 a61af66fc99e Initial load duke parents: diff changeset	1529 \
a61af66fc99e Initial load duke parents: diff changeset	1530 product(intx, ParGCArrayScanChunk, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1531 "Scan a subset of object array and push remainder, if array is " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1532 "bigger than this") \
0 a61af66fc99e Initial load duke parents: diff changeset	1533 \
695 becb17ad5e51 6824570: ParNew: Fix memory leak introduced in 6819891 ysr parents: 679 diff changeset	1534 product(bool, ParGCUseLocalOverflow, false, \
becb17ad5e51 6824570: ParNew: Fix memory leak introduced in 6819891 ysr parents: 679 diff changeset	1535 "Instead of a global overflow list, use local overflow stacks") \
becb17ad5e51 6824570: ParNew: Fix memory leak introduced in 6819891 ysr parents: 679 diff changeset	1536 \
679 cea947c8a988 6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops ysr parents: 647 diff changeset	1537 product(bool, ParGCTrimOverflow, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1538 "Eagerly trim the local overflow lists " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1539 "(when ParGCUseLocalOverflow)") \
679 cea947c8a988 6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops ysr parents: 647 diff changeset	1540 \
534 5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1541 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1542 "Simulate work queue overflow in ParNew") \
534 5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1543 \
5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1544 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1545 "An `interval' counter that determines how frequently " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1546 "we simulate overflow; a smaller number increases frequency") \
534 5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1547 \
5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1548 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
0 a61af66fc99e Initial load duke parents: diff changeset	1549 "The desired number of objects to claim from the overflow list") \
a61af66fc99e Initial load duke parents: diff changeset	1550 \
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4125 diff changeset	1551 diagnostic(uintx, ParGCStridesPerThread, 2, \
3357 fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1552 "The number of strides per worker thread that we divide up the " \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1553 "card table scanning work into") \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1554 \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1555 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1556 "The number of cards in each chunk of the parallel chunks used " \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1557 "during card table scanning") \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1558 \
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3325 diff changeset	1559 product(uintx, CMSParPromoteBlocksToClaim, 16, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1560 "Number of blocks to attempt to claim when refilling CMS LAB's " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1561 "for parallel GC") \
0 a61af66fc99e Initial load duke parents: diff changeset	1562 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1563 product(uintx, OldPLABWeight, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1564 "Percentage (0-100) used to weight the current sample when " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1565 "computing exponentially decaying average for resizing " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1566 "CMSParPromoteBlocksToClaim") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1567 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1568 product(bool, ResizeOldPLAB, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1569 "Dynamically resize (old gen) promotion LAB's") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1570 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1571 product(bool, PrintOldPLAB, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1572 "Print (old gen) promotion LAB's sizing decisions") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1573 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1574 product(uintx, CMSOldPLABMin, 16, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1575 "Minimum size of CMS gen promotion LAB caches per worker " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1576 "per block size") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1577 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1578 product(uintx, CMSOldPLABMax, 1024, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1579 "Maximum size of CMS gen promotion LAB caches per worker " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1580 "per block size") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1581 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1582 product(uintx, CMSOldPLABNumRefills, 4, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1583 "Nominal number of refills of CMS gen promotion LAB cache " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1584 "per worker per block size") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1585 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1586 product(bool, CMSOldPLABResizeQuicker, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1587 "React on-the-fly during a scavenge to a sudden " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1588 "change in block demand rate") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1589 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1590 product(uintx, CMSOldPLABToleranceFactor, 4, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1591 "The tolerance of the phase-change detector for on-the-fly " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1592 "PLAB resizing during a scavenge") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1593 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1594 product(uintx, CMSOldPLABReactivityFactor, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1595 "The gain in the feedback loop for on-the-fly PLAB resizing " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1596 "during a scavenge") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1597 \
0 a61af66fc99e Initial load duke parents: diff changeset	1598 product(bool, AlwaysPreTouch, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1599 "Force all freshly committed pages to be pre-touched") \
0 a61af66fc99e Initial load duke parents: diff changeset	1600 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1601 product_pd(uintx, CMSYoungGenPerWorker, \
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 2362 diff changeset	1602 "The maximum size of young gen chosen by default per GC worker " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1603 "thread available") \
0 a61af66fc99e Initial load duke parents: diff changeset	1604 \
a61af66fc99e Initial load duke parents: diff changeset	1605 product(bool, CMSIncrementalMode, false, \
a61af66fc99e Initial load duke parents: diff changeset	1606 "Whether CMS GC should operate in \"incremental\" mode") \
a61af66fc99e Initial load duke parents: diff changeset	1607 \
a61af66fc99e Initial load duke parents: diff changeset	1608 product(uintx, CMSIncrementalDutyCycle, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1609 "Percentage (0-100) of CMS incremental mode duty cycle. If " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1610 "CMSIncrementalPacing is enabled, then this is just the initial " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1611 "value.") \
0 a61af66fc99e Initial load duke parents: diff changeset	1612 \
a61af66fc99e Initial load duke parents: diff changeset	1613 product(bool, CMSIncrementalPacing, true, \
a61af66fc99e Initial load duke parents: diff changeset	1614 "Whether the CMS incremental mode duty cycle should be " \
a61af66fc99e Initial load duke parents: diff changeset	1615 "automatically adjusted") \
a61af66fc99e Initial load duke parents: diff changeset	1616 \
a61af66fc99e Initial load duke parents: diff changeset	1617 product(uintx, CMSIncrementalDutyCycleMin, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1618 "Minimum percentage (0-100) of the CMS incremental duty cycle " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1619 "used when CMSIncrementalPacing is enabled") \
0 a61af66fc99e Initial load duke parents: diff changeset	1620 \
a61af66fc99e Initial load duke parents: diff changeset	1621 product(uintx, CMSIncrementalSafetyFactor, 10, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1622 "Percentage (0-100) used to add conservatism when computing the " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1623 "duty cycle") \
0 a61af66fc99e Initial load duke parents: diff changeset	1624 \
a61af66fc99e Initial load duke parents: diff changeset	1625 product(uintx, CMSIncrementalOffset, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1626 "Percentage (0-100) by which the CMS incremental mode duty cycle "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1627 "is shifted to the right within the period between young GCs") \
0 a61af66fc99e Initial load duke parents: diff changeset	1628 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1629 product(uintx, CMSExpAvgFactor, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1630 "Percentage (0-100) used to weigh the current sample when " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1631 "computing exponential averages for CMS statistics") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1632 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1633 product(uintx, CMS_FLSWeight, 75, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1634 "Percentage (0-100) used to weigh the current sample when " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1635 "computing exponentially decaying averages for CMS FLS " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1636 "statistics") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1637 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1638 product(uintx, CMS_FLSPadding, 1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1639 "The multiple of deviation from mean to use for buffering " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1640 "against volatility in free list demand") \
0 a61af66fc99e Initial load duke parents: diff changeset	1641 \
a61af66fc99e Initial load duke parents: diff changeset	1642 product(uintx, FLSCoalescePolicy, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1643 "CMS: aggressiveness level for coalescing, increasing " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1644 "from 0 to 4") \
0 a61af66fc99e Initial load duke parents: diff changeset	1645 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1646 product(bool, FLSAlwaysCoalesceLarge, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1647 "CMS: larger free blocks are always available for coalescing") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1648 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1649 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1650 "CMS: the smaller the percentage the greater the coalescing " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1651 "force") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1652 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1653 product(double, CMSSmallCoalSurplusPercent, 1.05, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1654 "CMS: the factor by which to inflate estimated demand of small " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1655 "block sizes to prevent coalescing with an adjoining block") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1656 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1657 product(double, CMSLargeCoalSurplusPercent, 0.95, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1658 "CMS: the factor by which to inflate estimated demand of large " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1659 "block sizes to prevent coalescing with an adjoining block") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1660 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1661 product(double, CMSSmallSplitSurplusPercent, 1.10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1662 "CMS: the factor by which to inflate estimated demand of small " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1663 "block sizes to prevent splitting to supply demand for smaller " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1664 "blocks") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1665 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1666 product(double, CMSLargeSplitSurplusPercent, 1.00, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1667 "CMS: the factor by which to inflate estimated demand of large " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1668 "block sizes to prevent splitting to supply demand for smaller " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1669 "blocks") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1670 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1671 product(bool, CMSExtrapolateSweep, false, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1672 "CMS: cushion for block demand during sweep") \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1673 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1674 product(uintx, CMS_SweepWeight, 75, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1675 "Percentage (0-100) used to weight the current sample when " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1676 "computing exponentially decaying average for inter-sweep " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1677 "duration") \
0 a61af66fc99e Initial load duke parents: diff changeset	1678 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1679 product(uintx, CMS_SweepPadding, 1, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1680 "The multiple of deviation from mean to use for buffering " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1681 "against volatility in inter-sweep duration") \
0 a61af66fc99e Initial load duke parents: diff changeset	1682 \
a61af66fc99e Initial load duke parents: diff changeset	1683 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
a61af66fc99e Initial load duke parents: diff changeset	1684 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1685 "duration exceeds this threshold in milliseconds") \
0 a61af66fc99e Initial load duke parents: diff changeset	1686 \
a61af66fc99e Initial load duke parents: diff changeset	1687 develop(bool, CMSTraceIncrementalMode, false, \
a61af66fc99e Initial load duke parents: diff changeset	1688 "Trace CMS incremental mode") \
a61af66fc99e Initial load duke parents: diff changeset	1689 \
a61af66fc99e Initial load duke parents: diff changeset	1690 develop(bool, CMSTraceIncrementalPacing, false, \
a61af66fc99e Initial load duke parents: diff changeset	1691 "Trace CMS incremental mode pacing computation") \
a61af66fc99e Initial load duke parents: diff changeset	1692 \
a61af66fc99e Initial load duke parents: diff changeset	1693 develop(bool, CMSTraceThreadState, false, \
a61af66fc99e Initial load duke parents: diff changeset	1694 "Trace the CMS thread state (enable the trace_state() method)") \
a61af66fc99e Initial load duke parents: diff changeset	1695 \
7454 6e9174173e00 8000325: Change default for CMSClassUnloadingEnabled to true jmasa parents: 7448 diff changeset	1696 product(bool, CMSClassUnloadingEnabled, true, \
0 a61af66fc99e Initial load duke parents: diff changeset	1697 "Whether class unloading enabled when using CMS GC") \
a61af66fc99e Initial load duke parents: diff changeset	1698 \
94 0834225a7916 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction ysr parents: 15 diff changeset	1699 product(uintx, CMSClassUnloadingMaxInterval, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1700 "When CMS class unloading is enabled, the maximum CMS cycle " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1701 "count for which classes may not be unloaded") \
94 0834225a7916 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction ysr parents: 15 diff changeset	1702 \
0 a61af66fc99e Initial load duke parents: diff changeset	1703 product(bool, CMSCompactWhenClearAllSoftRefs, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1704 "Compact when asked to collect CMS gen with " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1705 "clear_all_soft_refs()") \
0 a61af66fc99e Initial load duke parents: diff changeset	1706 \
a61af66fc99e Initial load duke parents: diff changeset	1707 product(bool, UseCMSCompactAtFullCollection, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1708 "Use Mark-Sweep-Compact algorithm at full collections") \
0 a61af66fc99e Initial load duke parents: diff changeset	1709 \
a61af66fc99e Initial load duke parents: diff changeset	1710 product(uintx, CMSFullGCsBeforeCompaction, 0, \
a61af66fc99e Initial load duke parents: diff changeset	1711 "Number of CMS full collection done before compaction if > 0") \
a61af66fc99e Initial load duke parents: diff changeset	1712 \
a61af66fc99e Initial load duke parents: diff changeset	1713 develop(intx, CMSDictionaryChoice, 0, \
a61af66fc99e Initial load duke parents: diff changeset	1714 "Use BinaryTreeDictionary as default in the CMS generation") \
a61af66fc99e Initial load duke parents: diff changeset	1715 \
a61af66fc99e Initial load duke parents: diff changeset	1716 product(uintx, CMSIndexedFreeListReplenish, 4, \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	1717 "Replenish an indexed free list with this number of chunks") \
0 a61af66fc99e Initial load duke parents: diff changeset	1718 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1719 product(bool, CMSReplenishIntermediate, true, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1720 "Replenish all intermediate free-list caches") \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1721 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1722 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1777 179464550c7d 6983930: CMS: Various small cleanups ca September 2010 ysr parents: 1749 diff changeset	1723 "When satisfying batched demand, split blocks from the " \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1724 "IndexedFreeList whose size is a multiple of requested size") \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1725 \
0 a61af66fc99e Initial load duke parents: diff changeset	1726 product(bool, CMSLoopWarn, false, \
a61af66fc99e Initial load duke parents: diff changeset	1727 "Warn in case of excessive CMS looping") \
a61af66fc99e Initial load duke parents: diff changeset	1728 \
a61af66fc99e Initial load duke parents: diff changeset	1729 develop(bool, CMSOverflowEarlyRestoration, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1730 "Restore preserved marks early") \
0 a61af66fc99e Initial load duke parents: diff changeset	1731 \
1284 5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1732 product(uintx, MarkStackSize, NOT_LP64(32K) LP64_ONLY(4M), \
5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1733 "Size of marking stack") \
5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1734 \
5f1f51edaff6 6928081: G1: rename parameters common with CMS jmasa parents: 1283 diff changeset	1735 product(uintx, MarkStackSizeMax, NOT_LP64(4M) LP64_ONLY(512M), \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1736 "Maximum size of marking stack") \
0 a61af66fc99e Initial load duke parents: diff changeset	1737 \
a61af66fc99e Initial load duke parents: diff changeset	1738 notproduct(bool, CMSMarkStackOverflowALot, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1739 "Simulate frequent marking stack / work queue overflow") \
0 a61af66fc99e Initial load duke parents: diff changeset	1740 \
534 5cfd8d19e546 6786503: Overflow list performance can be improved ysr parents: 514 diff changeset	1741 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1742 "An \"interval\" counter that determines how frequently " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1743 "to simulate overflow; a smaller number increases frequency") \
0 a61af66fc99e Initial load duke parents: diff changeset	1744 \
a61af66fc99e Initial load duke parents: diff changeset	1745 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1746 "(Temporary, subject to experimentation) " \
0 a61af66fc99e Initial load duke parents: diff changeset	1747 "Maximum number of abortable preclean iterations, if > 0") \
a61af66fc99e Initial load duke parents: diff changeset	1748 \
a61af66fc99e Initial load duke parents: diff changeset	1749 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1750 "(Temporary, subject to experimentation) " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1751 "Maximum time in abortable preclean (in milliseconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1752 \
a61af66fc99e Initial load duke parents: diff changeset	1753 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1754 "(Temporary, subject to experimentation) " \
0 a61af66fc99e Initial load duke parents: diff changeset	1755 "Nominal minimum work per abortable preclean iteration") \
a61af66fc99e Initial load duke parents: diff changeset	1756 \
1887 cd3ef3fd20dd 6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent ysr parents: 1843 diff changeset	1757 manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1758 "(Temporary, subject to experimentation) " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1759 "Time that we sleep between iterations when not given " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1760 "enough work per iteration") \
0 a61af66fc99e Initial load duke parents: diff changeset	1761 \
a61af66fc99e Initial load duke parents: diff changeset	1762 product(uintx, CMSRescanMultiple, 32, \
a61af66fc99e Initial load duke parents: diff changeset	1763 "Size (in cards) of CMS parallel rescan task") \
a61af66fc99e Initial load duke parents: diff changeset	1764 \
a61af66fc99e Initial load duke parents: diff changeset	1765 product(uintx, CMSConcMarkMultiple, 32, \
a61af66fc99e Initial load duke parents: diff changeset	1766 "Size (in cards) of CMS concurrent MT marking task") \
a61af66fc99e Initial load duke parents: diff changeset	1767 \
a61af66fc99e Initial load duke parents: diff changeset	1768 product(bool, CMSAbortSemantics, false, \
a61af66fc99e Initial load duke parents: diff changeset	1769 "Whether abort-on-overflow semantics is implemented") \
a61af66fc99e Initial load duke parents: diff changeset	1770 \
11975 ca9dedeebdec 6412968: CMS Long initial mark pauses jmasa parents: 11973 diff changeset	1771 product(bool, CMSParallelInitialMarkEnabled, true, \
ca9dedeebdec 6412968: CMS Long initial mark pauses jmasa parents: 11973 diff changeset	1772 "Use the parallel initial mark.") \
ca9dedeebdec 6412968: CMS Long initial mark pauses jmasa parents: 11973 diff changeset	1773 \
0 a61af66fc99e Initial load duke parents: diff changeset	1774 product(bool, CMSParallelRemarkEnabled, true, \
a61af66fc99e Initial load duke parents: diff changeset	1775 "Whether parallel remark enabled (only if ParNewGC)") \
a61af66fc99e Initial load duke parents: diff changeset	1776 \
a61af66fc99e Initial load duke parents: diff changeset	1777 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1778 "Whether parallel remark of survivor space " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1779 "enabled (effective only if CMSParallelRemarkEnabled)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1780 \
a61af66fc99e Initial load duke parents: diff changeset	1781 product(bool, CMSPLABRecordAlways, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1782 "Always record survivor space PLAB boundaries (effective only " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1783 "if CMSParallelSurvivorRemarkEnabled)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1784 \
11973 7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1785 product(bool, CMSEdenChunksRecordAlways, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1786 "Always record eden chunks used for the parallel initial mark " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1787 "or remark of eden") \
11973 7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1788 \
7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1789 product(bool, CMSPrintEdenSurvivorChunks, false, \
7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1790 "Print the eden and the survivor chunks used for the parallel " \
7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1791 "initial mark or remark of the eden/survivor spaces") \
7b06ae405d7b 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses jmasa parents: 11112 diff changeset	1792 \
0 a61af66fc99e Initial load duke parents: diff changeset	1793 product(bool, CMSConcurrentMTEnabled, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1794 "Whether multi-threaded concurrent work enabled " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1795 "(effective only if ParNewGC)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1796 \
a61af66fc99e Initial load duke parents: diff changeset	1797 product(bool, CMSPrecleaningEnabled, true, \
a61af66fc99e Initial load duke parents: diff changeset	1798 "Whether concurrent precleaning enabled") \
a61af66fc99e Initial load duke parents: diff changeset	1799 \
a61af66fc99e Initial load duke parents: diff changeset	1800 product(uintx, CMSPrecleanIter, 3, \
a61af66fc99e Initial load duke parents: diff changeset	1801 "Maximum number of precleaning iteration passes") \
a61af66fc99e Initial load duke parents: diff changeset	1802 \
a61af66fc99e Initial load duke parents: diff changeset	1803 product(uintx, CMSPrecleanNumerator, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1804 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1805 "ratio") \
0 a61af66fc99e Initial load duke parents: diff changeset	1806 \
a61af66fc99e Initial load duke parents: diff changeset	1807 product(uintx, CMSPrecleanDenominator, 3, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1808 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1809 "ratio") \
0 a61af66fc99e Initial load duke parents: diff changeset	1810 \
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 443 diff changeset	1811 product(bool, CMSPrecleanRefLists1, true, \
0 a61af66fc99e Initial load duke parents: diff changeset	1812 "Preclean ref lists during (initial) preclean phase") \
a61af66fc99e Initial load duke parents: diff changeset	1813 \
a61af66fc99e Initial load duke parents: diff changeset	1814 product(bool, CMSPrecleanRefLists2, false, \
a61af66fc99e Initial load duke parents: diff changeset	1815 "Preclean ref lists during abortable preclean phase") \
a61af66fc99e Initial load duke parents: diff changeset	1816 \
a61af66fc99e Initial load duke parents: diff changeset	1817 product(bool, CMSPrecleanSurvivors1, false, \
a61af66fc99e Initial load duke parents: diff changeset	1818 "Preclean survivors during (initial) preclean phase") \
a61af66fc99e Initial load duke parents: diff changeset	1819 \
a61af66fc99e Initial load duke parents: diff changeset	1820 product(bool, CMSPrecleanSurvivors2, true, \
a61af66fc99e Initial load duke parents: diff changeset	1821 "Preclean survivors during abortable preclean phase") \
a61af66fc99e Initial load duke parents: diff changeset	1822 \
a61af66fc99e Initial load duke parents: diff changeset	1823 product(uintx, CMSPrecleanThreshold, 1000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1824 "Do not iterate again if number of dirty cards is less than this")\
0 a61af66fc99e Initial load duke parents: diff changeset	1825 \
a61af66fc99e Initial load duke parents: diff changeset	1826 product(bool, CMSCleanOnEnter, true, \
a61af66fc99e Initial load duke parents: diff changeset	1827 "Clean-on-enter optimization for reducing number of dirty cards") \
a61af66fc99e Initial load duke parents: diff changeset	1828 \
a61af66fc99e Initial load duke parents: diff changeset	1829 product(uintx, CMSRemarkVerifyVariant, 1, \
a61af66fc99e Initial load duke parents: diff changeset	1830 "Choose variant (1,2) of verification following remark") \
a61af66fc99e Initial load duke parents: diff changeset	1831 \
a61af66fc99e Initial load duke parents: diff changeset	1832 product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1833 "If Eden size is below this, do not try to schedule remark") \
0 a61af66fc99e Initial load duke parents: diff changeset	1834 \
a61af66fc99e Initial load duke parents: diff changeset	1835 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1836 "The Eden occupancy percentage (0-100) at which " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1837 "to try and schedule remark pause") \
0 a61af66fc99e Initial load duke parents: diff changeset	1838 \
a61af66fc99e Initial load duke parents: diff changeset	1839 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1840 "Start sampling eden top at least before young gen " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1841 "occupancy reaches 1/<ratio> of the size at which " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1842 "we plan to schedule remark") \
0 a61af66fc99e Initial load duke parents: diff changeset	1843 \
a61af66fc99e Initial load duke parents: diff changeset	1844 product(uintx, CMSSamplingGrain, 16*K, \
a61af66fc99e Initial load duke parents: diff changeset	1845 "The minimum distance between eden samples for CMS (see above)") \
a61af66fc99e Initial load duke parents: diff changeset	1846 \
a61af66fc99e Initial load duke parents: diff changeset	1847 product(bool, CMSScavengeBeforeRemark, false, \
a61af66fc99e Initial load duke parents: diff changeset	1848 "Attempt scavenge before the CMS remark step") \
a61af66fc99e Initial load duke parents: diff changeset	1849 \
a61af66fc99e Initial load duke parents: diff changeset	1850 develop(bool, CMSTraceSweeper, false, \
a61af66fc99e Initial load duke parents: diff changeset	1851 "Trace some actions of the CMS sweeper") \
a61af66fc99e Initial load duke parents: diff changeset	1852 \
a61af66fc99e Initial load duke parents: diff changeset	1853 product(uintx, CMSWorkQueueDrainThreshold, 10, \
a61af66fc99e Initial load duke parents: diff changeset	1854 "Don't drain below this size per parallel worker/thief") \
a61af66fc99e Initial load duke parents: diff changeset	1855 \
1887 cd3ef3fd20dd 6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent ysr parents: 1843 diff changeset	1856 manageable(intx, CMSWaitDuration, 2000, \
0 a61af66fc99e Initial load duke parents: diff changeset	1857 "Time in milliseconds that CMS thread waits for young GC") \
a61af66fc99e Initial load duke parents: diff changeset	1858 \
8679 a252e688abcf 7189971: Implement CMSWaitDuration for non-incremental mode of CMS jmasa parents: 8040 diff changeset	1859 develop(uintx, CMSCheckInterval, 1000, \
a252e688abcf 7189971: Implement CMSWaitDuration for non-incremental mode of CMS jmasa parents: 8040 diff changeset	1860 "Interval in milliseconds that CMS thread checks if it " \
a252e688abcf 7189971: Implement CMSWaitDuration for non-incremental mode of CMS jmasa parents: 8040 diff changeset	1861 "should start a collection cycle") \
a252e688abcf 7189971: Implement CMSWaitDuration for non-incremental mode of CMS jmasa parents: 8040 diff changeset	1862 \
0 a61af66fc99e Initial load duke parents: diff changeset	1863 product(bool, CMSYield, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1864 "Yield between steps of CMS") \
0 a61af66fc99e Initial load duke parents: diff changeset	1865 \
a61af66fc99e Initial load duke parents: diff changeset	1866 product(uintx, CMSBitMapYieldQuantum, 10*M, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1867 "Bitmap operations should process at most this many bits " \
0 a61af66fc99e Initial load duke parents: diff changeset	1868 "between yields") \
a61af66fc99e Initial load duke parents: diff changeset	1869 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1870 product(bool, CMSDumpAtPromotionFailure, false, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1871 "Dump useful information about the state of the CMS old " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1872 "generation upon a promotion failure") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1873 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1874 product(bool, CMSPrintChunksInDump, false, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1875 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1876 "more detailed information about the free chunks") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1877 \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1878 product(bool, CMSPrintObjectsInDump, false, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1879 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1880 "more detailed information about the allocated objects") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1881 \
0 a61af66fc99e Initial load duke parents: diff changeset	1882 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1883 "Verify that all references across the FLS boundary " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1884 "are to valid objects") \
0 a61af66fc99e Initial load duke parents: diff changeset	1885 \
a61af66fc99e Initial load duke parents: diff changeset	1886 diagnostic(bool, FLSVerifyLists, false, \
a61af66fc99e Initial load duke parents: diff changeset	1887 "Do lots of (expensive) FreeListSpace verification") \
a61af66fc99e Initial load duke parents: diff changeset	1888 \
a61af66fc99e Initial load duke parents: diff changeset	1889 diagnostic(bool, FLSVerifyIndexTable, false, \
a61af66fc99e Initial load duke parents: diff changeset	1890 "Do lots of (expensive) FLS index table verification") \
a61af66fc99e Initial load duke parents: diff changeset	1891 \
a61af66fc99e Initial load duke parents: diff changeset	1892 develop(bool, FLSVerifyDictionary, false, \
a61af66fc99e Initial load duke parents: diff changeset	1893 "Do lots of (expensive) FLS dictionary verification") \
a61af66fc99e Initial load duke parents: diff changeset	1894 \
a61af66fc99e Initial load duke parents: diff changeset	1895 develop(bool, VerifyBlockOffsetArray, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1896 "Do (expensive) block offset array verification") \
0 a61af66fc99e Initial load duke parents: diff changeset	1897 \
3321 a1d5f532838d 7040068: CMS: Possibly unsafe initialization of BlockOffsetArrayUseUnallocatedBlock brutisso parents: 3255 diff changeset	1898 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1899 "Maintain _unallocated_block in BlockOffsetArray " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1900 "(currently applicable only to CMS collector)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1901 \
a61af66fc99e Initial load duke parents: diff changeset	1902 develop(bool, TraceCMSState, false, \
a61af66fc99e Initial load duke parents: diff changeset	1903 "Trace the state of the CMS collection") \
a61af66fc99e Initial load duke parents: diff changeset	1904 \
a61af66fc99e Initial load duke parents: diff changeset	1905 product(intx, RefDiscoveryPolicy, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1906 "Select type of reference discovery policy: " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1907 "reference-based(0) or referent-based(1)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1908 \
a61af66fc99e Initial load duke parents: diff changeset	1909 product(bool, ParallelRefProcEnabled, false, \
a61af66fc99e Initial load duke parents: diff changeset	1910 "Enable parallel reference processing whenever possible") \
a61af66fc99e Initial load duke parents: diff changeset	1911 \
a61af66fc99e Initial load duke parents: diff changeset	1912 product(bool, ParallelRefProcBalancingEnabled, true, \
a61af66fc99e Initial load duke parents: diff changeset	1913 "Enable balancing of reference processing queues") \
a61af66fc99e Initial load duke parents: diff changeset	1914 \
8035 f64ffbf81af5 8006432: Ratio flags should be unsigned jwilhelm parents: 8034 diff changeset	1915 product(uintx, CMSTriggerRatio, 80, \
0 a61af66fc99e Initial load duke parents: diff changeset	1916 "Percentage of MinHeapFreeRatio in CMS generation that is " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1917 "allocated before a CMS collection cycle commences") \
0 a61af66fc99e Initial load duke parents: diff changeset	1918 \
94 0834225a7916 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction ysr parents: 15 diff changeset	1919 product(uintx, CMSBootstrapOccupancy, 50, \
0 a61af66fc99e Initial load duke parents: diff changeset	1920 "Percentage CMS generation occupancy at which to " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1921 "initiate CMS collection for bootstrapping collection stats") \
0 a61af66fc99e Initial load duke parents: diff changeset	1922 \
a61af66fc99e Initial load duke parents: diff changeset	1923 product(intx, CMSInitiatingOccupancyFraction, -1, \
a61af66fc99e Initial load duke parents: diff changeset	1924 "Percentage CMS generation occupancy to start a CMS collection " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1925 "cycle. A negative value means that CMSTriggerRatio is used") \
94 0834225a7916 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction ysr parents: 15 diff changeset	1926 \
1283 1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1927 product(uintx, InitiatingHeapOccupancyPercent, 45, \
1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1928 "Percentage of the (entire) heap occupancy to start a " \
8034 bce1ac447f6b 7052429: G1: Avoid unnecessary scanning of humongous regions during concurrent marking johnc parents: 7615 diff changeset	1929 "concurrent GC cycle. It is used by GCs that trigger a " \
1283 1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1930 "concurrent GC cycle based on the occupancy of the entire heap, " \
1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1931 "not just one of the generations (e.g., G1). A value of 0 " \
1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1932 "denotes 'do constant GC cycles'.") \
1c72304f1885 6928073: G1: use existing command line parameters for marking cycle initiation tonyp parents: 1211 diff changeset	1933 \
0 a61af66fc99e Initial load duke parents: diff changeset	1934 product(bool, UseCMSInitiatingOccupancyOnly, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1935 "Only use occupancy as a criterion for starting a CMS collection")\
0 a61af66fc99e Initial load duke parents: diff changeset	1936 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1937 product(uintx, CMSIsTooFullPercentage, 98, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1938 "An absolute ceiling above which CMS will always consider the " \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	1939 "unloading of classes when class unloading is enabled") \
94 0834225a7916 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction ysr parents: 15 diff changeset	1940 \
0 a61af66fc99e Initial load duke parents: diff changeset	1941 develop(bool, CMSTestInFreeList, false, \
a61af66fc99e Initial load duke parents: diff changeset	1942 "Check if the coalesced range is already in the " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	1943 "free lists as claimed") \
0 a61af66fc99e Initial load duke parents: diff changeset	1944 \
a61af66fc99e Initial load duke parents: diff changeset	1945 notproduct(bool, CMSVerifyReturnedBytes, false, \
a61af66fc99e Initial load duke parents: diff changeset	1946 "Check that all the garbage collected was returned to the " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1947 "free lists") \
0 a61af66fc99e Initial load duke parents: diff changeset	1948 \
a61af66fc99e Initial load duke parents: diff changeset	1949 notproduct(bool, ScavengeALot, false, \
a61af66fc99e Initial load duke parents: diff changeset	1950 "Force scavenge at every Nth exit from the runtime system " \
a61af66fc99e Initial load duke parents: diff changeset	1951 "(N=ScavengeALotInterval)") \
a61af66fc99e Initial load duke parents: diff changeset	1952 \
a61af66fc99e Initial load duke parents: diff changeset	1953 develop(bool, FullGCALot, false, \
a61af66fc99e Initial load duke parents: diff changeset	1954 "Force full gc at every Nth exit from the runtime system " \
a61af66fc99e Initial load duke parents: diff changeset	1955 "(N=FullGCALotInterval)") \
a61af66fc99e Initial load duke parents: diff changeset	1956 \
a61af66fc99e Initial load duke parents: diff changeset	1957 notproduct(bool, GCALotAtAllSafepoints, false, \
a61af66fc99e Initial load duke parents: diff changeset	1958 "Enforce ScavengeALot/GCALot at all potential safepoints") \
a61af66fc99e Initial load duke parents: diff changeset	1959 \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1960 product(bool, PrintPromotionFailure, false, \
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1961 "Print additional diagnostic information following " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1962 "promotion failure") \
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 1064 diff changeset	1963 \
0 a61af66fc99e Initial load duke parents: diff changeset	1964 notproduct(bool, PromotionFailureALot, false, \
a61af66fc99e Initial load duke parents: diff changeset	1965 "Use promotion failure handling on every youngest generation " \
a61af66fc99e Initial load duke parents: diff changeset	1966 "collection") \
a61af66fc99e Initial load duke parents: diff changeset	1967 \
a61af66fc99e Initial load duke parents: diff changeset	1968 develop(uintx, PromotionFailureALotCount, 1000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1969 "Number of promotion failures occurring at ParGCAllocBuffer " \
0 a61af66fc99e Initial load duke parents: diff changeset	1970 "refill attempts (ParNew) or promotion attempts " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1971 "(other young collectors)") \
0 a61af66fc99e Initial load duke parents: diff changeset	1972 \
a61af66fc99e Initial load duke parents: diff changeset	1973 develop(uintx, PromotionFailureALotInterval, 5, \
a61af66fc99e Initial load duke parents: diff changeset	1974 "Total collections between promotion failures alot") \
a61af66fc99e Initial load duke parents: diff changeset	1975 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	1976 experimental(uintx, WorkStealingSleepMillis, 1, \
0 a61af66fc99e Initial load duke parents: diff changeset	1977 "Sleep time when sleep is used for yields") \
a61af66fc99e Initial load duke parents: diff changeset	1978 \
2430 5c0b591e1074 6948149: G1: Imbalance in termination times brutisso parents: 2379 diff changeset	1979 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
0 a61af66fc99e Initial load duke parents: diff changeset	1980 "Number of yields before a sleep is done during workstealing") \
a61af66fc99e Initial load duke parents: diff changeset	1981 \
1837 c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	1982 experimental(uintx, WorkStealingHardSpins, 4096, \
546 05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 541 diff changeset	1983 "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	1984 "time out of hard spin") \
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 541 diff changeset	1985 \
1837 c99c53f07c14 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time ysr parents: 1836 diff changeset	1986 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
546 05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 541 diff changeset	1987 "Ratio of hard spins to calls to yield") \
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination. jmasa parents: 541 diff changeset	1988 \
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1288 diff changeset	1989 develop(uintx, ObjArrayMarkingStride, 512, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1990 "Number of object array elements to push onto the marking stack " \
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1288 diff changeset	1991 "before pushing a continuation entry") \
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1288 diff changeset	1992 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1993 develop(bool, MetadataAllocationFailALot, false, \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1994 "Fail metadata allocations at intervals controlled by " \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1995 "MetadataAllocationFailALotInterval") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1996 \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1997 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	1998 "Metadata allocation failure a lot interval") \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	1999 \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2000 develop(bool, TraceMetadataChunkAllocation, false, \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	2001 "Trace chunk metadata allocations") \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2002 \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2003 product(bool, TraceMetadataHumongousAllocation, false, \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2004 "Trace humongous metadata allocations") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2005 \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2006 develop(bool, TraceMetavirtualspaceAllocation, false, \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	2007 "Trace virtual space metadata allocations") \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2008 \
3779 04760e41b01e 7016112: CMS: crash during promotion testing brutisso parents: 3767 diff changeset	2009 notproduct(bool, ExecuteInternalVMTests, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2010 "Enable execution of internal VM tests") \
3779 04760e41b01e 7016112: CMS: crash during promotion testing brutisso parents: 3767 diff changeset	2011 \
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12056 diff changeset	2012 notproduct(bool, VerboseInternalVMTests, false, \
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12056 diff changeset	2013 "Turn on logging for internal VM tests.") \
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12056 diff changeset	2014 \
0 a61af66fc99e Initial load duke parents: diff changeset	2015 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
a61af66fc99e Initial load duke parents: diff changeset	2016 \
a61af66fc99e Initial load duke parents: diff changeset	2017 product_pd(bool, ResizeTLAB, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2018 "Dynamically resize TLAB size for threads") \
0 a61af66fc99e Initial load duke parents: diff changeset	2019 \
a61af66fc99e Initial load duke parents: diff changeset	2020 product(bool, ZeroTLAB, false, \
a61af66fc99e Initial load duke parents: diff changeset	2021 "Zero out the newly created TLAB") \
a61af66fc99e Initial load duke parents: diff changeset	2022 \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	2023 product(bool, FastTLABRefill, true, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	2024 "Use fast TLAB refill code") \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 142 diff changeset	2025 \
0 a61af66fc99e Initial load duke parents: diff changeset	2026 product(bool, PrintTLAB, false, \
a61af66fc99e Initial load duke parents: diff changeset	2027 "Print various TLAB related information") \
a61af66fc99e Initial load duke parents: diff changeset	2028 \
a61af66fc99e Initial load duke parents: diff changeset	2029 product(bool, TLABStats, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2030 "Provide more detailed and expensive TLAB statistics " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2031 "(with PrintTLAB)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2032 \
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2033 EMBEDDED_ONLY(product(bool, LowMemoryProtection, true, \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2034 "Enable LowMemoryProtection")) \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2035 \
0 a61af66fc99e Initial load duke parents: diff changeset	2036 product_pd(bool, NeverActAsServerClassMachine, \
a61af66fc99e Initial load duke parents: diff changeset	2037 "Never act like a server-class machine") \
a61af66fc99e Initial load duke parents: diff changeset	2038 \
a61af66fc99e Initial load duke parents: diff changeset	2039 product(bool, AlwaysActAsServerClassMachine, false, \
a61af66fc99e Initial load duke parents: diff changeset	2040 "Always act like a server-class machine") \
a61af66fc99e Initial load duke parents: diff changeset	2041 \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2042 product_pd(uint64_t, MaxRAM, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2043 "Real memory size (in bytes) used to set maximum heap size") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2044 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2045 product(uintx, ErgoHeapSizeLimit, 0, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2046 "Maximum ergonomically set heap size (in bytes); zero means use " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2047 "MaxRAM / MaxRAMFraction") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2048 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2049 product(uintx, MaxRAMFraction, 4, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2050 "Maximum fraction (1/n) of real memory used for maximum heap " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2051 "size") \
0 a61af66fc99e Initial load duke parents: diff changeset	2052 \
a61af66fc99e Initial load duke parents: diff changeset	2053 product(uintx, DefaultMaxRAMFraction, 4, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2054 "Maximum fraction (1/n) of real memory used for maximum heap " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2055 "size; deprecated: to be renamed to MaxRAMFraction") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2056 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2057 product(uintx, MinRAMFraction, 2, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2058 "Minimum fraction (1/n) of real memory used for maxmimum heap " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2059 "size on systems with small physical memory size") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2060 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2061 product(uintx, InitialRAMFraction, 64, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2062 "Fraction (1/n) of real memory used for initial heap size") \
0 a61af66fc99e Initial load duke parents: diff changeset	2063 \
8854 754c24457b20 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM tschatzl parents: 8853 diff changeset	2064 develop(uintx, MaxVirtMemFraction, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2065 "Maximum fraction (1/n) of virtual memory used for ergonomically "\
8854 754c24457b20 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM tschatzl parents: 8853 diff changeset	2066 "determining maximum heap size") \
754c24457b20 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM tschatzl parents: 8853 diff changeset	2067 \
0 a61af66fc99e Initial load duke parents: diff changeset	2068 product(bool, UseAutoGCSelectPolicy, false, \
a61af66fc99e Initial load duke parents: diff changeset	2069 "Use automatic collection selection policy") \
a61af66fc99e Initial load duke parents: diff changeset	2070 \
a61af66fc99e Initial load duke parents: diff changeset	2071 product(uintx, AutoGCSelectPauseMillis, 5000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2072 "Automatic GC selection pause threshold in milliseconds") \
0 a61af66fc99e Initial load duke parents: diff changeset	2073 \
a61af66fc99e Initial load duke parents: diff changeset	2074 product(bool, UseAdaptiveSizePolicy, true, \
a61af66fc99e Initial load duke parents: diff changeset	2075 "Use adaptive generation sizing policies") \
a61af66fc99e Initial load duke parents: diff changeset	2076 \
a61af66fc99e Initial load duke parents: diff changeset	2077 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
a61af66fc99e Initial load duke parents: diff changeset	2078 "Use adaptive survivor sizing policies") \
a61af66fc99e Initial load duke parents: diff changeset	2079 \
a61af66fc99e Initial load duke parents: diff changeset	2080 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
a61af66fc99e Initial load duke parents: diff changeset	2081 "Use adaptive young-old sizing policies at minor collections") \
a61af66fc99e Initial load duke parents: diff changeset	2082 \
a61af66fc99e Initial load duke parents: diff changeset	2083 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
a61af66fc99e Initial load duke parents: diff changeset	2084 "Use adaptive young-old sizing policies at major collections") \
a61af66fc99e Initial load duke parents: diff changeset	2085 \
a61af66fc99e Initial load duke parents: diff changeset	2086 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2087 "Include statistics from System.gc() for adaptive size policy") \
0 a61af66fc99e Initial load duke parents: diff changeset	2088 \
a61af66fc99e Initial load duke parents: diff changeset	2089 product(bool, UseAdaptiveGCBoundary, false, \
a61af66fc99e Initial load duke parents: diff changeset	2090 "Allow young-old boundary to move") \
a61af66fc99e Initial load duke parents: diff changeset	2091 \
a61af66fc99e Initial load duke parents: diff changeset	2092 develop(bool, TraceAdaptiveGCBoundary, false, \
a61af66fc99e Initial load duke parents: diff changeset	2093 "Trace young-old boundary moves") \
a61af66fc99e Initial load duke parents: diff changeset	2094 \
a61af66fc99e Initial load duke parents: diff changeset	2095 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2096 "Resize the virtual spaces of the young or old generations") \
a61af66fc99e Initial load duke parents: diff changeset	2097 \
a61af66fc99e Initial load duke parents: diff changeset	2098 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2099 "Policy for changing generation size for throughput goals") \
0 a61af66fc99e Initial load duke parents: diff changeset	2100 \
a61af66fc99e Initial load duke parents: diff changeset	2101 product(uintx, AdaptiveSizePausePolicy, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2102 "Policy for changing generation size for pause goals") \
a61af66fc99e Initial load duke parents: diff changeset	2103 \
a61af66fc99e Initial load duke parents: diff changeset	2104 develop(bool, PSAdjustTenuredGenForMinorPause, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2105 "Adjust tenured generation to achieve a minor pause goal") \
0 a61af66fc99e Initial load duke parents: diff changeset	2106 \
a61af66fc99e Initial load duke parents: diff changeset	2107 develop(bool, PSAdjustYoungGenForMajorPause, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2108 "Adjust young generation to achieve a major pause goal") \
0 a61af66fc99e Initial load duke parents: diff changeset	2109 \
a61af66fc99e Initial load duke parents: diff changeset	2110 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
a61af66fc99e Initial load duke parents: diff changeset	2111 "Number of steps where heuristics is used before data is used") \
a61af66fc99e Initial load duke parents: diff changeset	2112 \
a61af66fc99e Initial load duke parents: diff changeset	2113 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
a61af66fc99e Initial load duke parents: diff changeset	2114 "Number of collections before the adaptive sizing is started") \
a61af66fc99e Initial load duke parents: diff changeset	2115 \
a61af66fc99e Initial load duke parents: diff changeset	2116 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	2117 "Collection interval for printing information; zero means never") \
0 a61af66fc99e Initial load duke parents: diff changeset	2118 \
a61af66fc99e Initial load duke parents: diff changeset	2119 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
a61af66fc99e Initial load duke parents: diff changeset	2120 "Use adaptive minimum footprint as a goal") \
a61af66fc99e Initial load duke parents: diff changeset	2121 \
a61af66fc99e Initial load duke parents: diff changeset	2122 product(uintx, AdaptiveSizePolicyWeight, 10, \
a61af66fc99e Initial load duke parents: diff changeset	2123 "Weight given to exponential resizing, between 0 and 100") \
a61af66fc99e Initial load duke parents: diff changeset	2124 \
a61af66fc99e Initial load duke parents: diff changeset	2125 product(uintx, AdaptiveTimeWeight, 25, \
a61af66fc99e Initial load duke parents: diff changeset	2126 "Weight given to time in adaptive policy, between 0 and 100") \
a61af66fc99e Initial load duke parents: diff changeset	2127 \
a61af66fc99e Initial load duke parents: diff changeset	2128 product(uintx, PausePadding, 1, \
a61af66fc99e Initial load duke parents: diff changeset	2129 "How much buffer to keep for pause time") \
a61af66fc99e Initial load duke parents: diff changeset	2130 \
a61af66fc99e Initial load duke parents: diff changeset	2131 product(uintx, PromotedPadding, 3, \
a61af66fc99e Initial load duke parents: diff changeset	2132 "How much buffer to keep for promotion failure") \
a61af66fc99e Initial load duke parents: diff changeset	2133 \
a61af66fc99e Initial load duke parents: diff changeset	2134 product(uintx, SurvivorPadding, 3, \
a61af66fc99e Initial load duke parents: diff changeset	2135 "How much buffer to keep for survivor overflow") \
a61af66fc99e Initial load duke parents: diff changeset	2136 \
a61af66fc99e Initial load duke parents: diff changeset	2137 product(uintx, ThresholdTolerance, 10, \
a61af66fc99e Initial load duke parents: diff changeset	2138 "Allowed collection cost difference between generations") \
a61af66fc99e Initial load duke parents: diff changeset	2139 \
a61af66fc99e Initial load duke parents: diff changeset	2140 product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2141 "If collection costs are within margin, reduce both by full " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2142 "delta") \
0 a61af66fc99e Initial load duke parents: diff changeset	2143 \
a61af66fc99e Initial load duke parents: diff changeset	2144 product(uintx, YoungGenerationSizeIncrement, 20, \
a61af66fc99e Initial load duke parents: diff changeset	2145 "Adaptive size percentage change in young generation") \
a61af66fc99e Initial load duke parents: diff changeset	2146 \
a61af66fc99e Initial load duke parents: diff changeset	2147 product(uintx, YoungGenerationSizeSupplement, 80, \
a61af66fc99e Initial load duke parents: diff changeset	2148 "Supplement to YoungedGenerationSizeIncrement used at startup") \
a61af66fc99e Initial load duke parents: diff changeset	2149 \
a61af66fc99e Initial load duke parents: diff changeset	2150 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
a61af66fc99e Initial load duke parents: diff changeset	2151 "Decay factor to YoungedGenerationSizeSupplement") \
a61af66fc99e Initial load duke parents: diff changeset	2152 \
a61af66fc99e Initial load duke parents: diff changeset	2153 product(uintx, TenuredGenerationSizeIncrement, 20, \
a61af66fc99e Initial load duke parents: diff changeset	2154 "Adaptive size percentage change in tenured generation") \
a61af66fc99e Initial load duke parents: diff changeset	2155 \
a61af66fc99e Initial load duke parents: diff changeset	2156 product(uintx, TenuredGenerationSizeSupplement, 80, \
a61af66fc99e Initial load duke parents: diff changeset	2157 "Supplement to TenuredGenerationSizeIncrement used at startup") \
a61af66fc99e Initial load duke parents: diff changeset	2158 \
a61af66fc99e Initial load duke parents: diff changeset	2159 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
a61af66fc99e Initial load duke parents: diff changeset	2160 "Decay factor to TenuredGenerationSizeIncrement") \
a61af66fc99e Initial load duke parents: diff changeset	2161 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	2162 product(uintx, MaxGCPauseMillis, max_uintx, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2163 "Adaptive size policy maximum GC pause time goal in millisecond, "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2164 "or (G1 Only) the maximum GC time per MMU time slice") \
751 20c6f43950b5 6490395: G1: Tidy up command line flags. johnc parents: 726 diff changeset	2165 \
1610 79107c3a6bd5 6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent tonyp parents: 1589 diff changeset	2166 product(uintx, GCPauseIntervalMillis, 0, \
751 20c6f43950b5 6490395: G1: Tidy up command line flags. johnc parents: 726 diff changeset	2167 "Time slice for MMU specification") \
0 a61af66fc99e Initial load duke parents: diff changeset	2168 \
a61af66fc99e Initial load duke parents: diff changeset	2169 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2170 "Adaptive size policy maximum GC minor pause time goal " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2171 "in millisecond") \
0 a61af66fc99e Initial load duke parents: diff changeset	2172 \
a61af66fc99e Initial load duke parents: diff changeset	2173 product(uintx, GCTimeRatio, 99, \
a61af66fc99e Initial load duke parents: diff changeset	2174 "Adaptive size policy application time to GC time ratio") \
a61af66fc99e Initial load duke parents: diff changeset	2175 \
a61af66fc99e Initial load duke parents: diff changeset	2176 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
a61af66fc99e Initial load duke parents: diff changeset	2177 "Adaptive size scale down factor for shrinking") \
a61af66fc99e Initial load duke parents: diff changeset	2178 \
a61af66fc99e Initial load duke parents: diff changeset	2179 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
a61af66fc99e Initial load duke parents: diff changeset	2180 "Adaptive size decays the major cost for long major intervals") \
a61af66fc99e Initial load duke parents: diff changeset	2181 \
a61af66fc99e Initial load duke parents: diff changeset	2182 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
a61af66fc99e Initial load duke parents: diff changeset	2183 "Time scale over which major costs decay") \
a61af66fc99e Initial load duke parents: diff changeset	2184 \
a61af66fc99e Initial load duke parents: diff changeset	2185 product(uintx, MinSurvivorRatio, 3, \
a61af66fc99e Initial load duke parents: diff changeset	2186 "Minimum ratio of young generation/survivor space size") \
a61af66fc99e Initial load duke parents: diff changeset	2187 \
a61af66fc99e Initial load duke parents: diff changeset	2188 product(uintx, InitialSurvivorRatio, 8, \
12899 bfd52054aeb8 8024632: Description of InitialSurvivorRatio flag in globals.hpp is incorrect pliden parents: 12893 diff changeset	2189 "Initial ratio of young generation/survivor space size") \
0 a61af66fc99e Initial load duke parents: diff changeset	2190 \
a61af66fc99e Initial load duke parents: diff changeset	2191 product(uintx, BaseFootPrintEstimate, 256*M, \
a61af66fc99e Initial load duke parents: diff changeset	2192 "Estimate of footprint other than Java Heap") \
a61af66fc99e Initial load duke parents: diff changeset	2193 \
a61af66fc99e Initial load duke parents: diff changeset	2194 product(bool, UseGCOverheadLimit, true, \
a61af66fc99e Initial load duke parents: diff changeset	2195 "Use policy to limit of proportion of time spent in GC " \
a61af66fc99e Initial load duke parents: diff changeset	2196 "before an OutOfMemory error is thrown") \
a61af66fc99e Initial load duke parents: diff changeset	2197 \
a61af66fc99e Initial load duke parents: diff changeset	2198 product(uintx, GCTimeLimit, 98, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2199 "Limit of the proportion of time spent in GC before " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2200 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2201 \
a61af66fc99e Initial load duke parents: diff changeset	2202 product(uintx, GCHeapFreeLimit, 2, \
a61af66fc99e Initial load duke parents: diff changeset	2203 "Minimum percentage of free space after a full GC before an " \
a61af66fc99e Initial load duke parents: diff changeset	2204 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
a61af66fc99e Initial load duke parents: diff changeset	2205 \
a61af66fc99e Initial load duke parents: diff changeset	2206 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
a61af66fc99e Initial load duke parents: diff changeset	2207 "Number of consecutive collections before gc time limit fires") \
a61af66fc99e Initial load duke parents: diff changeset	2208 \
a61af66fc99e Initial load duke parents: diff changeset	2209 product(bool, PrintAdaptiveSizePolicy, false, \
a61af66fc99e Initial load duke parents: diff changeset	2210 "Print information about AdaptiveSizePolicy") \
a61af66fc99e Initial load duke parents: diff changeset	2211 \
a61af66fc99e Initial load duke parents: diff changeset	2212 product(intx, PrefetchCopyIntervalInBytes, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2213 "How far ahead to prefetch destination area (<= 0 means off)") \
a61af66fc99e Initial load duke parents: diff changeset	2214 \
a61af66fc99e Initial load duke parents: diff changeset	2215 product(intx, PrefetchScanIntervalInBytes, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2216 "How far ahead to prefetch scan area (<= 0 means off)") \
a61af66fc99e Initial load duke parents: diff changeset	2217 \
a61af66fc99e Initial load duke parents: diff changeset	2218 product(intx, PrefetchFieldsAhead, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2219 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
a61af66fc99e Initial load duke parents: diff changeset	2220 \
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 9073 diff changeset	2221 diagnostic(bool, VerifySilently, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2222 "Do not print the verification progress") \
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 9073 diff changeset	2223 \
9071 68fe50d4f1d5 8011343: Add new flag for verifying the heap during startup johnc parents: 8880 diff changeset	2224 diagnostic(bool, VerifyDuringStartup, false, \
68fe50d4f1d5 8011343: Add new flag for verifying the heap during startup johnc parents: 8880 diff changeset	2225 "Verify memory system before executing any Java code " \
68fe50d4f1d5 8011343: Add new flag for verifying the heap during startup johnc parents: 8880 diff changeset	2226 "during VM initialization") \
68fe50d4f1d5 8011343: Add new flag for verifying the heap during startup johnc parents: 8880 diff changeset	2227 \
0 a61af66fc99e Initial load duke parents: diff changeset	2228 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	2229 "Verify system before exiting") \
a61af66fc99e Initial load duke parents: diff changeset	2230 \
a61af66fc99e Initial load duke parents: diff changeset	2231 diagnostic(bool, VerifyBeforeGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2232 "Verify memory system before GC") \
a61af66fc99e Initial load duke parents: diff changeset	2233 \
a61af66fc99e Initial load duke parents: diff changeset	2234 diagnostic(bool, VerifyAfterGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2235 "Verify memory system after GC") \
a61af66fc99e Initial load duke parents: diff changeset	2236 \
a61af66fc99e Initial load duke parents: diff changeset	2237 diagnostic(bool, VerifyDuringGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2238 "Verify memory system during GC (between phases)") \
a61af66fc99e Initial load duke parents: diff changeset	2239 \
390 cc68c8e9b309 6752248: G1: introduce parallel heap verification tonyp parents: 389 diff changeset	2240 diagnostic(bool, GCParallelVerificationEnabled, true, \
cc68c8e9b309 6752248: G1: introduce parallel heap verification tonyp parents: 389 diff changeset	2241 "Enable parallel memory system verification") \
cc68c8e9b309 6752248: G1: introduce parallel heap verification tonyp parents: 389 diff changeset	2242 \
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1146 diff changeset	2243 diagnostic(bool, DeferInitialCardMark, false, \
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1146 diff changeset	2244 "When +ReduceInitialCardMarks, explicitly defer any that " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2245 "may arise from new_pre_store_barrier") \
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1146 diff changeset	2246 \
0 a61af66fc99e Initial load duke parents: diff changeset	2247 diagnostic(bool, VerifyRememberedSets, false, \
a61af66fc99e Initial load duke parents: diff changeset	2248 "Verify GC remembered sets") \
a61af66fc99e Initial load duke parents: diff changeset	2249 \
a61af66fc99e Initial load duke parents: diff changeset	2250 diagnostic(bool, VerifyObjectStartArray, true, \
a61af66fc99e Initial load duke parents: diff changeset	2251 "Verify GC object start array if verify before/after") \
a61af66fc99e Initial load duke parents: diff changeset	2252 \
a61af66fc99e Initial load duke parents: diff changeset	2253 product(bool, DisableExplicitGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2254 "Ignore calls to System.gc()") \
0 a61af66fc99e Initial load duke parents: diff changeset	2255 \
a61af66fc99e Initial load duke parents: diff changeset	2256 notproduct(bool, CheckMemoryInitialization, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2257 "Check memory initialization") \
0 a61af66fc99e Initial load duke parents: diff changeset	2258 \
a61af66fc99e Initial load duke parents: diff changeset	2259 product(bool, CollectGen0First, false, \
a61af66fc99e Initial load duke parents: diff changeset	2260 "Collect youngest generation before each full GC") \
a61af66fc99e Initial load duke parents: diff changeset	2261 \
a61af66fc99e Initial load duke parents: diff changeset	2262 diagnostic(bool, BindCMSThreadToCPU, false, \
a61af66fc99e Initial load duke parents: diff changeset	2263 "Bind CMS Thread to CPU if possible") \
a61af66fc99e Initial load duke parents: diff changeset	2264 \
a61af66fc99e Initial load duke parents: diff changeset	2265 diagnostic(uintx, CPUForCMSThread, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2266 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
a61af66fc99e Initial load duke parents: diff changeset	2267 \
a61af66fc99e Initial load duke parents: diff changeset	2268 product(bool, BindGCTaskThreadsToCPUs, false, \
a61af66fc99e Initial load duke parents: diff changeset	2269 "Bind GCTaskThreads to CPUs if possible") \
a61af66fc99e Initial load duke parents: diff changeset	2270 \
a61af66fc99e Initial load duke parents: diff changeset	2271 product(bool, UseGCTaskAffinity, false, \
a61af66fc99e Initial load duke parents: diff changeset	2272 "Use worker affinity when asking for GCTasks") \
a61af66fc99e Initial load duke parents: diff changeset	2273 \
a61af66fc99e Initial load duke parents: diff changeset	2274 product(uintx, ProcessDistributionStride, 4, \
a61af66fc99e Initial load duke parents: diff changeset	2275 "Stride through processors when distributing processes") \
a61af66fc99e Initial load duke parents: diff changeset	2276 \
a61af66fc99e Initial load duke parents: diff changeset	2277 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2278 "Number of times the coordinator GC thread will sleep while " \
0 a61af66fc99e Initial load duke parents: diff changeset	2279 "yielding before giving up and resuming GC") \
a61af66fc99e Initial load duke parents: diff changeset	2280 \
a61af66fc99e Initial load duke parents: diff changeset	2281 product(uintx, CMSYieldSleepCount, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2282 "Number of times a GC thread (minus the coordinator) " \
0 a61af66fc99e Initial load duke parents: diff changeset	2283 "will sleep while yielding before giving up and resuming GC") \
a61af66fc99e Initial load duke parents: diff changeset	2284 \
a61af66fc99e Initial load duke parents: diff changeset	2285 /* gc tracing */ \
a61af66fc99e Initial load duke parents: diff changeset	2286 manageable(bool, PrintGC, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2287 "Print message at garbage collection") \
0 a61af66fc99e Initial load duke parents: diff changeset	2288 \
a61af66fc99e Initial load duke parents: diff changeset	2289 manageable(bool, PrintGCDetails, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2290 "Print more details at garbage collection") \
0 a61af66fc99e Initial load duke parents: diff changeset	2291 \
a61af66fc99e Initial load duke parents: diff changeset	2292 manageable(bool, PrintGCDateStamps, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2293 "Print date stamps at garbage collection") \
0 a61af66fc99e Initial load duke parents: diff changeset	2294 \
a61af66fc99e Initial load duke parents: diff changeset	2295 manageable(bool, PrintGCTimeStamps, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2296 "Print timestamps at garbage collection") \
0 a61af66fc99e Initial load duke parents: diff changeset	2297 \
a61af66fc99e Initial load duke parents: diff changeset	2298 product(bool, PrintGCTaskTimeStamps, false, \
a61af66fc99e Initial load duke parents: diff changeset	2299 "Print timestamps for individual gc worker thread tasks") \
a61af66fc99e Initial load duke parents: diff changeset	2300 \
a61af66fc99e Initial load duke parents: diff changeset	2301 develop(intx, ConcGCYieldTimeout, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2302 "If non-zero, assert that GC threads yield within this " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2303 "number of milliseconds") \
0 a61af66fc99e Initial load duke parents: diff changeset	2304 \
a61af66fc99e Initial load duke parents: diff changeset	2305 notproduct(bool, TraceMarkSweep, false, \
a61af66fc99e Initial load duke parents: diff changeset	2306 "Trace mark sweep") \
a61af66fc99e Initial load duke parents: diff changeset	2307 \
a61af66fc99e Initial load duke parents: diff changeset	2308 product(bool, PrintReferenceGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2309 "Print times spent handling reference objects during GC " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2310 "(enabled only when PrintGCDetails)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2311 \
a61af66fc99e Initial load duke parents: diff changeset	2312 develop(bool, TraceReferenceGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2313 "Trace handling of soft/weak/final/phantom references") \
a61af66fc99e Initial load duke parents: diff changeset	2314 \
a61af66fc99e Initial load duke parents: diff changeset	2315 develop(bool, TraceFinalizerRegistration, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2316 "Trace registration of final references") \
0 a61af66fc99e Initial load duke parents: diff changeset	2317 \
a61af66fc99e Initial load duke parents: diff changeset	2318 notproduct(bool, TraceScavenge, false, \
a61af66fc99e Initial load duke parents: diff changeset	2319 "Trace scavenge") \
a61af66fc99e Initial load duke parents: diff changeset	2320 \
a61af66fc99e Initial load duke parents: diff changeset	2321 product_rw(bool, TraceClassLoading, false, \
a61af66fc99e Initial load duke parents: diff changeset	2322 "Trace all classes loaded") \
a61af66fc99e Initial load duke parents: diff changeset	2323 \
a61af66fc99e Initial load duke parents: diff changeset	2324 product(bool, TraceClassLoadingPreorder, false, \
a61af66fc99e Initial load duke parents: diff changeset	2325 "Trace all classes loaded in order referenced (not loaded)") \
a61af66fc99e Initial load duke parents: diff changeset	2326 \
a61af66fc99e Initial load duke parents: diff changeset	2327 product_rw(bool, TraceClassUnloading, false, \
a61af66fc99e Initial load duke parents: diff changeset	2328 "Trace unloading of classes") \
a61af66fc99e Initial load duke parents: diff changeset	2329 \
a61af66fc99e Initial load duke parents: diff changeset	2330 product_rw(bool, TraceLoaderConstraints, false, \
a61af66fc99e Initial load duke parents: diff changeset	2331 "Trace loader constraints") \
a61af66fc99e Initial load duke parents: diff changeset	2332 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2333 develop(bool, TraceClassLoaderData, false, \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2334 "Trace class loader loader_data lifetime") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2335 \
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7428 diff changeset	2336 product(uintx, InitialBootClassLoaderMetaspaceSize, \
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7428 diff changeset	2337 NOT_LP64(2200K) LP64_ONLY(4M), \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2338 "Initial size of the boot class loader data metaspace") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	2339 \
0 a61af66fc99e Initial load duke parents: diff changeset	2340 product(bool, TraceGen0Time, false, \
a61af66fc99e Initial load duke parents: diff changeset	2341 "Trace accumulated time for Gen 0 collection") \
a61af66fc99e Initial load duke parents: diff changeset	2342 \
a61af66fc99e Initial load duke parents: diff changeset	2343 product(bool, TraceGen1Time, false, \
a61af66fc99e Initial load duke parents: diff changeset	2344 "Trace accumulated time for Gen 1 collection") \
a61af66fc99e Initial load duke parents: diff changeset	2345 \
a61af66fc99e Initial load duke parents: diff changeset	2346 product(bool, PrintTenuringDistribution, false, \
a61af66fc99e Initial load duke parents: diff changeset	2347 "Print tenuring age information") \
a61af66fc99e Initial load duke parents: diff changeset	2348 \
a61af66fc99e Initial load duke parents: diff changeset	2349 product_rw(bool, PrintHeapAtGC, false, \
a61af66fc99e Initial load duke parents: diff changeset	2350 "Print heap layout before and after each GC") \
a61af66fc99e Initial load duke parents: diff changeset	2351 \
838 0316eac49d5a 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set tonyp parents: 779 diff changeset	2352 product_rw(bool, PrintHeapAtGCExtended, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2353 "Print extended information about the layout of the heap " \
838 0316eac49d5a 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set tonyp parents: 779 diff changeset	2354 "when -XX:+PrintHeapAtGC is set") \
0316eac49d5a 6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set tonyp parents: 779 diff changeset	2355 \
0 a61af66fc99e Initial load duke parents: diff changeset	2356 product(bool, PrintHeapAtSIGBREAK, true, \
a61af66fc99e Initial load duke parents: diff changeset	2357 "Print heap layout in response to SIGBREAK") \
a61af66fc99e Initial load duke parents: diff changeset	2358 \
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2359 manageable(bool, PrintClassHistogramBeforeFullGC, false, \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2360 "Print a class histogram before any major stop-world GC") \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2361 \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2362 manageable(bool, PrintClassHistogramAfterFullGC, false, \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2363 "Print a class histogram after any major stop-world GC") \
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 570 diff changeset	2364 \
0 a61af66fc99e Initial load duke parents: diff changeset	2365 manageable(bool, PrintClassHistogram, false, \
a61af66fc99e Initial load duke parents: diff changeset	2366 "Print a histogram of class instances") \
a61af66fc99e Initial load duke parents: diff changeset	2367 \
a61af66fc99e Initial load duke parents: diff changeset	2368 develop(bool, TraceWorkGang, false, \
a61af66fc99e Initial load duke parents: diff changeset	2369 "Trace activities of work gangs") \
a61af66fc99e Initial load duke parents: diff changeset	2370 \
a61af66fc99e Initial load duke parents: diff changeset	2371 product(bool, TraceParallelOldGCTasks, false, \
a61af66fc99e Initial load duke parents: diff changeset	2372 "Trace multithreaded GC activity") \
a61af66fc99e Initial load duke parents: diff changeset	2373 \
a61af66fc99e Initial load duke parents: diff changeset	2374 develop(bool, TraceBlockOffsetTable, false, \
a61af66fc99e Initial load duke parents: diff changeset	2375 "Print BlockOffsetTable maps") \
a61af66fc99e Initial load duke parents: diff changeset	2376 \
a61af66fc99e Initial load duke parents: diff changeset	2377 develop(bool, TraceCardTableModRefBS, false, \
a61af66fc99e Initial load duke parents: diff changeset	2378 "Print CardTableModRefBS maps") \
a61af66fc99e Initial load duke parents: diff changeset	2379 \
a61af66fc99e Initial load duke parents: diff changeset	2380 develop(bool, TraceGCTaskManager, false, \
a61af66fc99e Initial load duke parents: diff changeset	2381 "Trace actions of the GC task manager") \
a61af66fc99e Initial load duke parents: diff changeset	2382 \
a61af66fc99e Initial load duke parents: diff changeset	2383 develop(bool, TraceGCTaskQueue, false, \
a61af66fc99e Initial load duke parents: diff changeset	2384 "Trace actions of the GC task queues") \
a61af66fc99e Initial load duke parents: diff changeset	2385 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	2386 diagnostic(bool, TraceGCTaskThread, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	2387 "Trace actions of the GC task threads") \
a61af66fc99e Initial load duke parents: diff changeset	2388 \
a61af66fc99e Initial load duke parents: diff changeset	2389 product(bool, PrintParallelOldGCPhaseTimes, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2390 "Print the time taken by each phase in ParallelOldGC " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2391 "(PrintGCDetails must also be enabled)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2392 \
a61af66fc99e Initial load duke parents: diff changeset	2393 develop(bool, TraceParallelOldGCMarkingPhase, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2394 "Trace marking phase in ParallelOldGC") \
0 a61af66fc99e Initial load duke parents: diff changeset	2395 \
a61af66fc99e Initial load duke parents: diff changeset	2396 develop(bool, TraceParallelOldGCSummaryPhase, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2397 "Trace summary phase in ParallelOldGC") \
0 a61af66fc99e Initial load duke parents: diff changeset	2398 \
a61af66fc99e Initial load duke parents: diff changeset	2399 develop(bool, TraceParallelOldGCCompactionPhase, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2400 "Trace compaction phase in ParallelOldGC") \
0 a61af66fc99e Initial load duke parents: diff changeset	2401 \
a61af66fc99e Initial load duke parents: diff changeset	2402 develop(bool, TraceParallelOldGCDensePrefix, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2403 "Trace dense prefix computation for ParallelOldGC") \
0 a61af66fc99e Initial load duke parents: diff changeset	2404 \
a61af66fc99e Initial load duke parents: diff changeset	2405 develop(bool, IgnoreLibthreadGPFault, false, \
a61af66fc99e Initial load duke parents: diff changeset	2406 "Suppress workaround for libthread GP fault") \
a61af66fc99e Initial load duke parents: diff changeset	2407 \
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	2408 product(bool, PrintJNIGCStalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2409 "Print diagnostic message when GC is stalled " \
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	2410 "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	2411 \
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	2412 experimental(double, ObjectCountCutOffPercent, 0.5, \
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	2413 "The percentage of the used heap that the instances of a class " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2414 "must occupy for the class to generate a trace event") \
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	2415 \
3767 2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2416 /* GC log rotation setting */ \
2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2417 \
2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2418 product(bool, UseGCLogFileRotation, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2419 "Rotate gclog files (for long running applications). It requires "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2420 "-Xloggc:<filename>") \
3767 2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2421 \
2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2422 product(uintx, NumberOfGCLogFiles, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2423 "Number of gclog files in rotation " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2424 "(default: 0, no rotation)") \
3767 2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2425 \
2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2426 product(uintx, GCLogFileSize, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2427 "GC log file size (default: 0 bytes, no rotation). " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2428 "It requires UseGCLogFileRotation") \
3767 2a241e764894 6941923: RFE: Handling large log files produced by long running Java Applications minqi parents: 3418 diff changeset	2429 \
0 a61af66fc99e Initial load duke parents: diff changeset	2430 /* JVMTI heap profiling */ \
a61af66fc99e Initial load duke parents: diff changeset	2431 \
a61af66fc99e Initial load duke parents: diff changeset	2432 diagnostic(bool, TraceJVMTIObjectTagging, false, \
a61af66fc99e Initial load duke parents: diff changeset	2433 "Trace JVMTI object tagging calls") \
a61af66fc99e Initial load duke parents: diff changeset	2434 \
a61af66fc99e Initial load duke parents: diff changeset	2435 diagnostic(bool, VerifyBeforeIteration, false, \
a61af66fc99e Initial load duke parents: diff changeset	2436 "Verify memory system before JVMTI iteration") \
a61af66fc99e Initial load duke parents: diff changeset	2437 \
a61af66fc99e Initial load duke parents: diff changeset	2438 /* compiler interface */ \
a61af66fc99e Initial load duke parents: diff changeset	2439 \
a61af66fc99e Initial load duke parents: diff changeset	2440 develop(bool, CIPrintCompilerName, false, \
a61af66fc99e Initial load duke parents: diff changeset	2441 "when CIPrint is active, print the name of the active compiler") \
a61af66fc99e Initial load duke parents: diff changeset	2442 \
a61af66fc99e Initial load duke parents: diff changeset	2443 develop(bool, CIPrintCompileQueue, false, \
a61af66fc99e Initial load duke parents: diff changeset	2444 "display the contents of the compile queue whenever a " \
a61af66fc99e Initial load duke parents: diff changeset	2445 "compilation is enqueued") \
a61af66fc99e Initial load duke parents: diff changeset	2446 \
a61af66fc99e Initial load duke parents: diff changeset	2447 develop(bool, CIPrintRequests, false, \
a61af66fc99e Initial load duke parents: diff changeset	2448 "display every request for compilation") \
a61af66fc99e Initial load duke parents: diff changeset	2449 \
a61af66fc99e Initial load duke parents: diff changeset	2450 product(bool, CITime, false, \
a61af66fc99e Initial load duke parents: diff changeset	2451 "collect timing information for compilation") \
a61af66fc99e Initial load duke parents: diff changeset	2452 \
a61af66fc99e Initial load duke parents: diff changeset	2453 develop(bool, CITimeEach, false, \
a61af66fc99e Initial load duke parents: diff changeset	2454 "display timing information after each successful compilation") \
a61af66fc99e Initial load duke parents: diff changeset	2455 \
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6818 diff changeset	2456 develop(bool, CICountOSR, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	2457 "use a separate counter when assigning ids to osr compilations") \
a61af66fc99e Initial load duke parents: diff changeset	2458 \
a61af66fc99e Initial load duke parents: diff changeset	2459 develop(bool, CICompileNatives, true, \
a61af66fc99e Initial load duke parents: diff changeset	2460 "compile native methods if supported by the compiler") \
a61af66fc99e Initial load duke parents: diff changeset	2461 \
a61af66fc99e Initial load duke parents: diff changeset	2462 develop_pd(bool, CICompileOSR, \
a61af66fc99e Initial load duke parents: diff changeset	2463 "compile on stack replacement methods if supported by the " \
a61af66fc99e Initial load duke parents: diff changeset	2464 "compiler") \
a61af66fc99e Initial load duke parents: diff changeset	2465 \
a61af66fc99e Initial load duke parents: diff changeset	2466 develop(bool, CIPrintMethodCodes, false, \
a61af66fc99e Initial load duke parents: diff changeset	2467 "print method bytecodes of the compiled code") \
a61af66fc99e Initial load duke parents: diff changeset	2468 \
a61af66fc99e Initial load duke parents: diff changeset	2469 develop(bool, CIPrintTypeFlow, false, \
a61af66fc99e Initial load duke parents: diff changeset	2470 "print the results of ciTypeFlow analysis") \
a61af66fc99e Initial load duke parents: diff changeset	2471 \
a61af66fc99e Initial load duke parents: diff changeset	2472 develop(bool, CITraceTypeFlow, false, \
a61af66fc99e Initial load duke parents: diff changeset	2473 "detailed per-bytecode tracing of ciTypeFlow analysis") \
a61af66fc99e Initial load duke parents: diff changeset	2474 \
2403 1927db75dd85 7024475: loop doesn't terminate when compiled never parents: 2379 diff changeset	2475 develop(intx, OSROnlyBCI, -1, \
1927db75dd85 7024475: loop doesn't terminate when compiled never parents: 2379 diff changeset	2476 "OSR only at this bci. Negative values mean exclude that bci") \
1927db75dd85 7024475: loop doesn't terminate when compiled never parents: 2379 diff changeset	2477 \
0 a61af66fc99e Initial load duke parents: diff changeset	2478 /* compiler */ \
a61af66fc99e Initial load duke parents: diff changeset	2479 \
a61af66fc99e Initial load duke parents: diff changeset	2480 product(intx, CICompilerCount, CI_COMPILER_COUNT, \
a61af66fc99e Initial load duke parents: diff changeset	2481 "Number of compiler threads to run") \
a61af66fc99e Initial load duke parents: diff changeset	2482 \
a61af66fc99e Initial load duke parents: diff changeset	2483 product(intx, CompilationPolicyChoice, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2484 "which compilation policy (0/1)") \
a61af66fc99e Initial load duke parents: diff changeset	2485 \
a61af66fc99e Initial load duke parents: diff changeset	2486 develop(bool, UseStackBanging, true, \
a61af66fc99e Initial load duke parents: diff changeset	2487 "use stack banging for stack overflow checks (required for " \
a61af66fc99e Initial load duke parents: diff changeset	2488 "proper StackOverflow handling; disable only to measure cost " \
a61af66fc99e Initial load duke parents: diff changeset	2489 "of stackbanging)") \
a61af66fc99e Initial load duke parents: diff changeset	2490 \
a61af66fc99e Initial load duke parents: diff changeset	2491 develop(bool, UseStrictFP, true, \
a61af66fc99e Initial load duke parents: diff changeset	2492 "use strict fp if modifier strictfp is set") \
a61af66fc99e Initial load duke parents: diff changeset	2493 \
a61af66fc99e Initial load duke parents: diff changeset	2494 develop(bool, GenerateSynchronizationCode, true, \
a61af66fc99e Initial load duke parents: diff changeset	2495 "generate locking/unlocking code for synchronized methods and " \
a61af66fc99e Initial load duke parents: diff changeset	2496 "monitors") \
a61af66fc99e Initial load duke parents: diff changeset	2497 \
a61af66fc99e Initial load duke parents: diff changeset	2498 develop(bool, GenerateCompilerNullChecks, true, \
a61af66fc99e Initial load duke parents: diff changeset	2499 "Generate explicit null checks for loads/stores/calls") \
a61af66fc99e Initial load duke parents: diff changeset	2500 \
a61af66fc99e Initial load duke parents: diff changeset	2501 develop(bool, GenerateRangeChecks, true, \
a61af66fc99e Initial load duke parents: diff changeset	2502 "Generate range checks for array accesses") \
a61af66fc99e Initial load duke parents: diff changeset	2503 \
a61af66fc99e Initial load duke parents: diff changeset	2504 develop_pd(bool, ImplicitNullChecks, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2505 "Generate code for implicit null checks") \
0 a61af66fc99e Initial load duke parents: diff changeset	2506 \
a61af66fc99e Initial load duke parents: diff changeset	2507 product(bool, PrintSafepointStatistics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2508 "Print statistics about safepoint synchronization") \
0 a61af66fc99e Initial load duke parents: diff changeset	2509 \
a61af66fc99e Initial load duke parents: diff changeset	2510 product(intx, PrintSafepointStatisticsCount, 300, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2511 "Total number of safepoint statistics collected " \
0 a61af66fc99e Initial load duke parents: diff changeset	2512 "before printing them out") \
a61af66fc99e Initial load duke parents: diff changeset	2513 \
a61af66fc99e Initial load duke parents: diff changeset	2514 product(intx, PrintSafepointStatisticsTimeout, -1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2515 "Print safepoint statistics only when safepoint takes " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2516 "more than PrintSafepointSatisticsTimeout in millis") \
0 a61af66fc99e Initial load duke parents: diff changeset	2517 \
1321 0f6600cee529 6934758: Expose the break down of clean up task time during safepoint. xlu parents: 1288 diff changeset	2518 product(bool, TraceSafepointCleanupTime, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2519 "Print the break down of clean up tasks performed during " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2520 "safepoint") \
1321 0f6600cee529 6934758: Expose the break down of clean up task time during safepoint. xlu parents: 1288 diff changeset	2521 \
0 a61af66fc99e Initial load duke parents: diff changeset	2522 product(bool, Inline, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2523 "Enable inlining") \
0 a61af66fc99e Initial load duke parents: diff changeset	2524 \
a61af66fc99e Initial load duke parents: diff changeset	2525 product(bool, ClipInlining, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2526 "Clip inlining if aggregate method exceeds DesiredMethodLimit") \
0 a61af66fc99e Initial load duke parents: diff changeset	2527 \
a61af66fc99e Initial load duke parents: diff changeset	2528 develop(bool, UseCHA, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2529 "Enable CHA") \
0 a61af66fc99e Initial load duke parents: diff changeset	2530 \
a61af66fc99e Initial load duke parents: diff changeset	2531 product(bool, UseTypeProfile, true, \
a61af66fc99e Initial load duke parents: diff changeset	2532 "Check interpreter profile for historically monomorphic calls") \
a61af66fc99e Initial load duke parents: diff changeset	2533 \
a61af66fc99e Initial load duke parents: diff changeset	2534 notproduct(bool, TimeCompiler, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2535 "Time the compiler") \
0 a61af66fc99e Initial load duke parents: diff changeset	2536 \
a61af66fc99e Initial load duke parents: diff changeset	2537 diagnostic(bool, PrintInlining, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2538 "Print inlining optimizations") \
0 a61af66fc99e Initial load duke parents: diff changeset	2539 \
643 c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h twisti parents: 642 diff changeset	2540 product(bool, UsePopCountInstruction, false, \
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h twisti parents: 642 diff changeset	2541 "Use population count instruction") \
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h twisti parents: 642 diff changeset	2542 \
0 a61af66fc99e Initial load duke parents: diff changeset	2543 develop(bool, EagerInitialization, false, \
a61af66fc99e Initial load duke parents: diff changeset	2544 "Eagerly initialize classes if possible") \
a61af66fc99e Initial load duke parents: diff changeset	2545 \
a61af66fc99e Initial load duke parents: diff changeset	2546 develop(bool, TraceMethodReplacement, false, \
a61af66fc99e Initial load duke parents: diff changeset	2547 "Print when methods are replaced do to recompilation") \
a61af66fc99e Initial load duke parents: diff changeset	2548 \
a61af66fc99e Initial load duke parents: diff changeset	2549 develop(bool, PrintMethodFlushing, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2550 "Print the nmethods being flushed") \
0 a61af66fc99e Initial load duke parents: diff changeset	2551 \
a61af66fc99e Initial load duke parents: diff changeset	2552 develop(bool, UseRelocIndex, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2553 "Use an index to speed random access to relocations") \
0 a61af66fc99e Initial load duke parents: diff changeset	2554 \
a61af66fc99e Initial load duke parents: diff changeset	2555 develop(bool, StressCodeBuffers, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2556 "Exercise code buffer expansion and other rare state changes") \
0 a61af66fc99e Initial load duke parents: diff changeset	2557 \
a61af66fc99e Initial load duke parents: diff changeset	2558 diagnostic(bool, DebugNonSafepoints, trueInDebug, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2559 "Generate extra debugging information for non-safepoints in " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2560 "nmethods") \
0 a61af66fc99e Initial load duke parents: diff changeset	2561 \
4066 3c7d67df8d07 7108264: Fix for 7104173 is insufficient dholmes parents: 4031 diff changeset	2562 product(bool, PrintVMOptions, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2563 "Print flags that appeared on the command line") \
0 a61af66fc99e Initial load duke parents: diff changeset	2564 \
564 323728917cf4 6788376: allow to ignore unrecognized VM options kvn parents: 484 diff changeset	2565 product(bool, IgnoreUnrecognizedVMOptions, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2566 "Ignore unrecognized VM options") \
564 323728917cf4 6788376: allow to ignore unrecognized VM options kvn parents: 484 diff changeset	2567 \
1150 f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2568 product(bool, PrintCommandLineFlags, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2569 "Print flags specified on command line or set by ergonomics") \
1150 f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2570 \
f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2571 product(bool, PrintFlagsInitial, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2572 "Print all VM flags before argument processing and exit VM") \
1150 f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2573 \
f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2574 product(bool, PrintFlagsFinal, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2575 "Print all VM flags after argument and ergonomic processing") \
1150 f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1119 diff changeset	2576 \
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1749 diff changeset	2577 notproduct(bool, PrintFlagsWithComments, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2578 "Print all VM flags with default values and descriptions and " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2579 "exit") \
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1749 diff changeset	2580 \
0 a61af66fc99e Initial load duke parents: diff changeset	2581 diagnostic(bool, SerializeVMOutput, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2582 "Use a mutex to serialize output to tty and LogFile") \
0 a61af66fc99e Initial load duke parents: diff changeset	2583 \
a61af66fc99e Initial load duke parents: diff changeset	2584 diagnostic(bool, DisplayVMOutput, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2585 "Display all VM output on the tty, independently of LogVMOutput") \
0 a61af66fc99e Initial load duke parents: diff changeset	2586 \
12257 01b268b3080a 8023134: Rename VM LogFile to hotspot_pid{pid}.log (was hotspot.log) vlivanov parents: 12190 diff changeset	2587 diagnostic(bool, LogVMOutput, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2588 "Save VM output to LogFile") \
0 a61af66fc99e Initial load duke parents: diff changeset	2589 \
a61af66fc99e Initial load duke parents: diff changeset	2590 diagnostic(ccstr, LogFile, NULL, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2591 "If LogVMOutput or LogCompilation is on, save VM output to " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2592 "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)")\
0 a61af66fc99e Initial load duke parents: diff changeset	2593 \
a61af66fc99e Initial load duke parents: diff changeset	2594 product(ccstr, ErrorFile, NULL, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2595 "If an error occurs, save the error data to this file " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2596 "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2597 \
a61af66fc99e Initial load duke parents: diff changeset	2598 product(bool, DisplayVMOutputToStderr, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2599 "If DisplayVMOutput is true, display all VM output to stderr") \
0 a61af66fc99e Initial load duke parents: diff changeset	2600 \
a61af66fc99e Initial load duke parents: diff changeset	2601 product(bool, DisplayVMOutputToStdout, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2602 "If DisplayVMOutput is true, display all VM output to stdout") \
0 a61af66fc99e Initial load duke parents: diff changeset	2603 \
a61af66fc99e Initial load duke parents: diff changeset	2604 product(bool, UseHeavyMonitors, false, \
a61af66fc99e Initial load duke parents: diff changeset	2605 "use heavyweight instead of lightweight Java monitors") \
a61af66fc99e Initial load duke parents: diff changeset	2606 \
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 6109 diff changeset	2607 product(bool, PrintStringTableStatistics, false, \
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 6109 diff changeset	2608 "print statistics about the StringTable and SymbolTable") \
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 6109 diff changeset	2609 \
12275 63147986a428 8019835: Strings interned in different threads equal but does not == dcubed parents: 12190 diff changeset	2610 diagnostic(bool, VerifyStringTableAtExit, false, \
63147986a428 8019835: Strings interned in different threads equal but does not == dcubed parents: 12190 diff changeset	2611 "verify StringTable contents at exit") \
63147986a428 8019835: Strings interned in different threads equal but does not == dcubed parents: 12190 diff changeset	2612 \
0 a61af66fc99e Initial load duke parents: diff changeset	2613 notproduct(bool, PrintSymbolTableSizeHistogram, false, \
a61af66fc99e Initial load duke parents: diff changeset	2614 "print histogram of the symbol table") \
a61af66fc99e Initial load duke parents: diff changeset	2615 \
a61af66fc99e Initial load duke parents: diff changeset	2616 notproduct(bool, ExitVMOnVerifyError, false, \
a61af66fc99e Initial load duke parents: diff changeset	2617 "standard exit from VM if bytecode verify error " \
a61af66fc99e Initial load duke parents: diff changeset	2618 "(only in debug mode)") \
a61af66fc99e Initial load duke parents: diff changeset	2619 \
a61af66fc99e Initial load duke parents: diff changeset	2620 notproduct(ccstr, AbortVMOnException, NULL, \
a61af66fc99e Initial load duke parents: diff changeset	2621 "Call fatal if this exception is thrown. Example: " \
a61af66fc99e Initial load duke parents: diff changeset	2622 "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
a61af66fc99e Initial load duke parents: diff changeset	2623 \
1684 66c5dadb4d61 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path() kvn parents: 1660 diff changeset	2624 notproduct(ccstr, AbortVMOnExceptionMessage, NULL, \
66c5dadb4d61 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path() kvn parents: 1660 diff changeset	2625 "Call fatal if the exception pointed by AbortVMOnException " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2626 "has this message") \
1684 66c5dadb4d61 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path() kvn parents: 1660 diff changeset	2627 \
0 a61af66fc99e Initial load duke parents: diff changeset	2628 develop(bool, DebugVtables, false, \
a61af66fc99e Initial load duke parents: diff changeset	2629 "add debugging code to vtable dispatch") \
a61af66fc99e Initial load duke parents: diff changeset	2630 \
a61af66fc99e Initial load duke parents: diff changeset	2631 develop(bool, PrintVtables, false, \
a61af66fc99e Initial load duke parents: diff changeset	2632 "print vtables when printing klass") \
a61af66fc99e Initial load duke parents: diff changeset	2633 \
a61af66fc99e Initial load duke parents: diff changeset	2634 notproduct(bool, PrintVtableStats, false, \
a61af66fc99e Initial load duke parents: diff changeset	2635 "print vtables stats at end of run") \
a61af66fc99e Initial load duke parents: diff changeset	2636 \
a61af66fc99e Initial load duke parents: diff changeset	2637 develop(bool, TraceCreateZombies, false, \
a61af66fc99e Initial load duke parents: diff changeset	2638 "trace creation of zombie nmethods") \
a61af66fc99e Initial load duke parents: diff changeset	2639 \
a61af66fc99e Initial load duke parents: diff changeset	2640 notproduct(bool, IgnoreLockingAssertions, false, \
a61af66fc99e Initial load duke parents: diff changeset	2641 "disable locking assertions (for speed)") \
a61af66fc99e Initial load duke parents: diff changeset	2642 \
a61af66fc99e Initial load duke parents: diff changeset	2643 product(bool, RangeCheckElimination, true, \
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8706 diff changeset	2644 "Eliminate range checks") \
0 a61af66fc99e Initial load duke parents: diff changeset	2645 \
a61af66fc99e Initial load duke parents: diff changeset	2646 develop_pd(bool, UncommonNullCast, \
a61af66fc99e Initial load duke parents: diff changeset	2647 "track occurrences of null in casts; adjust compiler tactics") \
a61af66fc99e Initial load duke parents: diff changeset	2648 \
a61af66fc99e Initial load duke parents: diff changeset	2649 develop(bool, TypeProfileCasts, true, \
a61af66fc99e Initial load duke parents: diff changeset	2650 "treat casts like calls for purposes of type profiling") \
a61af66fc99e Initial load duke parents: diff changeset	2651 \
a61af66fc99e Initial load duke parents: diff changeset	2652 develop(bool, DelayCompilationDuringStartup, true, \
a61af66fc99e Initial load duke parents: diff changeset	2653 "Delay invoking the compiler until main application class is " \
a61af66fc99e Initial load duke parents: diff changeset	2654 "loaded") \
a61af66fc99e Initial load duke parents: diff changeset	2655 \
a61af66fc99e Initial load duke parents: diff changeset	2656 develop(bool, CompileTheWorld, false, \
a61af66fc99e Initial load duke parents: diff changeset	2657 "Compile all methods in all classes in bootstrap class path " \
a61af66fc99e Initial load duke parents: diff changeset	2658 "(stress test)") \
a61af66fc99e Initial load duke parents: diff changeset	2659 \
a61af66fc99e Initial load duke parents: diff changeset	2660 develop(bool, CompileTheWorldPreloadClasses, true, \
a61af66fc99e Initial load duke parents: diff changeset	2661 "Preload all classes used by a class before start loading") \
a61af66fc99e Initial load duke parents: diff changeset	2662 \
1188 99af867dfa05 6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld kvn parents: 1179 diff changeset	2663 notproduct(intx, CompileTheWorldSafepointInterval, 100, \
99af867dfa05 6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld kvn parents: 1179 diff changeset	2664 "Force a safepoint every n compiles so sweeper can keep up") \
99af867dfa05 6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld kvn parents: 1179 diff changeset	2665 \
0 a61af66fc99e Initial load duke parents: diff changeset	2666 develop(bool, FillDelaySlots, true, \
a61af66fc99e Initial load duke parents: diff changeset	2667 "Fill delay slots (on SPARC only)") \
a61af66fc99e Initial load duke parents: diff changeset	2668 \
a61af66fc99e Initial load duke parents: diff changeset	2669 develop(bool, TimeLivenessAnalysis, false, \
a61af66fc99e Initial load duke parents: diff changeset	2670 "Time computation of bytecode liveness analysis") \
a61af66fc99e Initial load duke parents: diff changeset	2671 \
a61af66fc99e Initial load duke parents: diff changeset	2672 develop(bool, TraceLivenessGen, false, \
a61af66fc99e Initial load duke parents: diff changeset	2673 "Trace the generation of liveness analysis information") \
a61af66fc99e Initial load duke parents: diff changeset	2674 \
a61af66fc99e Initial load duke parents: diff changeset	2675 notproduct(bool, TraceLivenessQuery, false, \
a61af66fc99e Initial load duke parents: diff changeset	2676 "Trace queries of liveness analysis information") \
a61af66fc99e Initial load duke parents: diff changeset	2677 \
a61af66fc99e Initial load duke parents: diff changeset	2678 notproduct(bool, CollectIndexSetStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	2679 "Collect information about IndexSets") \
a61af66fc99e Initial load duke parents: diff changeset	2680 \
a61af66fc99e Initial load duke parents: diff changeset	2681 develop(bool, UseLoopSafepoints, true, \
a61af66fc99e Initial load duke parents: diff changeset	2682 "Generate Safepoint nodes in every loop") \
a61af66fc99e Initial load duke parents: diff changeset	2683 \
a61af66fc99e Initial load duke parents: diff changeset	2684 develop(intx, FastAllocateSizeLimit, 128*K, \
a61af66fc99e Initial load duke parents: diff changeset	2685 /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ \
a61af66fc99e Initial load duke parents: diff changeset	2686 "Inline allocations larger than this in doublewords must go slow")\
a61af66fc99e Initial load duke parents: diff changeset	2687 \
a61af66fc99e Initial load duke parents: diff changeset	2688 product(bool, AggressiveOpts, false, \
a61af66fc99e Initial load duke parents: diff changeset	2689 "Enable aggressive optimizations - see arguments.cpp") \
a61af66fc99e Initial load duke parents: diff changeset	2690 \
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12326 diff changeset	2691 product_pd(uintx, TypeProfileLevel, \
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2692 "=XYZ, with Z: Type profiling of arguments at call; " \
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2693 "Y: Type profiling of return value at call; " \
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2694 "X: Type profiling of parameters to methods; " \
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2695 "X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods") \
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12326 diff changeset	2696 \
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12326 diff changeset	2697 product(intx, TypeProfileArgsLimit, 2, \
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12326 diff changeset	2698 "max number of call arguments to consider for type profiling") \
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12326 diff changeset	2699 \
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2700 product(intx, TypeProfileParmsLimit, 2, \
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2701 "max number of incoming parameters to consider for type profiling"\
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2702 ", -1 for all") \
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12908 diff changeset	2703 \
0 a61af66fc99e Initial load duke parents: diff changeset	2704 /* statistics */ \
a61af66fc99e Initial load duke parents: diff changeset	2705 develop(bool, CountCompiledCalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2706 "Count method invocations") \
0 a61af66fc99e Initial load duke parents: diff changeset	2707 \
a61af66fc99e Initial load duke parents: diff changeset	2708 notproduct(bool, CountRuntimeCalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2709 "Count VM runtime calls") \
0 a61af66fc99e Initial load duke parents: diff changeset	2710 \
a61af66fc99e Initial load duke parents: diff changeset	2711 develop(bool, CountJNICalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2712 "Count jni method invocations") \
0 a61af66fc99e Initial load duke parents: diff changeset	2713 \
a61af66fc99e Initial load duke parents: diff changeset	2714 notproduct(bool, CountJVMCalls, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2715 "Count jvm method invocations") \
0 a61af66fc99e Initial load duke parents: diff changeset	2716 \
a61af66fc99e Initial load duke parents: diff changeset	2717 notproduct(bool, CountRemovableExceptions, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2718 "Count exceptions that could be replaced by branches due to " \
0 a61af66fc99e Initial load duke parents: diff changeset	2719 "inlining") \
a61af66fc99e Initial load duke parents: diff changeset	2720 \
a61af66fc99e Initial load duke parents: diff changeset	2721 notproduct(bool, ICMissHistogram, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2722 "Produce histogram of IC misses") \
0 a61af66fc99e Initial load duke parents: diff changeset	2723 \
a61af66fc99e Initial load duke parents: diff changeset	2724 notproduct(bool, PrintClassStatistics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2725 "Print class statistics at end of run") \
0 a61af66fc99e Initial load duke parents: diff changeset	2726 \
a61af66fc99e Initial load duke parents: diff changeset	2727 notproduct(bool, PrintMethodStatistics, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2728 "Print method statistics at end of run") \
0 a61af66fc99e Initial load duke parents: diff changeset	2729 \
a61af66fc99e Initial load duke parents: diff changeset	2730 /* interpreter */ \
a61af66fc99e Initial load duke parents: diff changeset	2731 develop(bool, ClearInterpreterLocals, false, \
a61af66fc99e Initial load duke parents: diff changeset	2732 "Always clear local variables of interpreter activations upon " \
a61af66fc99e Initial load duke parents: diff changeset	2733 "entry") \
a61af66fc99e Initial load duke parents: diff changeset	2734 \
a61af66fc99e Initial load duke parents: diff changeset	2735 product_pd(bool, RewriteBytecodes, \
a61af66fc99e Initial load duke parents: diff changeset	2736 "Allow rewriting of bytecodes (bytecodes are not immutable)") \
a61af66fc99e Initial load duke parents: diff changeset	2737 \
a61af66fc99e Initial load duke parents: diff changeset	2738 product_pd(bool, RewriteFrequentPairs, \
a61af66fc99e Initial load duke parents: diff changeset	2739 "Rewrite frequently used bytecode pairs into a single bytecode") \
a61af66fc99e Initial load duke parents: diff changeset	2740 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	2741 diagnostic(bool, PrintInterpreter, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2742 "Print the generated interpreter code") \
0 a61af66fc99e Initial load duke parents: diff changeset	2743 \
a61af66fc99e Initial load duke parents: diff changeset	2744 product(bool, UseInterpreter, true, \
a61af66fc99e Initial load duke parents: diff changeset	2745 "Use interpreter for non-compiled methods") \
a61af66fc99e Initial load duke parents: diff changeset	2746 \
a61af66fc99e Initial load duke parents: diff changeset	2747 develop(bool, UseFastSignatureHandlers, true, \
a61af66fc99e Initial load duke parents: diff changeset	2748 "Use fast signature handlers for native calls") \
a61af66fc99e Initial load duke parents: diff changeset	2749 \
a61af66fc99e Initial load duke parents: diff changeset	2750 product(bool, UseLoopCounter, true, \
a61af66fc99e Initial load duke parents: diff changeset	2751 "Increment invocation counter on backward branch") \
a61af66fc99e Initial load duke parents: diff changeset	2752 \
a61af66fc99e Initial load duke parents: diff changeset	2753 product(bool, UseFastEmptyMethods, true, \
a61af66fc99e Initial load duke parents: diff changeset	2754 "Use fast method entry code for empty methods") \
a61af66fc99e Initial load duke parents: diff changeset	2755 \
a61af66fc99e Initial load duke parents: diff changeset	2756 product(bool, UseFastAccessorMethods, true, \
a61af66fc99e Initial load duke parents: diff changeset	2757 "Use fast method entry code for accessor methods") \
a61af66fc99e Initial load duke parents: diff changeset	2758 \
a61af66fc99e Initial load duke parents: diff changeset	2759 product_pd(bool, UseOnStackReplacement, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2760 "Use on stack replacement, calls runtime if invoc. counter " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2761 "overflows in loop") \
0 a61af66fc99e Initial load duke parents: diff changeset	2762 \
a61af66fc99e Initial load duke parents: diff changeset	2763 notproduct(bool, TraceOnStackReplacement, false, \
a61af66fc99e Initial load duke parents: diff changeset	2764 "Trace on stack replacement") \
a61af66fc99e Initial load duke parents: diff changeset	2765 \
a61af66fc99e Initial load duke parents: diff changeset	2766 product_pd(bool, PreferInterpreterNativeStubs, \
a61af66fc99e Initial load duke parents: diff changeset	2767 "Use always interpreter stubs for native methods invoked via " \
a61af66fc99e Initial load duke parents: diff changeset	2768 "interpreter") \
a61af66fc99e Initial load duke parents: diff changeset	2769 \
a61af66fc99e Initial load duke parents: diff changeset	2770 develop(bool, CountBytecodes, false, \
a61af66fc99e Initial load duke parents: diff changeset	2771 "Count number of bytecodes executed") \
a61af66fc99e Initial load duke parents: diff changeset	2772 \
a61af66fc99e Initial load duke parents: diff changeset	2773 develop(bool, PrintBytecodeHistogram, false, \
a61af66fc99e Initial load duke parents: diff changeset	2774 "Print histogram of the executed bytecodes") \
a61af66fc99e Initial load duke parents: diff changeset	2775 \
a61af66fc99e Initial load duke parents: diff changeset	2776 develop(bool, PrintBytecodePairHistogram, false, \
a61af66fc99e Initial load duke parents: diff changeset	2777 "Print histogram of the executed bytecode pairs") \
a61af66fc99e Initial load duke parents: diff changeset	2778 \
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 76 diff changeset	2779 diagnostic(bool, PrintSignatureHandlers, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	2780 "Print code generated for native method signature handlers") \
a61af66fc99e Initial load duke parents: diff changeset	2781 \
a61af66fc99e Initial load duke parents: diff changeset	2782 develop(bool, VerifyOops, false, \
a61af66fc99e Initial load duke parents: diff changeset	2783 "Do plausibility checks for oops") \
a61af66fc99e Initial load duke parents: diff changeset	2784 \
a61af66fc99e Initial load duke parents: diff changeset	2785 develop(bool, CheckUnhandledOops, false, \
a61af66fc99e Initial load duke parents: diff changeset	2786 "Check for unhandled oops in VM code") \
a61af66fc99e Initial load duke parents: diff changeset	2787 \
a61af66fc99e Initial load duke parents: diff changeset	2788 develop(bool, VerifyJNIFields, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	2789 "Verify jfieldIDs for instance fields") \
a61af66fc99e Initial load duke parents: diff changeset	2790 \
a61af66fc99e Initial load duke parents: diff changeset	2791 notproduct(bool, VerifyJNIEnvThread, false, \
a61af66fc99e Initial load duke parents: diff changeset	2792 "Verify JNIEnv.thread == Thread::current() when entering VM " \
a61af66fc99e Initial load duke parents: diff changeset	2793 "from JNI") \
a61af66fc99e Initial load duke parents: diff changeset	2794 \
a61af66fc99e Initial load duke parents: diff changeset	2795 develop(bool, VerifyFPU, false, \
a61af66fc99e Initial load duke parents: diff changeset	2796 "Verify FPU state (check for NaN's, etc.)") \
a61af66fc99e Initial load duke parents: diff changeset	2797 \
a61af66fc99e Initial load duke parents: diff changeset	2798 develop(bool, VerifyThread, false, \
a61af66fc99e Initial load duke parents: diff changeset	2799 "Watch the thread register for corruption (SPARC only)") \
a61af66fc99e Initial load duke parents: diff changeset	2800 \
a61af66fc99e Initial load duke parents: diff changeset	2801 develop(bool, VerifyActivationFrameSize, false, \
a61af66fc99e Initial load duke parents: diff changeset	2802 "Verify that activation frame didn't become smaller than its " \
a61af66fc99e Initial load duke parents: diff changeset	2803 "minimal size") \
a61af66fc99e Initial load duke parents: diff changeset	2804 \
a61af66fc99e Initial load duke parents: diff changeset	2805 develop(bool, TraceFrequencyInlining, false, \
a61af66fc99e Initial load duke parents: diff changeset	2806 "Trace frequency based inlining") \
a61af66fc99e Initial load duke parents: diff changeset	2807 \
a61af66fc99e Initial load duke parents: diff changeset	2808 develop_pd(bool, InlineIntrinsics, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2809 "Inline intrinsics that can be statically resolved") \
0 a61af66fc99e Initial load duke parents: diff changeset	2810 \
a61af66fc99e Initial load duke parents: diff changeset	2811 product_pd(bool, ProfileInterpreter, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2812 "Profile at the bytecode level during interpretation") \
0 a61af66fc99e Initial load duke parents: diff changeset	2813 \
a61af66fc99e Initial load duke parents: diff changeset	2814 develop_pd(bool, ProfileTraps, \
a61af66fc99e Initial load duke parents: diff changeset	2815 "Profile deoptimization traps at the bytecode level") \
a61af66fc99e Initial load duke parents: diff changeset	2816 \
a61af66fc99e Initial load duke parents: diff changeset	2817 product(intx, ProfileMaturityPercentage, 20, \
a61af66fc99e Initial load duke parents: diff changeset	2818 "number of method invocations/branches (expressed as % of " \
a61af66fc99e Initial load duke parents: diff changeset	2819 "CompileThreshold) before using the method's profile") \
a61af66fc99e Initial load duke parents: diff changeset	2820 \
a61af66fc99e Initial load duke parents: diff changeset	2821 develop(bool, PrintMethodData, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2822 "Print the results of +ProfileInterpreter at end of run") \
0 a61af66fc99e Initial load duke parents: diff changeset	2823 \
a61af66fc99e Initial load duke parents: diff changeset	2824 develop(bool, VerifyDataPointer, trueInDebug, \
a61af66fc99e Initial load duke parents: diff changeset	2825 "Verify the method data pointer during interpreter profiling") \
a61af66fc99e Initial load duke parents: diff changeset	2826 \
a61af66fc99e Initial load duke parents: diff changeset	2827 develop(bool, VerifyCompiledCode, false, \
a61af66fc99e Initial load duke parents: diff changeset	2828 "Include miscellaneous runtime verifications in nmethod code; " \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	2829 "default off because it disturbs nmethod size heuristics") \
0 a61af66fc99e Initial load duke parents: diff changeset	2830 \
1119 547f81740344 6361589: Print out stack trace for target thread of GC crash minqi parents: 1064 diff changeset	2831 notproduct(bool, CrashGCForDumpingJavaThread, false, \
547f81740344 6361589: Print out stack trace for target thread of GC crash minqi parents: 1064 diff changeset	2832 "Manually make GC thread crash then dump java stack trace; " \
547f81740344 6361589: Print out stack trace for target thread of GC crash minqi parents: 1064 diff changeset	2833 "Test only") \
0 a61af66fc99e Initial load duke parents: diff changeset	2834 \
a61af66fc99e Initial load duke parents: diff changeset	2835 /* compilation */ \
a61af66fc99e Initial load duke parents: diff changeset	2836 product(bool, UseCompiler, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2837 "Use Just-In-Time compilation") \
0 a61af66fc99e Initial load duke parents: diff changeset	2838 \
a61af66fc99e Initial load duke parents: diff changeset	2839 develop(bool, TraceCompilationPolicy, false, \
a61af66fc99e Initial load duke parents: diff changeset	2840 "Trace compilation policy") \
a61af66fc99e Initial load duke parents: diff changeset	2841 \
a61af66fc99e Initial load duke parents: diff changeset	2842 develop(bool, TimeCompilationPolicy, false, \
a61af66fc99e Initial load duke parents: diff changeset	2843 "Time the compilation policy") \
a61af66fc99e Initial load duke parents: diff changeset	2844 \
a61af66fc99e Initial load duke parents: diff changeset	2845 product(bool, UseCounterDecay, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2846 "Adjust recompilation counters") \
0 a61af66fc99e Initial load duke parents: diff changeset	2847 \
a61af66fc99e Initial load duke parents: diff changeset	2848 develop(intx, CounterHalfLifeTime, 30, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2849 "Half-life time of invocation counters (in seconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2850 \
a61af66fc99e Initial load duke parents: diff changeset	2851 develop(intx, CounterDecayMinIntervalLength, 500, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2852 "The minimum interval (in milliseconds) between invocation of " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2853 "CounterDecay") \
0 a61af66fc99e Initial load duke parents: diff changeset	2854 \
a61af66fc99e Initial load duke parents: diff changeset	2855 product(bool, AlwaysCompileLoopMethods, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2856 "When using recompilation, never interpret methods " \
0 a61af66fc99e Initial load duke parents: diff changeset	2857 "containing loops") \
a61af66fc99e Initial load duke parents: diff changeset	2858 \
a61af66fc99e Initial load duke parents: diff changeset	2859 product(bool, DontCompileHugeMethods, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2860 "Do not compile methods > HugeMethodLimit") \
0 a61af66fc99e Initial load duke parents: diff changeset	2861 \
a61af66fc99e Initial load duke parents: diff changeset	2862 /* Bytecode escape analysis estimation. */ \
a61af66fc99e Initial load duke parents: diff changeset	2863 product(bool, EstimateArgEscape, true, \
a61af66fc99e Initial load duke parents: diff changeset	2864 "Analyze bytecodes to estimate escape state of arguments") \
a61af66fc99e Initial load duke parents: diff changeset	2865 \
a61af66fc99e Initial load duke parents: diff changeset	2866 product(intx, BCEATraceLevel, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2867 "How much tracing to do of bytecode escape analysis estimates") \
a61af66fc99e Initial load duke parents: diff changeset	2868 \
a61af66fc99e Initial load duke parents: diff changeset	2869 product(intx, MaxBCEAEstimateLevel, 5, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2870 "Maximum number of nested calls that are analyzed by BC EA") \
0 a61af66fc99e Initial load duke parents: diff changeset	2871 \
a61af66fc99e Initial load duke parents: diff changeset	2872 product(intx, MaxBCEAEstimateSize, 150, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2873 "Maximum bytecode size of a method to be analyzed by BC EA") \
0 a61af66fc99e Initial load duke parents: diff changeset	2874 \
a61af66fc99e Initial load duke parents: diff changeset	2875 product(intx, AllocatePrefetchStyle, 1, \
a61af66fc99e Initial load duke parents: diff changeset	2876 "0 = no prefetch, " \
a61af66fc99e Initial load duke parents: diff changeset	2877 "1 = prefetch instructions for each allocation, " \
1367 9e321dcfa5b7 6940726: Use BIS instruction for allocation prefetch on Sparc kvn parents: 1366 diff changeset	2878 "2 = use TLAB watermark to gate allocation prefetch, " \
9e321dcfa5b7 6940726: Use BIS instruction for allocation prefetch on Sparc kvn parents: 1366 diff changeset	2879 "3 = use BIS instruction on Sparc for allocation prefetch") \
0 a61af66fc99e Initial load duke parents: diff changeset	2880 \
a61af66fc99e Initial load duke parents: diff changeset	2881 product(intx, AllocatePrefetchDistance, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2882 "Distance to prefetch ahead of allocation pointer") \
a61af66fc99e Initial load duke parents: diff changeset	2883 \
3854 1af104d6cf99 7079329: Adjust allocation prefetching for T4 kvn parents: 3839 diff changeset	2884 product(intx, AllocatePrefetchLines, 3, \
1af104d6cf99 7079329: Adjust allocation prefetching for T4 kvn parents: 3839 diff changeset	2885 "Number of lines to prefetch ahead of array allocation pointer") \
1af104d6cf99 7079329: Adjust allocation prefetching for T4 kvn parents: 3839 diff changeset	2886 \
1af104d6cf99 7079329: Adjust allocation prefetching for T4 kvn parents: 3839 diff changeset	2887 product(intx, AllocateInstancePrefetchLines, 1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2888 "Number of lines to prefetch ahead of instance allocation " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2889 "pointer") \
0 a61af66fc99e Initial load duke parents: diff changeset	2890 \
a61af66fc99e Initial load duke parents: diff changeset	2891 product(intx, AllocatePrefetchStepSize, 16, \
a61af66fc99e Initial load duke parents: diff changeset	2892 "Step size in bytes of sequential prefetch instructions") \
a61af66fc99e Initial load duke parents: diff changeset	2893 \
a61af66fc99e Initial load duke parents: diff changeset	2894 product(intx, AllocatePrefetchInstr, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2895 "Prefetch instruction to prefetch ahead of allocation pointer") \
a61af66fc99e Initial load duke parents: diff changeset	2896 \
a61af66fc99e Initial load duke parents: diff changeset	2897 /* deoptimization */ \
2607 008adfd6d850 Fixed the stateBefore of invokes and monitorenter instructions to include the arguments of the instruction. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 2492 diff changeset	2898 product(bool, TraceDeoptimization, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	2899 "Trace deoptimization") \
a61af66fc99e Initial load duke parents: diff changeset	2900 \
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4561 diff changeset	2901 product(bool, PrintDeoptimizationDetails, false, \
3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4561 diff changeset	2902 "Print more information about deoptimization") \
3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4561 diff changeset	2903 \
0 a61af66fc99e Initial load duke parents: diff changeset	2904 develop(bool, DebugDeoptimization, false, \
a61af66fc99e Initial load duke parents: diff changeset	2905 "Tracing various information while debugging deoptimization") \
a61af66fc99e Initial load duke parents: diff changeset	2906 \
a61af66fc99e Initial load duke parents: diff changeset	2907 product(intx, SelfDestructTimer, 0, \
a61af66fc99e Initial load duke parents: diff changeset	2908 "Will cause VM to terminate after a given time (in minutes) " \
a61af66fc99e Initial load duke parents: diff changeset	2909 "(0 means off)") \
a61af66fc99e Initial load duke parents: diff changeset	2910 \
a61af66fc99e Initial load duke parents: diff changeset	2911 product(intx, MaxJavaStackTraceDepth, 1024, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2912 "The maximum number of lines in the stack trace for Java " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2913 "exceptions (0 means all)") \
0 a61af66fc99e Initial load duke parents: diff changeset	2914 \
3328 277d0f6ca64d 7005503: Make GuaranteedSafepointInterval a diagnostic flag kevinw parents: 3255 diff changeset	2915 NOT_EMBEDDED(diagnostic(intx, GuaranteedSafepointInterval, 1000, \
0 a61af66fc99e Initial load duke parents: diff changeset	2916 "Guarantee a safepoint (at least) every so many milliseconds " \
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2917 "(0 means none)")) \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2918 \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2919 EMBEDDED_ONLY(product(intx, GuaranteedSafepointInterval, 0, \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2920 "Guarantee a safepoint (at least) every so many milliseconds " \
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	2921 "(0 means none)")) \
0 a61af66fc99e Initial load duke parents: diff changeset	2922 \
a61af66fc99e Initial load duke parents: diff changeset	2923 product(intx, SafepointTimeoutDelay, 10000, \
a61af66fc99e Initial load duke parents: diff changeset	2924 "Delay in milliseconds for option SafepointTimeout") \
a61af66fc99e Initial load duke parents: diff changeset	2925 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	2926 product(intx, NmethodSweepFraction, 16, \
0 a61af66fc99e Initial load duke parents: diff changeset	2927 "Number of invocations of sweeper to cover all nmethods") \
a61af66fc99e Initial load duke parents: diff changeset	2928 \
1538 bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1513 diff changeset	2929 product(intx, NmethodSweepCheckInterval, 5, \
bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1513 diff changeset	2930 "Compilers wake up every n seconds to possibly sweep nmethods") \
bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1513 diff changeset	2931 \
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12322 diff changeset	2932 product(intx, NmethodSweepActivity, 10, \
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12322 diff changeset	2933 "Removes cold nmethods from code cache if > 0. Higher values " \
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12322 diff changeset	2934 "result in more aggressive sweeping") \
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12322 diff changeset	2935 \
3384 f52ed367b66d 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify never parents: 3373 diff changeset	2936 notproduct(bool, LogSweeper, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2937 "Keep a ring buffer of sweeper activity") \
3384 f52ed367b66d 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify never parents: 3373 diff changeset	2938 \
f52ed367b66d 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify never parents: 3373 diff changeset	2939 notproduct(intx, SweeperLogEntries, 1024, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2940 "Number of records in the ring buffer of sweeper activity") \
3384 f52ed367b66d 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify never parents: 3373 diff changeset	2941 \
0 a61af66fc99e Initial load duke parents: diff changeset	2942 notproduct(intx, MemProfilingInterval, 500, \
a61af66fc99e Initial load duke parents: diff changeset	2943 "Time between each invocation of the MemProfiler") \
a61af66fc99e Initial load duke parents: diff changeset	2944 \
a61af66fc99e Initial load duke parents: diff changeset	2945 develop(intx, MallocCatchPtr, -1, \
a61af66fc99e Initial load duke parents: diff changeset	2946 "Hit breakpoint when mallocing/freeing this pointer") \
a61af66fc99e Initial load duke parents: diff changeset	2947 \
a61af66fc99e Initial load duke parents: diff changeset	2948 notproduct(intx, AssertRepeat, 1, \
a61af66fc99e Initial load duke parents: diff changeset	2949 "number of times to evaluate expression in assert " \
a61af66fc99e Initial load duke parents: diff changeset	2950 "(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS") \
a61af66fc99e Initial load duke parents: diff changeset	2951 \
a61af66fc99e Initial load duke parents: diff changeset	2952 notproduct(ccstrlist, SuppressErrorAt, "", \
a61af66fc99e Initial load duke parents: diff changeset	2953 "List of assertions (file:line) to muzzle") \
a61af66fc99e Initial load duke parents: diff changeset	2954 \
a61af66fc99e Initial load duke parents: diff changeset	2955 notproduct(uintx, HandleAllocationLimit, 1024, \
a61af66fc99e Initial load duke parents: diff changeset	2956 "Threshold for HandleMark allocation when +TraceHandleAllocation "\
a61af66fc99e Initial load duke parents: diff changeset	2957 "is used") \
a61af66fc99e Initial load duke parents: diff changeset	2958 \
a61af66fc99e Initial load duke parents: diff changeset	2959 develop(uintx, TotalHandleAllocationLimit, 1024, \
a61af66fc99e Initial load duke parents: diff changeset	2960 "Threshold for total handle allocation when " \
a61af66fc99e Initial load duke parents: diff changeset	2961 "+TraceHandleAllocation is used") \
a61af66fc99e Initial load duke parents: diff changeset	2962 \
a61af66fc99e Initial load duke parents: diff changeset	2963 develop(intx, StackPrintLimit, 100, \
a61af66fc99e Initial load duke parents: diff changeset	2964 "number of stack frames to print in VM-level stack dump") \
a61af66fc99e Initial load duke parents: diff changeset	2965 \
a61af66fc99e Initial load duke parents: diff changeset	2966 notproduct(intx, MaxElementPrintSize, 256, \
a61af66fc99e Initial load duke parents: diff changeset	2967 "maximum number of elements to print") \
a61af66fc99e Initial load duke parents: diff changeset	2968 \
a61af66fc99e Initial load duke parents: diff changeset	2969 notproduct(intx, MaxSubklassPrintSize, 4, \
a61af66fc99e Initial load duke parents: diff changeset	2970 "maximum number of subklasses to print when printing klass") \
a61af66fc99e Initial load duke parents: diff changeset	2971 \
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1150 diff changeset	2972 product(intx, MaxInlineLevel, 9, \
0 a61af66fc99e Initial load duke parents: diff changeset	2973 "maximum number of nested calls that are inlined") \
a61af66fc99e Initial load duke parents: diff changeset	2974 \
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1150 diff changeset	2975 product(intx, MaxRecursiveInlineLevel, 1, \
0 a61af66fc99e Initial load duke parents: diff changeset	2976 "maximum number of nested recursive calls that are inlined") \
a61af66fc99e Initial load duke parents: diff changeset	2977 \
13081 e74074c34312 8028159: C2: compiler stack overflow during inlining of @ForceInline methods vlivanov parents: 13074 diff changeset	2978 develop(intx, MaxForceInlineLevel, 100, \
e74074c34312 8028159: C2: compiler stack overflow during inlining of @ForceInline methods vlivanov parents: 13074 diff changeset	2979 "maximum number of nested @ForceInline calls that are inlined") \
e74074c34312 8028159: C2: compiler stack overflow during inlining of @ForceInline methods vlivanov parents: 13074 diff changeset	2980 \
675 f6da6f0174ac 6821700: tune VM flags for peak performance kvn parents: 647 diff changeset	2981 product_pd(intx, InlineSmallCode, \
0 a61af66fc99e Initial load duke parents: diff changeset	2982 "Only inline already compiled methods if their code size is " \
a61af66fc99e Initial load duke parents: diff changeset	2983 "less than this") \
a61af66fc99e Initial load duke parents: diff changeset	2984 \
a61af66fc99e Initial load duke parents: diff changeset	2985 product(intx, MaxInlineSize, 35, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2986 "The maximum bytecode size of a method to be inlined") \
0 a61af66fc99e Initial load duke parents: diff changeset	2987 \
a61af66fc99e Initial load duke parents: diff changeset	2988 product_pd(intx, FreqInlineSize, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2989 "The maximum bytecode size of a frequent method to be inlined") \
0 a61af66fc99e Initial load duke parents: diff changeset	2990 \
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1150 diff changeset	2991 product(intx, MaxTrivialSize, 6, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2992 "The maximum bytecode size of a trivial method to be inlined") \
0 a61af66fc99e Initial load duke parents: diff changeset	2993 \
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1150 diff changeset	2994 product(intx, MinInliningThreshold, 250, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2995 "The minimum invocation count a method needs to have to be " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2996 "inlined") \
0 a61af66fc99e Initial load duke parents: diff changeset	2997 \
a61af66fc99e Initial load duke parents: diff changeset	2998 develop(intx, MethodHistogramCutoff, 100, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	2999 "The cutoff value for method invocation histogram (+CountCalls)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3000 \
a61af66fc99e Initial load duke parents: diff changeset	3001 develop(intx, ProfilerNumberOfInterpretedMethods, 25, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3002 "Number of interpreted methods to show in profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3003 \
a61af66fc99e Initial load duke parents: diff changeset	3004 develop(intx, ProfilerNumberOfCompiledMethods, 25, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3005 "Number of compiled methods to show in profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3006 \
a61af66fc99e Initial load duke parents: diff changeset	3007 develop(intx, ProfilerNumberOfStubMethods, 25, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3008 "Number of stub methods to show in profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3009 \
a61af66fc99e Initial load duke parents: diff changeset	3010 develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3011 "Number of runtime stub nodes to show in profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3012 \
a61af66fc99e Initial load duke parents: diff changeset	3013 product(intx, ProfileIntervalsTicks, 100, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3014 "Number of ticks between printing of interval profile " \
0 a61af66fc99e Initial load duke parents: diff changeset	3015 "(+ProfileIntervals)") \
a61af66fc99e Initial load duke parents: diff changeset	3016 \
a61af66fc99e Initial load duke parents: diff changeset	3017 notproduct(intx, ScavengeALotInterval, 1, \
a61af66fc99e Initial load duke parents: diff changeset	3018 "Interval between which scavenge will occur with +ScavengeALot") \
a61af66fc99e Initial load duke parents: diff changeset	3019 \
a61af66fc99e Initial load duke parents: diff changeset	3020 notproduct(intx, FullGCALotInterval, 1, \
a61af66fc99e Initial load duke parents: diff changeset	3021 "Interval between which full gc will occur with +FullGCALot") \
a61af66fc99e Initial load duke parents: diff changeset	3022 \
a61af66fc99e Initial load duke parents: diff changeset	3023 notproduct(intx, FullGCALotStart, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3024 "For which invocation to start FullGCAlot") \
a61af66fc99e Initial load duke parents: diff changeset	3025 \
a61af66fc99e Initial load duke parents: diff changeset	3026 notproduct(intx, FullGCALotDummies, 32*K, \
a61af66fc99e Initial load duke parents: diff changeset	3027 "Dummy object allocated with +FullGCALot, forcing all objects " \
a61af66fc99e Initial load duke parents: diff changeset	3028 "to move") \
a61af66fc99e Initial load duke parents: diff changeset	3029 \
a61af66fc99e Initial load duke parents: diff changeset	3030 develop(intx, DontYieldALotInterval, 10, \
a61af66fc99e Initial load duke parents: diff changeset	3031 "Interval between which yields will be dropped (milliseconds)") \
a61af66fc99e Initial load duke parents: diff changeset	3032 \
a61af66fc99e Initial load duke parents: diff changeset	3033 develop(intx, MinSleepInterval, 1, \
a61af66fc99e Initial load duke parents: diff changeset	3034 "Minimum sleep() interval (milliseconds) when " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3035 "ConvertSleepToYield is off (used for Solaris)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3036 \
a61af66fc99e Initial load duke parents: diff changeset	3037 develop(intx, ProfilerPCTickThreshold, 15, \
a61af66fc99e Initial load duke parents: diff changeset	3038 "Number of ticks in a PC buckets to be a hotspot") \
a61af66fc99e Initial load duke parents: diff changeset	3039 \
a61af66fc99e Initial load duke parents: diff changeset	3040 notproduct(intx, DeoptimizeALotInterval, 5, \
a61af66fc99e Initial load duke parents: diff changeset	3041 "Number of exits until DeoptimizeALot kicks in") \
a61af66fc99e Initial load duke parents: diff changeset	3042 \
a61af66fc99e Initial load duke parents: diff changeset	3043 notproduct(intx, ZombieALotInterval, 5, \
a61af66fc99e Initial load duke parents: diff changeset	3044 "Number of exits until ZombieALot kicks in") \
a61af66fc99e Initial load duke parents: diff changeset	3045 \
a61af66fc99e Initial load duke parents: diff changeset	3046 diagnostic(intx, MallocVerifyInterval, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3047 "If non-zero, verify C heap after every N calls to " \
0 a61af66fc99e Initial load duke parents: diff changeset	3048 "malloc/realloc/free") \
a61af66fc99e Initial load duke parents: diff changeset	3049 \
a61af66fc99e Initial load duke parents: diff changeset	3050 diagnostic(intx, MallocVerifyStart, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3051 "If non-zero, start verifying C heap after Nth call to " \
0 a61af66fc99e Initial load duke parents: diff changeset	3052 "malloc/realloc/free") \
a61af66fc99e Initial load duke parents: diff changeset	3053 \
8802 eca90b8a06eb 7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test rdurbin parents: 8706 diff changeset	3054 diagnostic(uintx, MallocMaxTestWords, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3055 "If non-zero, maximum number of words that malloc/realloc can " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3056 "allocate (for testing only)") \
8802 eca90b8a06eb 7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test rdurbin parents: 8706 diff changeset	3057 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	3058 product(intx, TypeProfileWidth, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3059 "Number of receiver types to record in call/cast profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3060 \
9760 c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9627 diff changeset	3061 product_pd(intx, MethodProfileWidth, \
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9627 diff changeset	3062 "number of methods to record in call profile") \
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9627 diff changeset	3063 \
0 a61af66fc99e Initial load duke parents: diff changeset	3064 develop(intx, BciProfileWidth, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3065 "Number of return bci's to record in ret profile") \
0 a61af66fc99e Initial load duke parents: diff changeset	3066 \
a61af66fc99e Initial load duke parents: diff changeset	3067 product(intx, PerMethodRecompilationCutoff, 400, \
a61af66fc99e Initial load duke parents: diff changeset	3068 "After recompiling N times, stay in the interpreter (-1=>'Inf')") \
a61af66fc99e Initial load duke parents: diff changeset	3069 \
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1202 diff changeset	3070 product(intx, PerBytecodeRecompilationCutoff, 200, \
0 a61af66fc99e Initial load duke parents: diff changeset	3071 "Per-BCI limit on repeated recompilation (-1=>'Inf')") \
a61af66fc99e Initial load duke parents: diff changeset	3072 \
a61af66fc99e Initial load duke parents: diff changeset	3073 product(intx, PerMethodTrapLimit, 100, \
a61af66fc99e Initial load duke parents: diff changeset	3074 "Limit on traps (of one kind) in a method (includes inlines)") \
a61af66fc99e Initial load duke parents: diff changeset	3075 \
a61af66fc99e Initial load duke parents: diff changeset	3076 product(intx, PerBytecodeTrapLimit, 4, \
a61af66fc99e Initial load duke parents: diff changeset	3077 "Limit on traps (of one kind) at a particular BCI") \
a61af66fc99e Initial load duke parents: diff changeset	3078 \
a61af66fc99e Initial load duke parents: diff changeset	3079 develop(intx, InlineFrequencyRatio, 20, \
a61af66fc99e Initial load duke parents: diff changeset	3080 "Ratio of call site execution to caller method invocation") \
a61af66fc99e Initial load duke parents: diff changeset	3081 \
a61af66fc99e Initial load duke parents: diff changeset	3082 develop_pd(intx, InlineFrequencyCount, \
a61af66fc99e Initial load duke parents: diff changeset	3083 "Count of call site execution necessary to trigger frequent " \
a61af66fc99e Initial load duke parents: diff changeset	3084 "inlining") \
a61af66fc99e Initial load duke parents: diff changeset	3085 \
a61af66fc99e Initial load duke parents: diff changeset	3086 develop(intx, InlineThrowCount, 50, \
a61af66fc99e Initial load duke parents: diff changeset	3087 "Force inlining of interpreted methods that throw this often") \
a61af66fc99e Initial load duke parents: diff changeset	3088 \
a61af66fc99e Initial load duke parents: diff changeset	3089 develop(intx, InlineThrowMaxSize, 200, \
a61af66fc99e Initial load duke parents: diff changeset	3090 "Force inlining of throwing methods smaller than this") \
a61af66fc99e Initial load duke parents: diff changeset	3091 \
a61af66fc99e Initial load duke parents: diff changeset	3092 develop(intx, ProfilerNodeSize, 1024, \
a61af66fc99e Initial load duke parents: diff changeset	3093 "Size in K to allocate for the Profile Nodes of each thread") \
a61af66fc99e Initial load duke parents: diff changeset	3094 \
a61af66fc99e Initial load duke parents: diff changeset	3095 product_pd(intx, PreInflateSpin, \
a61af66fc99e Initial load duke parents: diff changeset	3096 "Number of times to spin wait before inflation") \
a61af66fc99e Initial load duke parents: diff changeset	3097 \
a61af66fc99e Initial load duke parents: diff changeset	3098 /* gc parameters */ \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3099 product(uintx, InitialHeapSize, 0, \
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10208 diff changeset	3100 "Initial heap size (in bytes); zero means use ergonomics") \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3101 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3102 product(uintx, MaxHeapSize, ScaleForWordSize(96*M), \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3103 "Maximum heap size (in bytes)") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3104 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3105 product(uintx, OldSize, ScaleForWordSize(4*M), \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3106 "Initial tenured generation size (in bytes)") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3107 \
1287 8911d8c0596f 6923123: Hotspot refuses to start when -Xmx4m or -Xms4m is specified phh parents: 1211 diff changeset	3108 product(uintx, NewSize, ScaleForWordSize(1*M), \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3109 "Initial new generation size (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3110 \
a61af66fc99e Initial load duke parents: diff changeset	3111 product(uintx, MaxNewSize, max_uintx, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3112 "Maximum new generation size (in bytes), max_uintx means set " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3113 "ergonomically") \
0 a61af66fc99e Initial load duke parents: diff changeset	3114 \
a61af66fc99e Initial load duke parents: diff changeset	3115 product(uintx, PretenureSizeThreshold, 0, \
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3116 "Maximum size in bytes of objects allocated in DefNew " \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3117 "generation; zero means no maximum") \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3118 \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3119 product(uintx, TLABSize, 0, \
473cce303f13 6887571: Increase default heap config sizes phh parents: 1010 diff changeset	3120 "Starting TLAB size (in bytes); zero means set ergonomically") \
0 a61af66fc99e Initial load duke parents: diff changeset	3121 \
a61af66fc99e Initial load duke parents: diff changeset	3122 product(uintx, MinTLABSize, 2*K, \
a61af66fc99e Initial load duke parents: diff changeset	3123 "Minimum allowed TLAB size (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3124 \
a61af66fc99e Initial load duke parents: diff changeset	3125 product(uintx, TLABAllocationWeight, 35, \
a61af66fc99e Initial load duke parents: diff changeset	3126 "Allocation averaging weight") \
a61af66fc99e Initial load duke parents: diff changeset	3127 \
a61af66fc99e Initial load duke parents: diff changeset	3128 product(uintx, TLABWasteTargetPercent, 1, \
a61af66fc99e Initial load duke parents: diff changeset	3129 "Percentage of Eden that can be wasted") \
a61af66fc99e Initial load duke parents: diff changeset	3130 \
a61af66fc99e Initial load duke parents: diff changeset	3131 product(uintx, TLABRefillWasteFraction, 64, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3132 "Maximum TLAB waste at a refill (internal fragmentation)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3133 \
a61af66fc99e Initial load duke parents: diff changeset	3134 product(uintx, TLABWasteIncrement, 4, \
a61af66fc99e Initial load duke parents: diff changeset	3135 "Increment allowed waste at slow allocation") \
a61af66fc99e Initial load duke parents: diff changeset	3136 \
8035 f64ffbf81af5 8006432: Ratio flags should be unsigned jwilhelm parents: 8034 diff changeset	3137 product(uintx, SurvivorRatio, 8, \
0 a61af66fc99e Initial load duke parents: diff changeset	3138 "Ratio of eden/survivor space size") \
a61af66fc99e Initial load duke parents: diff changeset	3139 \
8035 f64ffbf81af5 8006432: Ratio flags should be unsigned jwilhelm parents: 8034 diff changeset	3140 product(uintx, NewRatio, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3141 "Ratio of old/new generation sizes") \
0 a61af66fc99e Initial load duke parents: diff changeset	3142 \
a61af66fc99e Initial load duke parents: diff changeset	3143 product_pd(uintx, NewSizeThreadIncrease, \
a61af66fc99e Initial load duke parents: diff changeset	3144 "Additional size added to desired new generation size per " \
a61af66fc99e Initial load duke parents: diff changeset	3145 "non-daemon thread (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3146 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3147 product_pd(uintx, MetaspaceSize, \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3148 "Initial size of Metaspaces (in bytes)") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3149 \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3150 product(uintx, MaxMetaspaceSize, max_uintx, \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3151 "Maximum size of Metaspaces (in bytes)") \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3152 \
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12154 diff changeset	3153 product(uintx, CompressedClassSpaceSize, 1*G, \
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12154 diff changeset	3154 "Maximum size of class area in Metaspace when compressed " \
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12154 diff changeset	3155 "class pointers are used") \
0 a61af66fc99e Initial load duke parents: diff changeset	3156 \
a61af66fc99e Initial load duke parents: diff changeset	3157 product(uintx, MinHeapFreeRatio, 40, \
12892 9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3158 "The minimum percentage of heap free after GC to avoid expansion."\
9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3159 " For most GCs this applies to the old generation. In G1 it" \
9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3160 " applies to the whole heap. Not supported by ParallelGC.") \
0 a61af66fc99e Initial load duke parents: diff changeset	3161 \
a61af66fc99e Initial load duke parents: diff changeset	3162 product(uintx, MaxHeapFreeRatio, 70, \
12892 9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3163 "The maximum percentage of heap free after GC to avoid shrinking."\
9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3164 " For most GCs this applies to the old generation. In G1 it" \
9c8289162268 8024776: Max/MinHeapFreeRatio descriptions should be more precise jwilhelm parents: 12838 diff changeset	3165 " applies to the whole heap. Not supported by ParallelGC.") \
0 a61af66fc99e Initial load duke parents: diff changeset	3166 \
a61af66fc99e Initial load duke parents: diff changeset	3167 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
a61af66fc99e Initial load duke parents: diff changeset	3168 "Number of milliseconds per MB of free space in the heap") \
a61af66fc99e Initial load duke parents: diff changeset	3169 \
a61af66fc99e Initial load duke parents: diff changeset	3170 product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3171 "The minimum change in heap space due to GC (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3172 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	3173 product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3174 "The minimum expansion of Metaspace (in bytes)") \
8040 a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8035 diff changeset	3175 \
a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8035 diff changeset	3176 product(uintx, MinMetaspaceFreeRatio, 40, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3177 "The minimum percentage of Metaspace free after GC to avoid " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3178 "expansion") \
8040 a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8035 diff changeset	3179 \
a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8035 diff changeset	3180 product(uintx, MaxMetaspaceFreeRatio, 70, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3181 "The maximum percentage of Metaspace free after GC to avoid " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3182 "shrinking") \
0 a61af66fc99e Initial load duke parents: diff changeset	3183 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	3184 product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3185 "The maximum expansion of Metaspace without full GC (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3186 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	3187 product(uintx, QueuedAllocationWarningCount, 0, \
0 a61af66fc99e Initial load duke parents: diff changeset	3188 "Number of times an allocation that queues behind a GC " \
a61af66fc99e Initial load duke parents: diff changeset	3189 "will retry before printing a warning") \
a61af66fc99e Initial load duke parents: diff changeset	3190 \
a61af66fc99e Initial load duke parents: diff changeset	3191 diagnostic(uintx, VerifyGCStartAt, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3192 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
a61af66fc99e Initial load duke parents: diff changeset	3193 \
a61af66fc99e Initial load duke parents: diff changeset	3194 diagnostic(intx, VerifyGCLevel, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3195 "Generation level at which to start +VerifyBefore/AfterGC") \
a61af66fc99e Initial load duke parents: diff changeset	3196 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	3197 product(uintx, MaxTenuringThreshold, 15, \
0 a61af66fc99e Initial load duke parents: diff changeset	3198 "Maximum value for tenuring threshold") \
a61af66fc99e Initial load duke parents: diff changeset	3199 \
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6817 diff changeset	3200 product(uintx, InitialTenuringThreshold, 7, \
0 a61af66fc99e Initial load duke parents: diff changeset	3201 "Initial value for tenuring threshold") \
a61af66fc99e Initial load duke parents: diff changeset	3202 \
8035 f64ffbf81af5 8006432: Ratio flags should be unsigned jwilhelm parents: 8034 diff changeset	3203 product(uintx, TargetSurvivorRatio, 50, \
0 a61af66fc99e Initial load duke parents: diff changeset	3204 "Desired percentage of survivor space used after scavenge") \
a61af66fc99e Initial load duke parents: diff changeset	3205 \
438 122d10c82f3f 6765804: GC "dead ratios" should be unsigned jcoomes parents: 406 diff changeset	3206 product(uintx, MarkSweepDeadRatio, 5, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3207 "Percentage (0-100) of the old gen allowed as dead wood. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3208 "Serial mark sweep treats this as both the minimum and maximum " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3209 "value. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3210 "CMS uses this value only if it falls back to mark sweep. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3211 "Par compact uses a variable scale based on the density of the " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3212 "generation and treats this as the maximum value when the heap " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3213 "is either completely full or completely empty. Par compact " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3214 "also has a smaller default value; see arguments.cpp.") \
0 a61af66fc99e Initial load duke parents: diff changeset	3215 \
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10241 diff changeset	3216 product(uintx, MarkSweepAlwaysCompactCount, 4, \
0 a61af66fc99e Initial load duke parents: diff changeset	3217 "How often should we fully compact the heap (ignoring the dead " \
a61af66fc99e Initial load duke parents: diff changeset	3218 "space parameters)") \
a61af66fc99e Initial load duke parents: diff changeset	3219 \
a61af66fc99e Initial load duke parents: diff changeset	3220 product(intx, PrintCMSStatistics, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3221 "Statistics for CMS") \
a61af66fc99e Initial load duke parents: diff changeset	3222 \
a61af66fc99e Initial load duke parents: diff changeset	3223 product(bool, PrintCMSInitiationStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	3224 "Statistics for initiating a CMS collection") \
a61af66fc99e Initial load duke parents: diff changeset	3225 \
a61af66fc99e Initial load duke parents: diff changeset	3226 product(intx, PrintFLSStatistics, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3227 "Statistics for CMS' FreeListSpace") \
a61af66fc99e Initial load duke parents: diff changeset	3228 \
a61af66fc99e Initial load duke parents: diff changeset	3229 product(intx, PrintFLSCensus, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3230 "Census for CMS' FreeListSpace") \
a61af66fc99e Initial load duke parents: diff changeset	3231 \
a61af66fc99e Initial load duke parents: diff changeset	3232 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3233 "Delay between expansion and allocation (in milliseconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3234 \
6817 f81a7c0c618d 7199349: NPG: PS: Crash seen in jprt jmasa parents: 6770 diff changeset	3235 develop(uintx, GCWorkerDelayMillis, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3236 "Delay in scheduling GC workers (in milliseconds)") \
6817 f81a7c0c618d 7199349: NPG: PS: Crash seen in jprt jmasa parents: 6770 diff changeset	3237 \
0 a61af66fc99e Initial load duke parents: diff changeset	3238 product(intx, DeferThrSuspendLoopCount, 4000, \
a61af66fc99e Initial load duke parents: diff changeset	3239 "(Unstable) Number of times to iterate in safepoint loop " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3240 "before blocking VM threads ") \
0 a61af66fc99e Initial load duke parents: diff changeset	3241 \
a61af66fc99e Initial load duke parents: diff changeset	3242 product(intx, DeferPollingPageLoopCount, -1, \
a61af66fc99e Initial load duke parents: diff changeset	3243 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
a61af66fc99e Initial load duke parents: diff changeset	3244 "before changing safepoint polling page to RO ") \
a61af66fc99e Initial load duke parents: diff changeset	3245 \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3246 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3247 \
a61af66fc99e Initial load duke parents: diff changeset	3248 product(bool, PSChunkLargeArrays, true, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3249 "Process large arrays in chunks") \
0 a61af66fc99e Initial load duke parents: diff changeset	3250 \
a61af66fc99e Initial load duke parents: diff changeset	3251 product(uintx, GCDrainStackTargetSize, 64, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3252 "Number of entries we will try to leave on the stack " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3253 "during parallel gc") \
0 a61af66fc99e Initial load duke parents: diff changeset	3254 \
a61af66fc99e Initial load duke parents: diff changeset	3255 /* stack parameters */ \
a61af66fc99e Initial load duke parents: diff changeset	3256 product_pd(intx, StackYellowPages, \
a61af66fc99e Initial load duke parents: diff changeset	3257 "Number of yellow zone (recoverable overflows) pages") \
a61af66fc99e Initial load duke parents: diff changeset	3258 \
a61af66fc99e Initial load duke parents: diff changeset	3259 product_pd(intx, StackRedPages, \
a61af66fc99e Initial load duke parents: diff changeset	3260 "Number of red zone (unrecoverable overflows) pages") \
a61af66fc99e Initial load duke parents: diff changeset	3261 \
a61af66fc99e Initial load duke parents: diff changeset	3262 product_pd(intx, StackShadowPages, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3263 "Number of shadow zone (for overflow checking) pages " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3264 "this should exceed the depth of the VM and native call stack") \
0 a61af66fc99e Initial load duke parents: diff changeset	3265 \
a61af66fc99e Initial load duke parents: diff changeset	3266 product_pd(intx, ThreadStackSize, \
a61af66fc99e Initial load duke parents: diff changeset	3267 "Thread Stack Size (in Kbytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3268 \
a61af66fc99e Initial load duke parents: diff changeset	3269 product_pd(intx, VMThreadStackSize, \
a61af66fc99e Initial load duke parents: diff changeset	3270 "Non-Java Thread Stack Size (in Kbytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3271 \
a61af66fc99e Initial load duke parents: diff changeset	3272 product_pd(intx, CompilerThreadStackSize, \
a61af66fc99e Initial load duke parents: diff changeset	3273 "Compiler Thread Stack Size (in Kbytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3274 \
a61af66fc99e Initial load duke parents: diff changeset	3275 develop_pd(uintx, JVMInvokeMethodSlack, \
a61af66fc99e Initial load duke parents: diff changeset	3276 "Stack space (bytes) required for JVM_InvokeMethod to complete") \
a61af66fc99e Initial load duke parents: diff changeset	3277 \
a61af66fc99e Initial load duke parents: diff changeset	3278 product(uintx, ThreadSafetyMargin, 50*M, \
a61af66fc99e Initial load duke parents: diff changeset	3279 "Thread safety margin is used on fixed-stack LinuxThreads (on " \
a61af66fc99e Initial load duke parents: diff changeset	3280 "Linux/x86 only) to prevent heap-stack collision. Set to 0 to " \
a61af66fc99e Initial load duke parents: diff changeset	3281 "disable this feature") \
a61af66fc99e Initial load duke parents: diff changeset	3282 \
a61af66fc99e Initial load duke parents: diff changeset	3283 /* code cache parameters */ \
a61af66fc99e Initial load duke parents: diff changeset	3284 develop(uintx, CodeCacheSegmentSize, 64, \
a61af66fc99e Initial load duke parents: diff changeset	3285 "Code cache segment size (in bytes) - smallest unit of " \
a61af66fc99e Initial load duke parents: diff changeset	3286 "allocation") \
a61af66fc99e Initial load duke parents: diff changeset	3287 \
a61af66fc99e Initial load duke parents: diff changeset	3288 develop_pd(intx, CodeEntryAlignment, \
a61af66fc99e Initial load duke parents: diff changeset	3289 "Code entry alignment for generated code (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3290 \
1365 6476042f815c 6940701: Don't align loops in stubs for Niagara sparc kvn parents: 1351 diff changeset	3291 product_pd(intx, OptoLoopAlignment, \
6476042f815c 6940701: Don't align loops in stubs for Niagara sparc kvn parents: 1351 diff changeset	3292 "Align inner loops to zero relative to this modulus") \
6476042f815c 6940701: Don't align loops in stubs for Niagara sparc kvn parents: 1351 diff changeset	3293 \
0 a61af66fc99e Initial load duke parents: diff changeset	3294 product_pd(uintx, InitialCodeCacheSize, \
a61af66fc99e Initial load duke parents: diff changeset	3295 "Initial code cache size (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3296 \
11079 738e04fb1232 8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k anoll parents: 10405 diff changeset	3297 develop_pd(uintx, CodeCacheMinimumUseSpace, \
738e04fb1232 8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k anoll parents: 10405 diff changeset	3298 "Minimum code cache size (in bytes) required to start VM.") \
738e04fb1232 8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k anoll parents: 10405 diff changeset	3299 \
0 a61af66fc99e Initial load duke parents: diff changeset	3300 product_pd(uintx, ReservedCodeCacheSize, \
a61af66fc99e Initial load duke parents: diff changeset	3301 "Reserved code cache size (in bytes) - maximum code cache size") \
a61af66fc99e Initial load duke parents: diff changeset	3302 \
a61af66fc99e Initial load duke parents: diff changeset	3303 product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3304 "When less than X space left, we stop compiling") \
0 a61af66fc99e Initial load duke parents: diff changeset	3305 \
a61af66fc99e Initial load duke parents: diff changeset	3306 product_pd(uintx, CodeCacheExpansionSize, \
a61af66fc99e Initial load duke parents: diff changeset	3307 "Code cache expansion size (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	3308 \
a61af66fc99e Initial load duke parents: diff changeset	3309 develop_pd(uintx, CodeCacheMinBlockLength, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3310 "Minimum number of segments in a code cache block") \
0 a61af66fc99e Initial load duke parents: diff changeset	3311 \
a61af66fc99e Initial load duke parents: diff changeset	3312 notproduct(bool, ExitOnFullCodeCache, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3313 "Exit the VM if we fill the code cache") \
0 a61af66fc99e Initial load duke parents: diff changeset	3314 \
4039 5bda8dae4e14 7103784: enable some flags by default never parents: 4006 diff changeset	3315 product(bool, UseCodeCacheFlushing, true, \
13074 78da3894b86f 8027593: performance drop with constrained codecache starting with hs25 b111 anoll parents: 13071 diff changeset	3316 "Remove cold/old nmethods from the code cache") \
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1188 diff changeset	3317 \
0 a61af66fc99e Initial load duke parents: diff changeset	3318 /* interpreter debugging */ \
a61af66fc99e Initial load duke parents: diff changeset	3319 develop(intx, BinarySwitchThreshold, 5, \
a61af66fc99e Initial load duke parents: diff changeset	3320 "Minimal number of lookupswitch entries for rewriting to binary " \
a61af66fc99e Initial load duke parents: diff changeset	3321 "switch") \
a61af66fc99e Initial load duke parents: diff changeset	3322 \
a61af66fc99e Initial load duke parents: diff changeset	3323 develop(intx, StopInterpreterAt, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3324 "Stop interpreter execution at specified bytecode number") \
0 a61af66fc99e Initial load duke parents: diff changeset	3325 \
a61af66fc99e Initial load duke parents: diff changeset	3326 develop(intx, TraceBytecodesAt, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3327 "Trace bytecodes starting with specified bytecode number") \
0 a61af66fc99e Initial load duke parents: diff changeset	3328 \
a61af66fc99e Initial load duke parents: diff changeset	3329 /* compiler interface */ \
a61af66fc99e Initial load duke parents: diff changeset	3330 develop(intx, CIStart, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3331 "The id of the first compilation to permit") \
0 a61af66fc99e Initial load duke parents: diff changeset	3332 \
a61af66fc99e Initial load duke parents: diff changeset	3333 develop(intx, CIStop, -1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3334 "The id of the last compilation to permit") \
0 a61af66fc99e Initial load duke parents: diff changeset	3335 \
a61af66fc99e Initial load duke parents: diff changeset	3336 develop(intx, CIStartOSR, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3337 "The id of the first osr compilation to permit " \
0 a61af66fc99e Initial load duke parents: diff changeset	3338 "(CICountOSR must be on)") \
a61af66fc99e Initial load duke parents: diff changeset	3339 \
a61af66fc99e Initial load duke parents: diff changeset	3340 develop(intx, CIStopOSR, -1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3341 "The id of the last osr compilation to permit " \
0 a61af66fc99e Initial load duke parents: diff changeset	3342 "(CICountOSR must be on)") \
a61af66fc99e Initial load duke parents: diff changeset	3343 \
a61af66fc99e Initial load duke parents: diff changeset	3344 develop(intx, CIBreakAtOSR, -1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3345 "The id of osr compilation to break at") \
0 a61af66fc99e Initial load duke parents: diff changeset	3346 \
a61af66fc99e Initial load duke parents: diff changeset	3347 develop(intx, CIBreakAt, -1, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3348 "The id of compilation to break at") \
0 a61af66fc99e Initial load duke parents: diff changeset	3349 \
a61af66fc99e Initial load duke parents: diff changeset	3350 product(ccstrlist, CompileOnly, "", \
a61af66fc99e Initial load duke parents: diff changeset	3351 "List of methods (pkg/class.name) to restrict compilation to") \
a61af66fc99e Initial load duke parents: diff changeset	3352 \
a61af66fc99e Initial load duke parents: diff changeset	3353 product(ccstr, CompileCommandFile, NULL, \
a61af66fc99e Initial load duke parents: diff changeset	3354 "Read compiler commands from this file [.hotspot_compiler]") \
a61af66fc99e Initial load duke parents: diff changeset	3355 \
a61af66fc99e Initial load duke parents: diff changeset	3356 product(ccstrlist, CompileCommand, "", \
a61af66fc99e Initial load duke parents: diff changeset	3357 "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \
a61af66fc99e Initial load duke parents: diff changeset	3358 \
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3359 develop(bool, ReplayCompiles, false, \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3360 "Enable replay of compilations from ReplayDataFile") \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3361 \
10195 e12c9b3740db 8012260: ciReplay: Include PID into the name of replay data file vlivanov parents: 9073 diff changeset	3362 product(ccstr, ReplayDataFile, NULL, \
e12c9b3740db 8012260: ciReplay: Include PID into the name of replay data file vlivanov parents: 9073 diff changeset	3363 "File containing compilation replay information" \
e12c9b3740db 8012260: ciReplay: Include PID into the name of replay data file vlivanov parents: 9073 diff changeset	3364 "[default: ./replay_pid%p.log] (%p replaced with pid)") \
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3365 \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3366 develop(intx, ReplaySuppressInitializers, 2, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3367 "Control handling of class initialization during replay: " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3368 "0 - don't do anything special; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3369 "1 - treat all class initializers as empty; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3370 "2 - treat class initializers for application classes as empty; " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3371 "3 - allow all class initializers to run during bootstrap but " \
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3372 " pretend they are empty after starting replay") \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3373 \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3374 develop(bool, ReplayIgnoreInitErrors, false, \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3375 "Ignore exceptions thrown during initialization for replay") \
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3376 \
10195 e12c9b3740db 8012260: ciReplay: Include PID into the name of replay data file vlivanov parents: 9073 diff changeset	3377 product(bool, DumpReplayDataOnError, true, \
e12c9b3740db 8012260: ciReplay: Include PID into the name of replay data file vlivanov parents: 9073 diff changeset	3378 "Record replay data for crashing compiler threads") \
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6935 diff changeset	3379 \
0 a61af66fc99e Initial load duke parents: diff changeset	3380 product(bool, CICompilerCountPerCPU, false, \
a61af66fc99e Initial load duke parents: diff changeset	3381 "1 compiler thread for log(N CPUs)") \
a61af66fc99e Initial load duke parents: diff changeset	3382 \
a61af66fc99e Initial load duke parents: diff changeset	3383 develop(intx, CIFireOOMAt, -1, \
a61af66fc99e Initial load duke parents: diff changeset	3384 "Fire OutOfMemoryErrors throughout CI for testing the compiler " \
a61af66fc99e Initial load duke parents: diff changeset	3385 "(non-negative value throws OOM after this many CI accesses " \
a61af66fc99e Initial load duke parents: diff changeset	3386 "in each compile)") \
10197 7b23cb975cf2 8011675: adding compilation level to replay data iignatyev parents: 10195 diff changeset	3387 notproduct(intx, CICrashAt, -1, \
7b23cb975cf2 8011675: adding compilation level to replay data iignatyev parents: 10195 diff changeset	3388 "id of compilation to trigger assert in compiler thread for " \
7b23cb975cf2 8011675: adding compilation level to replay data iignatyev parents: 10195 diff changeset	3389 "the purpose of testing, e.g. generation of replay data") \
909 b32a809aab08 6866585: debug code in ciObjectFactory too slow for large objects jcoomes parents: 905 diff changeset	3390 notproduct(bool, CIObjectFactoryVerify, false, \
b32a809aab08 6866585: debug code in ciObjectFactory too slow for large objects jcoomes parents: 905 diff changeset	3391 "enable potentially expensive verification in ciObjectFactory") \
b32a809aab08 6866585: debug code in ciObjectFactory too slow for large objects jcoomes parents: 905 diff changeset	3392 \
0 a61af66fc99e Initial load duke parents: diff changeset	3393 /* Priorities */ \
a61af66fc99e Initial load duke parents: diff changeset	3394 product_pd(bool, UseThreadPriorities, "Use native thread priorities") \
a61af66fc99e Initial load duke parents: diff changeset	3395 \
a61af66fc99e Initial load duke parents: diff changeset	3396 product(intx, ThreadPriorityPolicy, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3397 "0 : Normal. "\
a61af66fc99e Initial load duke parents: diff changeset	3398 " VM chooses priorities that are appropriate for normal "\
a61af66fc99e Initial load duke parents: diff changeset	3399 " applications. On Solaris NORM_PRIORITY and above are mapped "\
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3400 " to normal native priority. Java priorities below " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3401 " NORM_PRIORITY map to lower native priority values. On "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3402 " Windows applications are allowed to use higher native "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3403 " priorities. However, with ThreadPriorityPolicy=0, VM will "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3404 " not use the highest possible native priority, "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3405 " THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3406 " system threads. On Linux thread priorities are ignored "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3407 " because the OS does not support static priority in "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3408 " SCHED_OTHER scheduling class which is the only choice for "\
0 a61af66fc99e Initial load duke parents: diff changeset	3409 " non-root, non-realtime applications. "\
a61af66fc99e Initial load duke parents: diff changeset	3410 "1 : Aggressive. "\
a61af66fc99e Initial load duke parents: diff changeset	3411 " Java thread priorities map over to the entire range of "\
a61af66fc99e Initial load duke parents: diff changeset	3412 " native thread priorities. Higher Java thread priorities map "\
a61af66fc99e Initial load duke parents: diff changeset	3413 " to higher native thread priorities. This policy should be "\
a61af66fc99e Initial load duke parents: diff changeset	3414 " used with care, as sometimes it can cause performance "\
a61af66fc99e Initial load duke parents: diff changeset	3415 " degradation in the application and/or the entire system. On "\
a61af66fc99e Initial load duke parents: diff changeset	3416 " Linux this policy requires root privilege.") \
a61af66fc99e Initial load duke parents: diff changeset	3417 \
a61af66fc99e Initial load duke parents: diff changeset	3418 product(bool, ThreadPriorityVerbose, false, \
4854 de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3419 "Print priority changes") \
0 a61af66fc99e Initial load duke parents: diff changeset	3420 \
a61af66fc99e Initial load duke parents: diff changeset	3421 product(intx, DefaultThreadPriority, -1, \
4854 de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3422 "The native priority at which threads run if not elsewhere " \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3423 "specified (-1 means no change)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3424 \
a61af66fc99e Initial load duke parents: diff changeset	3425 product(intx, CompilerThreadPriority, -1, \
4854 de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3426 "The native priority at which compiler threads should run " \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3427 "(-1 means no change)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3428 \
a61af66fc99e Initial load duke parents: diff changeset	3429 product(intx, VMThreadPriority, -1, \
4854 de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3430 "The native priority at which the VM thread should run " \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3431 "(-1 means no change)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3432 \
a61af66fc99e Initial load duke parents: diff changeset	3433 product(bool, CompilerThreadHintNoPreempt, true, \
a61af66fc99e Initial load duke parents: diff changeset	3434 "(Solaris only) Give compiler threads an extra quanta") \
a61af66fc99e Initial load duke parents: diff changeset	3435 \
a61af66fc99e Initial load duke parents: diff changeset	3436 product(bool, VMThreadHintNoPreempt, false, \
a61af66fc99e Initial load duke parents: diff changeset	3437 "(Solaris only) Give VM thread an extra quanta") \
a61af66fc99e Initial load duke parents: diff changeset	3438 \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3439 product(intx, JavaPriority1_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3440 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3441 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3442 product(intx, JavaPriority2_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3443 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3444 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3445 product(intx, JavaPriority3_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3446 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3447 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3448 product(intx, JavaPriority4_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3449 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3450 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3451 product(intx, JavaPriority5_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3452 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3453 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3454 product(intx, JavaPriority6_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3455 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3456 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3457 product(intx, JavaPriority7_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3458 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3459 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3460 product(intx, JavaPriority8_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3461 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3462 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3463 product(intx, JavaPriority9_To_OSPriority, -1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3464 "Map Java priorities to OS priorities") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3465 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3466 product(intx, JavaPriority10_To_OSPriority,-1, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3467 "Map Java priorities to OS priorities") \
0 a61af66fc99e Initial load duke parents: diff changeset	3468 \
4854 de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3469 experimental(bool, UseCriticalJavaThreadPriority, false, \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3470 "Java thread priority 10 maps to critical scheduling priority") \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3471 \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3472 experimental(bool, UseCriticalCompilerThreadPriority, false, \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3473 "Compiler thread(s) run at critical scheduling priority") \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3474 \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3475 experimental(bool, UseCriticalCMSThreadPriority, false, \
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3476 "ConcurrentMarkSweep thread runs at critical scheduling priority")\
de268c8a8075 7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11 phh parents: 4807 diff changeset	3477 \
0 a61af66fc99e Initial load duke parents: diff changeset	3478 /* compiler debugging */ \
a61af66fc99e Initial load duke parents: diff changeset	3479 notproduct(intx, CompileTheWorldStartAt, 1, \
a61af66fc99e Initial load duke parents: diff changeset	3480 "First class to consider when using +CompileTheWorld") \
a61af66fc99e Initial load duke parents: diff changeset	3481 \
a61af66fc99e Initial load duke parents: diff changeset	3482 notproduct(intx, CompileTheWorldStopAt, max_jint, \
a61af66fc99e Initial load duke parents: diff changeset	3483 "Last class to consider when using +CompileTheWorld") \
a61af66fc99e Initial load duke parents: diff changeset	3484 \
a61af66fc99e Initial load duke parents: diff changeset	3485 develop(intx, NewCodeParameter, 0, \
a61af66fc99e Initial load duke parents: diff changeset	3486 "Testing Only: Create a dedicated integer parameter before " \
a61af66fc99e Initial load duke parents: diff changeset	3487 "putback") \
a61af66fc99e Initial load duke parents: diff changeset	3488 \
a61af66fc99e Initial load duke parents: diff changeset	3489 /* new oopmap storage allocation */ \
a61af66fc99e Initial load duke parents: diff changeset	3490 develop(intx, MinOopMapAllocation, 8, \
a61af66fc99e Initial load duke parents: diff changeset	3491 "Minimum number of OopMap entries in an OopMapSet") \
a61af66fc99e Initial load duke parents: diff changeset	3492 \
a61af66fc99e Initial load duke parents: diff changeset	3493 /* Background Compilation */ \
a61af66fc99e Initial load duke parents: diff changeset	3494 develop(intx, LongCompileThreshold, 50, \
a61af66fc99e Initial load duke parents: diff changeset	3495 "Used with +TraceLongCompiles") \
a61af66fc99e Initial load duke parents: diff changeset	3496 \
a61af66fc99e Initial load duke parents: diff changeset	3497 product(intx, StarvationMonitorInterval, 200, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3498 "Pause between each check (in milliseconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3499 \
a61af66fc99e Initial load duke parents: diff changeset	3500 /* recompilation */ \
a61af66fc99e Initial load duke parents: diff changeset	3501 product_pd(intx, CompileThreshold, \
a61af66fc99e Initial load duke parents: diff changeset	3502 "number of interpreted method invocations before (re-)compiling") \
a61af66fc99e Initial load duke parents: diff changeset	3503 \
a61af66fc99e Initial load duke parents: diff changeset	3504 product_pd(intx, BackEdgeThreshold, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3505 "Interpreter Back edge threshold at which an OSR compilation is " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3506 "invoked") \
0 a61af66fc99e Initial load duke parents: diff changeset	3507 \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3508 product(intx, Tier0InvokeNotifyFreqLog, 7, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3509 "Interpreter (tier 0) invocation notification frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3510 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3511 product(intx, Tier2InvokeNotifyFreqLog, 11, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3512 "C1 without MDO (tier 2) invocation notification frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3513 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3514 product(intx, Tier3InvokeNotifyFreqLog, 10, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3515 "C1 with MDO profiling (tier 3) invocation notification " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3516 "frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3517 \
3964 dc45ae774613 7096639: Tiered: Incorrect counter overflow handling for inlined methods iveresov parents: 3960 diff changeset	3518 product(intx, Tier23InlineeNotifyFreqLog, 20, \
dc45ae774613 7096639: Tiered: Incorrect counter overflow handling for inlined methods iveresov parents: 3960 diff changeset	3519 "Inlinee invocation (tiers 2 and 3) notification frequency") \
dc45ae774613 7096639: Tiered: Incorrect counter overflow handling for inlined methods iveresov parents: 3960 diff changeset	3520 \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3521 product(intx, Tier0BackedgeNotifyFreqLog, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3522 "Interpreter (tier 0) invocation notification frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3523 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3524 product(intx, Tier2BackedgeNotifyFreqLog, 14, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3525 "C1 without MDO (tier 2) invocation notification frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3526 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3527 product(intx, Tier3BackedgeNotifyFreqLog, 13, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3528 "C1 with MDO profiling (tier 3) invocation notification " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3529 "frequency") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3530 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3531 product(intx, Tier2CompileThreshold, 0, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3532 "threshold at which tier 2 compilation is invoked") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3533 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3534 product(intx, Tier2BackEdgeThreshold, 0, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3535 "Back edge threshold at which tier 2 compilation is invoked") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3536 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3537 product(intx, Tier3InvocationThreshold, 200, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3538 "Compile if number of method invocations crosses this " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3539 "threshold") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3540 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3541 product(intx, Tier3MinInvocationThreshold, 100, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3542 "Minimum invocation to compile at tier 3") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3543 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3544 product(intx, Tier3CompileThreshold, 2000, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3545 "Threshold at which tier 3 compilation is invoked (invocation " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3546 "minimum must be satisfied") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3547 \
4819 dddf0be88eb1 7132945: Tiered: adjust OSR threshold of level 3 iveresov parents: 4807 diff changeset	3548 product(intx, Tier3BackEdgeThreshold, 60000, \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3549 "Back edge threshold at which tier 3 OSR compilation is invoked") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3550 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3551 product(intx, Tier4InvocationThreshold, 5000, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3552 "Compile if number of method invocations crosses this " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3553 "threshold") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3554 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3555 product(intx, Tier4MinInvocationThreshold, 600, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3556 "Minimum invocation to compile at tier 4") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3557 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3558 product(intx, Tier4CompileThreshold, 15000, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3559 "Threshold at which tier 4 compilation is invoked (invocation " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3560 "minimum must be satisfied") \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3561 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3562 product(intx, Tier4BackEdgeThreshold, 40000, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3563 "Back edge threshold at which tier 4 OSR compilation is invoked") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3564 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3565 product(intx, Tier3DelayOn, 5, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3566 "If C2 queue size grows over this amount per compiler thread " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3567 "stop compiling at tier 3 and start compiling at tier 2") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3568 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3569 product(intx, Tier3DelayOff, 2, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3570 "If C2 queue size is less than this amount per compiler thread " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3571 "allow methods compiled at tier 2 transition to tier 3") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3572 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3573 product(intx, Tier3LoadFeedback, 5, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3574 "Tier 3 thresholds will increase twofold when C1 queue size " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3575 "reaches this amount per compiler thread") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3576 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3577 product(intx, Tier4LoadFeedback, 3, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3578 "Tier 4 thresholds will increase twofold when C2 queue size " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3579 "reaches this amount per compiler thread") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3580 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3581 product(intx, TieredCompileTaskTimeout, 50, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3582 "Kill compile task if method was not used within " \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3583 "given timeout in milliseconds") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3584 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3585 product(intx, TieredStopAtLevel, 4, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3586 "Stop at given compilation level") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3587 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3588 product(intx, Tier0ProfilingStartPercentage, 200, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3589 "Start profiling in interpreter if the counters exceed tier 3 " \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3590 "thresholds by the specified percentage") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3591 \
10319 91eba9f82325 8012371: Adjust Tiered compile threshold according to available space in code cache anoll parents: 10293 diff changeset	3592 product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3593 "Increase the compile threshold for C1 compilation if the code " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3594 "cache is filled by the specified percentage") \
10319 91eba9f82325 8012371: Adjust Tiered compile threshold according to available space in code cache anoll parents: 10293 diff changeset	3595 \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3596 product(intx, TieredRateUpdateMinTime, 1, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3597 "Minimum rate sampling interval (in milliseconds)") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3598 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3599 product(intx, TieredRateUpdateMaxTime, 25, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3600 "Maximum rate sampling interval (in milliseconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3601 \
a61af66fc99e Initial load duke parents: diff changeset	3602 product_pd(bool, TieredCompilation, \
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3603 "Enable tiered compilation") \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3604 \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3605 product(bool, PrintTieredEvents, false, \
d5d065957597 6953144: Tiered compilation iveresov parents: 1749 diff changeset	3606 "Print tiered events notifications") \
0 a61af66fc99e Initial load duke parents: diff changeset	3607 \
a61af66fc99e Initial load duke parents: diff changeset	3608 product_pd(intx, OnStackReplacePercentage, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3609 "NON_TIERED number of method invocations/branches (expressed as " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3610 "% of CompileThreshold) before (re-)compiling OSR code") \
0 a61af66fc99e Initial load duke parents: diff changeset	3611 \
a61af66fc99e Initial load duke parents: diff changeset	3612 product(intx, InterpreterProfilePercentage, 33, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3613 "NON_TIERED number of method invocations/branches (expressed as " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3614 "% of CompileThreshold) before profiling in the interpreter") \
0 a61af66fc99e Initial load duke parents: diff changeset	3615 \
a61af66fc99e Initial load duke parents: diff changeset	3616 develop(intx, MaxRecompilationSearchLength, 10, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3617 "The maximum number of frames to inspect when searching for " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3618 "recompilee") \
0 a61af66fc99e Initial load duke parents: diff changeset	3619 \
a61af66fc99e Initial load duke parents: diff changeset	3620 develop(intx, MaxInterpretedSearchLength, 3, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3621 "The maximum number of interpreted frames to skip when searching "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3622 "for recompilee") \
0 a61af66fc99e Initial load duke parents: diff changeset	3623 \
a61af66fc99e Initial load duke parents: diff changeset	3624 develop(intx, DesiredMethodLimit, 8000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3625 "The desired maximum method size (in bytecodes) after inlining") \
0 a61af66fc99e Initial load duke parents: diff changeset	3626 \
a61af66fc99e Initial load duke parents: diff changeset	3627 develop(intx, HugeMethodLimit, 8000, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3628 "Don't compile methods larger than this if " \
0 a61af66fc99e Initial load duke parents: diff changeset	3629 "+DontCompileHugeMethods") \
a61af66fc99e Initial load duke parents: diff changeset	3630 \
a61af66fc99e Initial load duke parents: diff changeset	3631 /* New JDK 1.4 reflection implementation */ \
a61af66fc99e Initial load duke parents: diff changeset	3632 \
a61af66fc99e Initial load duke parents: diff changeset	3633 develop(bool, UseNewReflection, true, \
a61af66fc99e Initial load duke parents: diff changeset	3634 "Temporary flag for transition to reflection based on dynamic " \
a61af66fc99e Initial load duke parents: diff changeset	3635 "bytecode generation in 1.4; can no longer be turned off in 1.4 " \
a61af66fc99e Initial load duke parents: diff changeset	3636 "JDK, and is unneeded in 1.3 JDK, but marks most places VM " \
a61af66fc99e Initial load duke parents: diff changeset	3637 "changes were needed") \
a61af66fc99e Initial load duke parents: diff changeset	3638 \
a61af66fc99e Initial load duke parents: diff changeset	3639 develop(bool, VerifyReflectionBytecodes, false, \
a61af66fc99e Initial load duke parents: diff changeset	3640 "Force verification of 1.4 reflection bytecodes. Does not work " \
a61af66fc99e Initial load duke parents: diff changeset	3641 "in situations like that described in 4486457 or for " \
a61af66fc99e Initial load duke parents: diff changeset	3642 "constructors generated for serialization, so can not be enabled "\
a61af66fc99e Initial load duke parents: diff changeset	3643 "in product.") \
a61af66fc99e Initial load duke parents: diff changeset	3644 \
a61af66fc99e Initial load duke parents: diff changeset	3645 product(bool, ReflectionWrapResolutionErrors, true, \
a61af66fc99e Initial load duke parents: diff changeset	3646 "Temporary flag for transition to AbstractMethodError wrapped " \
a61af66fc99e Initial load duke parents: diff changeset	3647 "in InvocationTargetException. See 6531596") \
a61af66fc99e Initial load duke parents: diff changeset	3648 \
12154 3a1df0dce3e5 8023872: Verification error in generated lambda classes acorn parents: 12132 diff changeset	3649 develop(bool, VerifyLambdaBytecodes, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3650 "Force verification of jdk 8 lambda metafactory bytecodes") \
0 a61af66fc99e Initial load duke parents: diff changeset	3651 \
a61af66fc99e Initial load duke parents: diff changeset	3652 develop(intx, FastSuperclassLimit, 8, \
a61af66fc99e Initial load duke parents: diff changeset	3653 "Depth of hardwired instanceof accelerator array") \
a61af66fc99e Initial load duke parents: diff changeset	3654 \
a61af66fc99e Initial load duke parents: diff changeset	3655 /* Properties for Java libraries */ \
a61af66fc99e Initial load duke parents: diff changeset	3656 \
6199 3f1ab0c19c30 7179383: MaxDirectMemorySize argument parsing is broken for values >2G dholmes parents: 6197 diff changeset	3657 product(uintx, MaxDirectMemorySize, 0, \
0 a61af66fc99e Initial load duke parents: diff changeset	3658 "Maximum total size of NIO direct-buffer allocations") \
a61af66fc99e Initial load duke parents: diff changeset	3659 \
a61af66fc99e Initial load duke parents: diff changeset	3660 /* temporary developer defined flags */ \
a61af66fc99e Initial load duke parents: diff changeset	3661 \
a61af66fc99e Initial load duke parents: diff changeset	3662 diagnostic(bool, UseNewCode, false, \
a61af66fc99e Initial load duke parents: diff changeset	3663 "Testing Only: Use the new version while testing") \
a61af66fc99e Initial load duke parents: diff changeset	3664 \
a61af66fc99e Initial load duke parents: diff changeset	3665 diagnostic(bool, UseNewCode2, false, \
a61af66fc99e Initial load duke parents: diff changeset	3666 "Testing Only: Use the new version while testing") \
a61af66fc99e Initial load duke parents: diff changeset	3667 \
a61af66fc99e Initial load duke parents: diff changeset	3668 diagnostic(bool, UseNewCode3, false, \
a61af66fc99e Initial load duke parents: diff changeset	3669 "Testing Only: Use the new version while testing") \
a61af66fc99e Initial load duke parents: diff changeset	3670 \
a61af66fc99e Initial load duke parents: diff changeset	3671 /* flags for performance data collection */ \
a61af66fc99e Initial load duke parents: diff changeset	3672 \
3797 eb94b7226b7a 7061192: option handling adjustments for oracle and embedded builds jcoomes parents: 3780 diff changeset	3673 product(bool, UsePerfData, falseInEmbedded, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3674 "Flag to disable jvmstat instrumentation for performance testing "\
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3675 "and problem isolation purposes") \
0 a61af66fc99e Initial load duke parents: diff changeset	3676 \
a61af66fc99e Initial load duke parents: diff changeset	3677 product(bool, PerfDataSaveToFile, false, \
a61af66fc99e Initial load duke parents: diff changeset	3678 "Save PerfData memory to hsperfdata_<pid> file on exit") \
a61af66fc99e Initial load duke parents: diff changeset	3679 \
a61af66fc99e Initial load duke parents: diff changeset	3680 product(ccstr, PerfDataSaveFile, NULL, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3681 "Save PerfData memory to the specified absolute pathname. " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3682 "The string %p in the file name (if present) " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3683 "will be replaced by pid") \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3684 \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3685 product(intx, PerfDataSamplingInterval, 50, \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3686 "Data sampling interval (in milliseconds)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3687 \
a61af66fc99e Initial load duke parents: diff changeset	3688 develop(bool, PerfTraceDataCreation, false, \
a61af66fc99e Initial load duke parents: diff changeset	3689 "Trace creation of Performance Data Entries") \
a61af66fc99e Initial load duke parents: diff changeset	3690 \
a61af66fc99e Initial load duke parents: diff changeset	3691 develop(bool, PerfTraceMemOps, false, \
a61af66fc99e Initial load duke parents: diff changeset	3692 "Trace PerfMemory create/attach/detach calls") \
a61af66fc99e Initial load duke parents: diff changeset	3693 \
a61af66fc99e Initial load duke parents: diff changeset	3694 product(bool, PerfDisableSharedMem, false, \
a61af66fc99e Initial load duke parents: diff changeset	3695 "Store performance data in standard memory") \
a61af66fc99e Initial load duke parents: diff changeset	3696 \
a61af66fc99e Initial load duke parents: diff changeset	3697 product(intx, PerfDataMemorySize, 32*K, \
a61af66fc99e Initial load duke parents: diff changeset	3698 "Size of performance data memory region. Will be rounded " \
a61af66fc99e Initial load duke parents: diff changeset	3699 "up to a multiple of the native os page size.") \
a61af66fc99e Initial load duke parents: diff changeset	3700 \
a61af66fc99e Initial load duke parents: diff changeset	3701 product(intx, PerfMaxStringConstLength, 1024, \
a61af66fc99e Initial load duke parents: diff changeset	3702 "Maximum PerfStringConstant string length before truncation") \
a61af66fc99e Initial load duke parents: diff changeset	3703 \
a61af66fc99e Initial load duke parents: diff changeset	3704 product(bool, PerfAllowAtExitRegistration, false, \
a61af66fc99e Initial load duke parents: diff changeset	3705 "Allow registration of atexit() methods") \
a61af66fc99e Initial load duke parents: diff changeset	3706 \
a61af66fc99e Initial load duke parents: diff changeset	3707 product(bool, PerfBypassFileSystemCheck, false, \
a61af66fc99e Initial load duke parents: diff changeset	3708 "Bypass Win32 file system criteria checks (Windows Only)") \
a61af66fc99e Initial load duke parents: diff changeset	3709 \
a61af66fc99e Initial load duke parents: diff changeset	3710 product(intx, UnguardOnExecutionViolation, 0, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3711 "Unguard page and retry on no-execute fault (Win32 only) " \
0 a61af66fc99e Initial load duke parents: diff changeset	3712 "0=off, 1=conservative, 2=aggressive") \
a61af66fc99e Initial load duke parents: diff changeset	3713 \
a61af66fc99e Initial load duke parents: diff changeset	3714 /* Serviceability Support */ \
a61af66fc99e Initial load duke parents: diff changeset	3715 \
a61af66fc99e Initial load duke parents: diff changeset	3716 product(bool, ManagementServer, false, \
a61af66fc99e Initial load duke parents: diff changeset	3717 "Create JMX Management Server") \
a61af66fc99e Initial load duke parents: diff changeset	3718 \
a61af66fc99e Initial load duke parents: diff changeset	3719 product(bool, DisableAttachMechanism, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3720 "Disable mechanism that allows tools to attach to this VM") \
0 a61af66fc99e Initial load duke parents: diff changeset	3721 \
a61af66fc99e Initial load duke parents: diff changeset	3722 product(bool, StartAttachListener, false, \
a61af66fc99e Initial load duke parents: diff changeset	3723 "Always start Attach Listener at VM startup") \
a61af66fc99e Initial load duke parents: diff changeset	3724 \
a61af66fc99e Initial load duke parents: diff changeset	3725 manageable(bool, PrintConcurrentLocks, false, \
a61af66fc99e Initial load duke parents: diff changeset	3726 "Print java.util.concurrent locks in thread dump") \
a61af66fc99e Initial load duke parents: diff changeset	3727 \
2209 e9aa2ca89ad6 7019718: make error reporting flags product instead of diagnostic kamg parents: 2204 diff changeset	3728 product(bool, TransmitErrorReport, false, \
2199 d8a72fbc4be7 7003401: Implement VM error-reporting functionality on erroneous termination kamg parents: 2192 diff changeset	3729 "Enable error report transmission on erroneous termination") \
d8a72fbc4be7 7003401: Implement VM error-reporting functionality on erroneous termination kamg parents: 2192 diff changeset	3730 \
2209 e9aa2ca89ad6 7019718: make error reporting flags product instead of diagnostic kamg parents: 2204 diff changeset	3731 product(ccstr, ErrorReportServer, NULL, \
2199 d8a72fbc4be7 7003401: Implement VM error-reporting functionality on erroneous termination kamg parents: 2192 diff changeset	3732 "Override built-in error report server address") \
d8a72fbc4be7 7003401: Implement VM error-reporting functionality on erroneous termination kamg parents: 2192 diff changeset	3733 \
0 a61af66fc99e Initial load duke parents: diff changeset	3734 /* Shared spaces */ \
a61af66fc99e Initial load duke parents: diff changeset	3735 \
a61af66fc99e Initial load duke parents: diff changeset	3736 product(bool, UseSharedSpaces, true, \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3737 "Use shared spaces for metadata") \
0 a61af66fc99e Initial load duke parents: diff changeset	3738 \
a61af66fc99e Initial load duke parents: diff changeset	3739 product(bool, RequireSharedSpaces, false, \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3740 "Require shared spaces for metadata") \
0 a61af66fc99e Initial load duke parents: diff changeset	3741 \
a61af66fc99e Initial load duke parents: diff changeset	3742 product(bool, DumpSharedSpaces, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3743 "Special mode: JVM reads a class list, loads classes, builds " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3744 "shared spaces, and dumps the shared spaces to a file to be " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3745 "used in future JVM runs") \
0 a61af66fc99e Initial load duke parents: diff changeset	3746 \
a61af66fc99e Initial load duke parents: diff changeset	3747 product(bool, PrintSharedSpaces, false, \
a61af66fc99e Initial load duke parents: diff changeset	3748 "Print usage of shared spaces") \
a61af66fc99e Initial load duke parents: diff changeset	3749 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3750 product(uintx, SharedReadWriteSize, NOT_LP64(12M) LP64_ONLY(16M), \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3751 "Size of read-write space for metadata (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3752 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3753 product(uintx, SharedReadOnlySize, NOT_LP64(12M) LP64_ONLY(16M), \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3754 "Size of read-only space for metadata (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3755 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3756 product(uintx, SharedMiscDataSize, NOT_LP64(2M) LP64_ONLY(4M), \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3757 "Size of the shared miscellaneous data area (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3758 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6633 diff changeset	3759 product(uintx, SharedMiscCodeSize, 120*K, \
7461 561148896559 8005076: Creating a CDS archive with one alignment and running another causes a crash. hseigel parents: 7428 diff changeset	3760 "Size of the shared miscellaneous code area (in bytes)") \
0 a61af66fc99e Initial load duke parents: diff changeset	3761 \
8804 91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8802 diff changeset	3762 product(uintx, SharedBaseAddress, LP64_ONLY(32*G) \
91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8802 diff changeset	3763 NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)), \
91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8802 diff changeset	3764 "Address to allocate shared memory region for class data") \
0 a61af66fc99e Initial load duke parents: diff changeset	3765 \
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2403 diff changeset	3766 diagnostic(bool, EnableInvokeDynamic, true, \
38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2403 diff changeset	3767 "support JSR 292 (method handles, invokedynamic, " \
38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2403 diff changeset	3768 "anonymous classes") \
38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2403 diff changeset	3769 \
3449 a9b8b43b115f 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3418 diff changeset	3770 diagnostic(bool, PrintMethodHandleStubs, false, \
a9b8b43b115f 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3418 diff changeset	3771 "Print generated stub code for method handles") \
a9b8b43b115f 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3418 diff changeset	3772 \
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3773 develop(bool, TraceMethodHandles, false, \
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3774 "trace internal method handle operations") \
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3775 \
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3776 diagnostic(bool, VerifyMethodHandles, trueInDebug, \
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3777 "perform extra checks when constructing method handles") \
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 685 diff changeset	3778 \
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6199 diff changeset	3779 diagnostic(bool, ShowHiddenFrames, false, \
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6199 diff changeset	3780 "show method handle implementation frames (usually hidden)") \
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3384 diff changeset	3781 \
1173 73b22f919c34 6912065: final fields in objects need to support inlining optimizations for JSR 292 jrose parents: 1157 diff changeset	3782 experimental(bool, TrustFinalNonStaticFields, false, \
73b22f919c34 6912065: final fields in objects need to support inlining optimizations for JSR 292 jrose parents: 1157 diff changeset	3783 "trust final non-static declarations for constant folding") \
73b22f919c34 6912065: final fields in objects need to support inlining optimizations for JSR 292 jrose parents: 1157 diff changeset	3784 \
12190 edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12154 diff changeset	3785 experimental(bool, FoldStableValues, false, \
edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12154 diff changeset	3786 "Private flag to control optimizations for stable variables") \
edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12154 diff changeset	3787 \
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 712 diff changeset	3788 develop(bool, TraceInvokeDynamic, false, \
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 712 diff changeset	3789 "trace internal invoke dynamic operations") \
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 712 diff changeset	3790 \
0 a61af66fc99e Initial load duke parents: diff changeset	3791 diagnostic(bool, PauseAtStartup, false, \
a61af66fc99e Initial load duke parents: diff changeset	3792 "Causes the VM to pause at startup time and wait for the pause " \
a61af66fc99e Initial load duke parents: diff changeset	3793 "file to be removed (default: ./vm.paused.<pid>)") \
a61af66fc99e Initial load duke parents: diff changeset	3794 \
a61af66fc99e Initial load duke parents: diff changeset	3795 diagnostic(ccstr, PauseAtStartupFile, NULL, \
a61af66fc99e Initial load duke parents: diff changeset	3796 "The file to create and for whose removal to await when pausing " \
a61af66fc99e Initial load duke parents: diff changeset	3797 "at startup. (default: ./vm.paused.<pid>)") \
a61af66fc99e Initial load duke parents: diff changeset	3798 \
2302 da091bb67459 7022037: Pause when exiting if debugger is attached on windows sla parents: 2265 diff changeset	3799 diagnostic(bool, PauseAtExit, false, \
da091bb67459 7022037: Pause when exiting if debugger is attached on windows sla parents: 2265 diff changeset	3800 "Pause and wait for keypress on exit if a debugger is attached") \
da091bb67459 7022037: Pause when exiting if debugger is attached on windows sla parents: 2265 diff changeset	3801 \
0 a61af66fc99e Initial load duke parents: diff changeset	3802 product(bool, ExtendedDTraceProbes, false, \
a61af66fc99e Initial load duke parents: diff changeset	3803 "Enable performance-impacting dtrace probes") \
a61af66fc99e Initial load duke parents: diff changeset	3804 \
a61af66fc99e Initial load duke parents: diff changeset	3805 product(bool, DTraceMethodProbes, false, \
a61af66fc99e Initial load duke parents: diff changeset	3806 "Enable dtrace probes for method-entry and method-exit") \
a61af66fc99e Initial load duke parents: diff changeset	3807 \
a61af66fc99e Initial load duke parents: diff changeset	3808 product(bool, DTraceAllocProbes, false, \
a61af66fc99e Initial load duke parents: diff changeset	3809 "Enable dtrace probes for object allocation") \
a61af66fc99e Initial load duke parents: diff changeset	3810 \
a61af66fc99e Initial load duke parents: diff changeset	3811 product(bool, DTraceMonitorProbes, false, \
a61af66fc99e Initial load duke parents: diff changeset	3812 "Enable dtrace probes for monitor events") \
a61af66fc99e Initial load duke parents: diff changeset	3813 \
a61af66fc99e Initial load duke parents: diff changeset	3814 product(bool, RelaxAccessControlCheck, false, \
a61af66fc99e Initial load duke parents: diff changeset	3815 "Relax the access control checks in the verifier") \
a61af66fc99e Initial load duke parents: diff changeset	3816 \
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 113 diff changeset	3817 diagnostic(bool, PrintDTraceDOF, false, \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3818 "Print the DTrace DOF passed to the system for JSDT probes") \
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 113 diff changeset	3819 \
6982 e4f764ddb06a 7122219: Passed StringTableSize value not verified hseigel parents: 6935 diff changeset	3820 product(uintx, StringTableSize, defaultStringTableSize, \
2378 924777755fad 6962930: make the string table size configurable jcoomes parents: 2376 diff changeset	3821 "Number of buckets in the interned String table") \
924777755fad 6962930: make the string table size configurable jcoomes parents: 2376 diff changeset	3822 \
12825 c90e76575b03 8019375: Internal symbol table size should be tunable. kevinw parents: 12326 diff changeset	3823 experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
c90e76575b03 8019375: Internal symbol table size should be tunable. kevinw parents: 12326 diff changeset	3824 "Number of buckets in the JVM internal Symbol table") \
c90e76575b03 8019375: Internal symbol table size should be tunable. kevinw parents: 12326 diff changeset	3825 \
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3826 develop(bool, TraceDefaultMethods, false, \
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3827 "Trace the default method processing steps") \
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3828 \
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3829 develop(bool, VerifyGenericSignatures, false, \
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3830 "Abort VM on erroneous or inconsistent generic signatures") \
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6916 diff changeset	3831 \
449 171e581e8161 6554406: Change switch UseVMInterruptibleIO default to false (sol) xlu parents: 443 diff changeset	3832 product(bool, UseVMInterruptibleIO, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	3833 "(Unstable, Solaris-specific) Thread interrupt before or with " \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3834 "EINTR for I/O operations results in OS_INTRPT. The default " \
b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3835 "value of this flag is true for JDK 6 and earlier") \
5915 2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4945 diff changeset	3836 \
2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4945 diff changeset	3837 diagnostic(bool, WhiteBoxAPI, false, \
6064 9d679effd28c 7166894: Add gc cause to GC logging for all collectors brutisso parents: 5979 diff changeset	3838 "Enable internal testing APIs") \
9d679effd28c 7166894: Add gc cause to GC logging for all collectors brutisso parents: 5979 diff changeset	3839 \
9d679effd28c 7166894: Add gc cause to GC logging for all collectors brutisso parents: 5979 diff changeset	3840 product(bool, PrintGCCause, true, \
8702 77443715ec55 8001307: Modify ACC_SUPER behavior kamg parents: 6870 diff changeset	3841 "Include GC cause in GC logging") \
77443715ec55 8001307: Modify ACC_SUPER behavior kamg parents: 6870 diff changeset	3842 \
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3843 product(bool , AllowNonVirtualCalls, false, \
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3844 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3845 \
11596 91e5f927af63 Initial implementation of PTXRuntime (RegisterConfig, PTX description etc); guarded with new flag UseGPU. Specify -XX:+UseGPU to exercise this new implementation. bharadwaj parents: 11173 diff changeset	3846 product(bool, TraceGPUInteraction, false, \
91e5f927af63 Initial implementation of PTXRuntime (RegisterConfig, PTX description etc); guarded with new flag UseGPU. Specify -XX:+UseGPU to exercise this new implementation. bharadwaj parents: 11173 diff changeset	3847 "Trace external GPU Interaction") \
91e5f927af63 Initial implementation of PTXRuntime (RegisterConfig, PTX description etc); guarded with new flag UseGPU. Specify -XX:+UseGPU to exercise this new implementation. bharadwaj parents: 11173 diff changeset	3848 \
12743 f1a55428a8d7 more HSAIL support in the C++ layer for executing HSAIL code on the simulator Doug Simon <doug.simon@oracle.com> parents: 12490 diff changeset	3849 product(bool, UseHSAILSimulator, false, \
f1a55428a8d7 more HSAIL support in the C++ layer for executing HSAIL code on the simulator Doug Simon <doug.simon@oracle.com> parents: 12490 diff changeset	3850 "Run code on HSAIL Simulator") \
f1a55428a8d7 more HSAIL support in the C++ layer for executing HSAIL code on the simulator Doug Simon <doug.simon@oracle.com> parents: 12490 diff changeset	3851 \
10270 f944ba972151 8014138: Add VM option to facilitate the writing of CDS tests hseigel parents: 10269 diff changeset	3852 diagnostic(ccstr, SharedArchiveFile, NULL, \
f944ba972151 8014138: Add VM option to facilitate the writing of CDS tests hseigel parents: 10269 diff changeset	3853 "Override the default location of the CDS archive file") \
f944ba972151 8014138: Add VM option to facilitate the writing of CDS tests hseigel parents: 10269 diff changeset	3854 \
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3855 experimental(uintx, ArrayAllocatorMallocLimit, \
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3856 SOLARIS_ONLY(64*K) NOT_SOLARIS(max_uintx), \
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 9071 diff changeset	3857 "Allocation less than this value will be allocated " \
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3858 "using malloc. Larger allocations will use mmap.") \
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3859 \
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3860 product(bool, EnableTracing, false, \
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3861 "Enable event-based tracing") \
12836 b4d8a3d4db73 8010506: Typos and errors in descriptions of vm options in globals.hpp tamao parents: 12287 diff changeset	3862 \
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3863 product(bool, UseLockedTracing, false, \
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3864 "Use locked-tracing when doing event-based tracing")
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	3865
0 a61af66fc99e Initial load duke parents: diff changeset	3866 /*
a61af66fc99e Initial load duke parents: diff changeset	3867 * Macros for factoring of globals
a61af66fc99e Initial load duke parents: diff changeset	3868 */
a61af66fc99e Initial load duke parents: diff changeset	3869
a61af66fc99e Initial load duke parents: diff changeset	3870 // Interface macros
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3871 #define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3872 #define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3873 #define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name;
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	3874 #define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name;
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3875 #define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3876 #define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name;
0 a61af66fc99e Initial load duke parents: diff changeset	3877 #ifdef PRODUCT
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3878 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type CONST_##name; const type name = value;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3879 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type CONST_##name; const type name = pd_##name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3880 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type CONST_##name;
0 a61af66fc99e Initial load duke parents: diff changeset	3881 #else
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3882 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3883 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3884 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name;
0 a61af66fc99e Initial load duke parents: diff changeset	3885 #endif
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3886 // 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	3887 #ifdef _LP64
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3888 #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	3889 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3890 #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	3891 #endif // _LP64
0 a61af66fc99e Initial load duke parents: diff changeset	3892
a61af66fc99e Initial load duke parents: diff changeset	3893 // Implementation macros
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3894 #define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3895 #define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3896 #define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value;
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	3897 #define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value;
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3898 #define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3899 #define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value;
0 a61af66fc99e Initial load duke parents: diff changeset	3900 #ifdef PRODUCT
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3901 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type CONST_##name = value;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3902 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type CONST_##name = pd_##name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3903 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type CONST_##name = value;
0 a61af66fc99e Initial load duke parents: diff changeset	3904 #else
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3905 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3906 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name;
72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3907 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value;
0 a61af66fc99e Initial load duke parents: diff changeset	3908 #endif
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3909 #ifdef _LP64
12322 72b7e96c1922 8024545: make develop and notproduct flag values available in product builds twisti parents: 12269 diff changeset	3910 #define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3911 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 109 diff changeset	3912 #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	3913 #endif // _LP64
0 a61af66fc99e Initial load duke parents: diff changeset	3914
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 348 diff changeset	3915 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 a61af66fc99e Initial load duke parents: diff changeset	3916
a61af66fc99e Initial load duke parents: diff changeset	3917 RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	3918
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6608 diff changeset	3919 ARCH_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG)
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6608 diff changeset	3920
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	3921 // Extensions
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	3922
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	3923 #include "runtime/globals_ext.hpp"
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	3924
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1890 diff changeset	3925 #endif // SHARE_VM_RUNTIME_GLOBALS_HPP

Mercurial > hg > truffle

annotate src/share/vm/runtime/globals.hpp @ 13212:eb03a7335eb0