jdk-sandbox: src/hotspot/share/gc/shared/gc_globals.hpp@3b1afeb49a20 (annotated)

49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	1	/*
54085 ab87b06dfdc0 8212206: Refactor AdaptiveSizePolicy to separate out code related to GC overhead manc parents: 52925 diff changeset	2	* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	4	*
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	5	* This code is free software; you can redistribute it and/or modify it
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	6	* under the terms of the GNU General Public License version 2 only, as
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	7	* published by the Free Software Foundation.
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	8	*
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	9	* This code is distributed in the hope that it will be useful, but WITHOUT
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	12	* version 2 for more details (a copy is included in the LICENSE file that
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	13	* accompanied this code).
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	14	*
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	15	* You should have received a copy of the GNU General Public License version
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	16	* 2 along with this work; if not, write to the Free Software Foundation,
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	18	*
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	20	* or visit www.oracle.com if you need additional information or have any
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	21	* questions.
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	22	*
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	23	*/
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	24
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	25	#ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	26	#define SHARE_GC_SHARED_GC_GLOBALS_HPP
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	27
54982 b18c8301b8c2 8224201: Simplify JVM flag macro expansions stefank parents: 54085 diff changeset	28	#include "runtime/globals_shared.hpp"
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	29	#include "utilities/macros.hpp"
50523 7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	30	#if INCLUDE_EPSILONGC
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	31	#include "gc/epsilon/epsilon_globals.hpp"
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	32	#endif
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	33	#if INCLUDE_G1GC
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	34	#include "gc/g1/g1_globals.hpp"
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	35	#endif
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	36	#if INCLUDE_PARALLELGC
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	37	#include "gc/parallel/parallel_globals.hpp"
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	38	#endif
9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	39	#if INCLUDE_SERIALGC
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	40	#include "gc/serial/serial_globals.hpp"
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	41	#endif
52925 9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	42	#if INCLUDE_SHENANDOAHGC
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	43	#include "gc/shenandoah/shenandoah_globals.hpp"
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	44	#endif
50525 767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	45	#if INCLUDE_ZGC
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	46	#include "gc/z/z_globals.hpp"
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	47	#endif
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	48
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	49	#define GC_FLAGS(develop, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	50	develop_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	51	product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	52	product_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	53	diagnostic, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	54	diagnostic_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	55	experimental, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	56	notproduct, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	57	manageable, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	58	product_rw, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	59	lp64_product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	60	range, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	61	constraint, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	62	writeable) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	63	\
50523 7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	64	EPSILONGC_ONLY(GC_EPSILON_FLAGS( \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	65	develop, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	66	develop_pd, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	67	product, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	68	product_pd, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	69	diagnostic, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	70	diagnostic_pd, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	71	experimental, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	72	notproduct, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	73	manageable, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	74	product_rw, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	75	lp64_product, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	76	range, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	77	constraint, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	78	writeable)) \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	79	\
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	80	G1GC_ONLY(GC_G1_FLAGS( \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	81	develop, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	82	develop_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	83	product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	84	product_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	85	diagnostic, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	86	diagnostic_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	87	experimental, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	88	notproduct, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	89	manageable, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	90	product_rw, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	91	lp64_product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	92	range, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	93	constraint, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	94	writeable)) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	95	\
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	96	PARALLELGC_ONLY(GC_PARALLEL_FLAGS( \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	97	develop, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	98	develop_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	99	product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	100	product_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	101	diagnostic, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	102	diagnostic_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	103	experimental, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	104	notproduct, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	105	manageable, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	106	product_rw, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	107	lp64_product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	108	range, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	109	constraint, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	110	writeable)) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	111	\
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	112	SERIALGC_ONLY(GC_SERIAL_FLAGS( \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	113	develop, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	114	develop_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	115	product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	116	product_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	117	diagnostic, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	118	diagnostic_pd, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	119	experimental, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	120	notproduct, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	121	manageable, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	122	product_rw, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	123	lp64_product, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	124	range, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	125	constraint, \
49982 9042ffe5b7fe 8200729: Conditional compilation of GCs stefank parents: 49741 diff changeset	126	writeable)) \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	127	\
52925 9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	128	SHENANDOAHGC_ONLY(GC_SHENANDOAH_FLAGS( \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	129	develop, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	130	develop_pd, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	131	product, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	132	product_pd, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	133	diagnostic, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	134	diagnostic_pd, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	135	experimental, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	136	notproduct, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	137	manageable, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	138	product_rw, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	139	lp64_product, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	140	range, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	141	constraint, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	142	writeable)) \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	143	\
50525 767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	144	ZGC_ONLY(GC_Z_FLAGS( \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	145	develop, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	146	develop_pd, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	147	product, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	148	product_pd, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	149	diagnostic, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	150	diagnostic_pd, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	151	experimental, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	152	notproduct, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	153	manageable, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	154	product_rw, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	155	lp64_product, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	156	range, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	157	constraint, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	158	writeable)) \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	159	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	160	/* gc */ \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	161	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	162	product(bool, UseSerialGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	163	"Use the Serial garbage collector") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	164	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	165	product(bool, UseG1GC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	166	"Use the Garbage-First garbage collector") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	167	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	168	product(bool, UseParallelGC, false, \
59288 3b1afeb49a20 8233301: Implementation of JEP 366: Deprecate the ParallelScavenge + SerialOld GC Combination tschatzl parents: 59241 diff changeset	169	"Use the Parallel garbage collector.") \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	170	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	171	product(bool, UseParallelOldGC, false, \
59288 3b1afeb49a20 8233301: Implementation of JEP 366: Deprecate the ParallelScavenge + SerialOld GC Combination tschatzl parents: 59241 diff changeset	172	"Use the Parallel or Serial garbage collector when collecting " \
3b1afeb49a20 8233301: Implementation of JEP 366: Deprecate the ParallelScavenge + SerialOld GC Combination tschatzl parents: 59241 diff changeset	173	"the old generation. Deprecated.") \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	174	\
50523 7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	175	experimental(bool, UseEpsilonGC, false, \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	176	"Use the Epsilon (no-op) garbage collector") \
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector shade parents: 49982 diff changeset	177	\
50525 767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	178	experimental(bool, UseZGC, false, \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	179	"Use the Z garbage collector") \
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental) pliden parents: 50523 diff changeset	180	\
52925 9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	181	experimental(bool, UseShenandoahGC, false, \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	182	"Use the Shenandoah garbage collector") \
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) rkennke parents: 52905 diff changeset	183	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	184	product(uint, ParallelGCThreads, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	185	"Number of parallel threads parallel gc will use") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	186	constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	187	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	188	diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	189	"Use semaphore synchronization for the GC Threads, " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	190	"instead of synchronization based on mutexes") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	191	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	192	product(bool, UseDynamicNumberOfGCThreads, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	193	"Dynamically choose the number of threads up to a maximum of " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	194	"ParallelGCThreads parallel collectors will use for garbage " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	195	"collection work") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	196	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	197	diagnostic(bool, InjectGCWorkerCreationFailure, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	198	"Inject thread creation failures for " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	199	"UseDynamicNumberOfGCThreads") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	200	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	201	diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	202	"Force dynamic selection of the number of " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	203	"parallel threads parallel gc will use to aid debugging") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	204	\
49741 0d8ed8b2ac4f 8200228: Change default value of HeapSizePerGCThread sjohanss parents: 49715 diff changeset	205	product(size_t, HeapSizePerGCThread, ScaleForWordSize(32*M), \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	206	"Size of heap (bytes) per GC thread used in calculating the " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	207	"number of GC threads") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	208	range((size_t)os::vm_page_size(), (size_t)max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	209	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	210	product(uint, ConcGCThreads, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	211	"Number of threads concurrent gc will use") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	212	constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	213	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	214	product(bool, AlwaysTenure, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	215	"Always tenure objects in eden (ParallelGC only)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	216	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	217	product(bool, NeverTenure, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	218	"Never tenure objects in eden, may tenure on overflow " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	219	"(ParallelGC only)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	220	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	221	product(bool, ScavengeBeforeFullGC, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	222	"Scavenge youngest generation before each full GC.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	223	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	224	product(bool, ExplicitGCInvokesConcurrent, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	225	"A System.gc() request invokes a concurrent collection; " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	226	"(effective only when using concurrent collectors)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	227	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	228	product(uintx, GCLockerEdenExpansionPercent, 5, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	229	"How much the GC can expand the eden by while the GC locker " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	230	"is active (as a percentage)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	231	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	232	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	233	diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	234	"Number of times to retry allocations when " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	235	"blocked by the GC locker") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	236	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	237	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	238	product(uintx, ParallelGCBufferWastePct, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	239	"Wasted fraction of parallel allocation buffer") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	240	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	241	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	242	product(uintx, TargetPLABWastePct, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	243	"Target wasted space in last buffer as percent of overall " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	244	"allocation") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	245	range(1, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	246	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	247	product(uintx, PLABWeight, 75, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	248	"Percentage (0-100) used to weight the current sample when " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	249	"computing exponentially decaying average for ResizePLAB") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	250	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	251	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	252	product(bool, ResizePLAB, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	253	"Dynamically resize (survivor space) promotion LAB's") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	254	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	255	product(int, ParGCArrayScanChunk, 50, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	256	"Scan a subset of object array and push remainder, if array is " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	257	"bigger than this") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	258	range(1, max_jint/3) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	259	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	260	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	261	product(bool, AlwaysPreTouch, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	262	"Force all freshly committed pages to be pre-touched") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	263	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	264	product(size_t, PreTouchParallelChunkSize, 1 * G, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	265	"Per-thread chunk size for parallel memory pre-touch.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	266	range(1, SIZE_MAX / 2) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	267	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	268	/* where does the range max value of (max_jint - 1) come from? */ \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	269	product(size_t, MarkStackSizeMax, NOT_LP64(4M) LP64_ONLY(512M), \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	270	"Maximum size of marking stack") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	271	range(1, (max_jint - 1)) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	272	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	273	product(size_t, MarkStackSize, NOT_LP64(32K) LP64_ONLY(4M), \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	274	"Size of marking stack") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	275	constraint(MarkStackSizeConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	276	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	277	product(intx, RefDiscoveryPolicy, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	278	"Select type of reference discovery policy: " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	279	"reference-based(0) or referent-based(1)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	280	range(ReferenceProcessor::DiscoveryPolicyMin, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	281	ReferenceProcessor::DiscoveryPolicyMax) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	282	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	283	product(bool, ParallelRefProcEnabled, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	284	"Enable parallel reference processing whenever possible") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	285	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	286	product(bool, ParallelRefProcBalancingEnabled, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	287	"Enable balancing of reference processing queues") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	288	\
50606 8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	289	experimental(size_t, ReferencesPerThread, 1000, \
8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	290	"Ergonomically start one thread for this amount of " \
8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	291	"references for reference processing if " \
8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	292	"ParallelRefProcEnabled is true. Specify 0 to disable and " \
8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	293	"use all threads.") \
8f1d5d706bdd 8043575: Dynamically parallelize reference processing work tschatzl parents: 50525 diff changeset	294	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	295	product(uintx, InitiatingHeapOccupancyPercent, 45, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	296	"The percent occupancy (IHOP) of the current old generation " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	297	"capacity above which a concurrent mark cycle will be initiated " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	298	"Its value may change over time if adaptive IHOP is enabled, " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	299	"otherwise the value remains constant. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	300	"In the latter case a value of 0 will result as frequent as " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	301	"possible concurrent marking cycles. A value of 100 disables " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	302	"concurrent marking. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	303	"Fragmentation waste in the old generation is not considered " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	304	"free space in this calculation. (G1 collector only)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	305	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	306	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	307	notproduct(bool, ScavengeALot, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	308	"Force scavenge at every Nth exit from the runtime system " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	309	"(N=ScavengeALotInterval)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	310	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	311	develop(bool, FullGCALot, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	312	"Force full gc at every Nth exit from the runtime system " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	313	"(N=FullGCALotInterval)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	314	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	315	notproduct(bool, GCALotAtAllSafepoints, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	316	"Enforce ScavengeALot/GCALot at all potential safepoints") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	317	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	318	notproduct(bool, PromotionFailureALot, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	319	"Use promotion failure handling on every youngest generation " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	320	"collection") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	321	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	322	develop(uintx, PromotionFailureALotCount, 1000, \
59053 ba6c248cae19 8232365: Implementation for JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector lkorinth parents: 57777 diff changeset	323	"Number of promotion failures occurring at PLAB promotion " \
ba6c248cae19 8232365: Implementation for JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector lkorinth parents: 57777 diff changeset	324	"attempts at young collectors") \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	325	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	326	develop(uintx, PromotionFailureALotInterval, 5, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	327	"Total collections between promotion failures a lot") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	328	\
52905 bec57b4a6d69 8204947: Port ShenandoahTaskTerminator to mainline and make it default zgu parents: 52396 diff changeset	329	diagnostic(bool, UseOWSTTaskTerminator, true, \
bec57b4a6d69 8204947: Port ShenandoahTaskTerminator to mainline and make it default zgu parents: 52396 diff changeset	330	"Use Optimized Work Stealing Threads task termination " \
bec57b4a6d69 8204947: Port ShenandoahTaskTerminator to mainline and make it default zgu parents: 52396 diff changeset	331	"protocol") \
bec57b4a6d69 8204947: Port ShenandoahTaskTerminator to mainline and make it default zgu parents: 52396 diff changeset	332	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	333	experimental(uintx, WorkStealingSleepMillis, 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	334	"Sleep time when sleep is used for yields") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	335	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	336	experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	337	"Number of yields before a sleep is done during work stealing") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	338	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	339	experimental(uintx, WorkStealingHardSpins, 4096, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	340	"Number of iterations in a spin loop between checks on " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	341	"time out of hard spin") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	342	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	343	experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	344	"Ratio of hard spins to calls to yield") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	345	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	346	develop(uintx, ObjArrayMarkingStride, 2048, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	347	"Number of object array elements to push onto the marking stack " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	348	"before pushing a continuation entry") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	349	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	350	develop(bool, MetadataAllocationFailALot, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	351	"Fail metadata allocations at intervals controlled by " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	352	"MetadataAllocationFailALotInterval") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	353	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	354	develop(uintx, MetadataAllocationFailALotInterval, 1000, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	355	"Metadata allocation failure a lot interval") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	356	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	357	product(bool, ExecutingUnitTests, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	358	"Whether the JVM is running unit tests or not") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	359	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	360	product_pd(bool, UseTLAB, "Use thread-local object allocation") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	361	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	362	product_pd(bool, ResizeTLAB, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	363	"Dynamically resize TLAB size for threads") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	364	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	365	product(bool, ZeroTLAB, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	366	"Zero out the newly created TLAB") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	367	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	368	product(bool, TLABStats, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	369	"Provide more detailed and expensive TLAB statistics.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	370	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	371	product_pd(bool, NeverActAsServerClassMachine, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	372	"Never act like a server-class machine") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	373	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	374	product(bool, AlwaysActAsServerClassMachine, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	375	"Always act like a server-class machine") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	376	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	377	product_pd(uint64_t, MaxRAM, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	378	"Real memory size (in bytes) used to set maximum heap size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	379	range(0, 0XFFFFFFFFFFFFFFFF) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	380	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	381	product(bool, AggressiveHeap, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	382	"Optimize heap options for long-running memory intensive apps") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	383	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	384	product(size_t, ErgoHeapSizeLimit, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	385	"Maximum ergonomically set heap size (in bytes); zero means use " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	386	"MaxRAM * MaxRAMPercentage / 100") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	387	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	388	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	389	product(uintx, MaxRAMFraction, 4, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	390	"Maximum fraction (1/n) of real memory used for maximum heap " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	391	"size. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	392	"Deprecated, use MaxRAMPercentage instead") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	393	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	394	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	395	product(uintx, MinRAMFraction, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	396	"Minimum fraction (1/n) of real memory used for maximum heap " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	397	"size on systems with small physical memory size. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	398	"Deprecated, use MinRAMPercentage instead") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	399	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	400	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	401	product(uintx, InitialRAMFraction, 64, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	402	"Fraction (1/n) of real memory used for initial heap size. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	403	"Deprecated, use InitialRAMPercentage instead") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	404	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	405	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	406	product(double, MaxRAMPercentage, 25.0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	407	"Maximum percentage of real memory used for maximum heap size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	408	range(0.0, 100.0) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	409	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	410	product(double, MinRAMPercentage, 50.0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	411	"Minimum percentage of real memory used for maximum heap" \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	412	"size on systems with small physical memory size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	413	range(0.0, 100.0) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	414	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	415	product(double, InitialRAMPercentage, 1.5625, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	416	"Percentage of real memory used for initial heap size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	417	range(0.0, 100.0) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	418	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	419	product(int, ActiveProcessorCount, -1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	420	"Specify the CPU count the VM should use and report as active") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	421	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	422	develop(uintx, MaxVirtMemFraction, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	423	"Maximum fraction (1/n) of virtual memory used for ergonomically "\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	424	"determining maximum heap size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	425	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	426	product(bool, UseAdaptiveSizePolicy, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	427	"Use adaptive generation sizing policies") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	428	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	429	product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	430	"Use adaptive survivor sizing policies") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	431	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	432	product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	433	"Use adaptive young-old sizing policies at minor collections") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	434	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	435	product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	436	"Use adaptive young-old sizing policies at major collections") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	437	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	438	product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	439	"Include statistics from System.gc() for adaptive size policy") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	440	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	441	product(bool, UseAdaptiveGCBoundary, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	442	"Allow young-old boundary to move") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	443	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	444	develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	445	"Resize the virtual spaces of the young or old generations") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	446	range(-1, 1) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	447	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	448	product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	449	"Policy for changing generation size for throughput goals") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	450	range(0, 1) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	451	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	452	product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	453	"Number of steps where heuristics is used before data is used") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	454	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	455	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	456	develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	457	"Number of collections before the adaptive sizing is started") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	458	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	459	product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	460	"Collection interval for printing information; zero means never") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	461	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	462	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	463	product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	464	"Use adaptive minimum footprint as a goal") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	465	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	466	product(uintx, AdaptiveSizePolicyWeight, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	467	"Weight given to exponential resizing, between 0 and 100") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	468	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	469	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	470	product(uintx, AdaptiveTimeWeight, 25, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	471	"Weight given to time in adaptive policy, between 0 and 100") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	472	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	473	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	474	product(uintx, PausePadding, 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	475	"How much buffer to keep for pause time") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	476	range(0, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	477	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	478	product(uintx, PromotedPadding, 3, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	479	"How much buffer to keep for promotion failure") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	480	range(0, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	481	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	482	product(uintx, SurvivorPadding, 3, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	483	"How much buffer to keep for survivor overflow") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	484	range(0, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	485	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	486	product(uintx, ThresholdTolerance, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	487	"Allowed collection cost difference between generations") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	488	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	489	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	490	product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	491	"If collection costs are within margin, reduce both by full " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	492	"delta") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	493	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	494	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	495	product(uintx, YoungGenerationSizeIncrement, 20, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	496	"Adaptive size percentage change in young generation") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	497	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	498	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	499	product(uintx, YoungGenerationSizeSupplement, 80, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	500	"Supplement to YoungedGenerationSizeIncrement used at startup") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	501	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	502	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	503	product(uintx, YoungGenerationSizeSupplementDecay, 8, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	504	"Decay factor to YoungedGenerationSizeSupplement") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	505	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	506	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	507	product(uintx, TenuredGenerationSizeIncrement, 20, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	508	"Adaptive size percentage change in tenured generation") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	509	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	510	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	511	product(uintx, TenuredGenerationSizeSupplement, 80, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	512	"Supplement to TenuredGenerationSizeIncrement used at startup") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	513	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	514	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	515	product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	516	"Decay factor to TenuredGenerationSizeIncrement") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	517	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	518	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	519	product(uintx, MaxGCPauseMillis, max_uintx - 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	520	"Adaptive size policy maximum GC pause time goal in millisecond, "\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	521	"or (G1 Only) the maximum GC time per MMU time slice") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	522	range(1, max_uintx - 1) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	523	constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	524	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	525	product(uintx, GCPauseIntervalMillis, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	526	"Time slice for MMU specification") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	527	constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	528	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	529	product(uintx, MaxGCMinorPauseMillis, max_uintx, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	530	"Adaptive size policy maximum GC minor pause time goal " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	531	"in millisecond") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	532	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	533	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	534	product(uintx, GCTimeRatio, 99, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	535	"Adaptive size policy application time to GC time ratio") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	536	range(0, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	537	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	538	product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	539	"Adaptive size scale down factor for shrinking") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	540	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	541	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	542	product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	543	"Adaptive size decays the major cost for long major intervals") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	544	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	545	product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	546	"Time scale over which major costs decay") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	547	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	548	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	549	product(uintx, MinSurvivorRatio, 3, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	550	"Minimum ratio of young generation/survivor space size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	551	range(3, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	552	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	553	product(uintx, InitialSurvivorRatio, 8, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	554	"Initial ratio of young generation/survivor space size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	555	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	556	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	557	product(size_t, BaseFootPrintEstimate, 256*M, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	558	"Estimate of footprint other than Java Heap") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	559	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	560	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	561	product(bool, UseGCOverheadLimit, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	562	"Use policy to limit of proportion of time spent in GC " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	563	"before an OutOfMemory error is thrown") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	564	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	565	product(uintx, GCTimeLimit, 98, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	566	"Limit of the proportion of time spent in GC before " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	567	"an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	568	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	569	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	570	product(uintx, GCHeapFreeLimit, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	571	"Minimum percentage of free space after a full GC before an " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	572	"OutOfMemoryError is thrown (used with GCTimeLimit)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	573	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	574	\
54085 ab87b06dfdc0 8212206: Refactor AdaptiveSizePolicy to separate out code related to GC overhead manc parents: 52925 diff changeset	575	develop(uintx, GCOverheadLimitThreshold, 5, \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	576	"Number of consecutive collections before gc time limit fires") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	577	range(1, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	578	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	579	product(intx, PrefetchCopyIntervalInBytes, -1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	580	"How far ahead to prefetch destination area (<= 0 means off)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	581	range(-1, max_jint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	582	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	583	product(intx, PrefetchScanIntervalInBytes, -1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	584	"How far ahead to prefetch scan area (<= 0 means off)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	585	range(-1, max_jint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	586	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	587	product(intx, PrefetchFieldsAhead, -1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	588	"How many fields ahead to prefetch in oop scan (<= 0 means off)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	589	range(-1, max_jint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	590	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	591	diagnostic(bool, VerifyDuringStartup, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	592	"Verify memory system before executing any Java code " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	593	"during VM initialization") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	594	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	595	diagnostic(bool, VerifyBeforeExit, trueInDebug, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	596	"Verify system before exiting") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	597	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	598	diagnostic(bool, VerifyBeforeGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	599	"Verify memory system before GC") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	600	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	601	diagnostic(bool, VerifyAfterGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	602	"Verify memory system after GC") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	603	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	604	diagnostic(bool, VerifyDuringGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	605	"Verify memory system during GC (between phases)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	606	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	607	diagnostic(ccstrlist, VerifyGCType, "", \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	608	"GC type(s) to verify when Verify*GC is enabled." \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	609	"Available types are collector specific.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	610	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	611	diagnostic(ccstrlist, VerifySubSet, "", \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	612	"Memory sub-systems to verify when Verify*GC flag(s) " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	613	"are enabled. One or more sub-systems can be specified " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	614	"in a comma separated string. Sub-systems are: " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	615	"threads, heap, symbol_table, string_table, codecache, " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	616	"dictionary, classloader_data_graph, metaspace, jni_handles, " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	617	"codecache_oops") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	618	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	619	diagnostic(bool, GCParallelVerificationEnabled, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	620	"Enable parallel memory system verification") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	621	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	622	diagnostic(bool, DeferInitialCardMark, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	623	"When +ReduceInitialCardMarks, explicitly defer any that " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	624	"may arise from new_pre_store_barrier") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	625	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	626	product(bool, UseCondCardMark, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	627	"Check for already marked card before updating card table") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	628	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	629	diagnostic(bool, VerifyRememberedSets, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	630	"Verify GC remembered sets") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	631	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	632	diagnostic(bool, VerifyObjectStartArray, true, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	633	"Verify GC object start array if verify before/after") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	634	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	635	product(bool, DisableExplicitGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	636	"Ignore calls to System.gc()") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	637	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	638	product(bool, PrintGC, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	639	"Print message at garbage collection. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	640	"Deprecated, use -Xlog:gc instead.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	641	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	642	product(bool, PrintGCDetails, false, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	643	"Print more details at garbage collection. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	644	"Deprecated, use -Xlog:gc* instead.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	645	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	646	develop(intx, ConcGCYieldTimeout, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	647	"If non-zero, assert that GC threads yield within this " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	648	"number of milliseconds") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	649	range(0, max_intx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	650	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	651	notproduct(intx, ScavengeALotInterval, 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	652	"Interval between which scavenge will occur with +ScavengeALot") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	653	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	654	notproduct(intx, FullGCALotInterval, 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	655	"Interval between which full gc will occur with +FullGCALot") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	656	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	657	notproduct(intx, FullGCALotStart, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	658	"For which invocation to start FullGCAlot") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	659	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	660	notproduct(intx, FullGCALotDummies, 32*K, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	661	"Dummy object allocated with +FullGCALot, forcing all objects " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	662	"to move") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	663	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	664	/* gc parameters */ \
55308 871bc449ce06 8223837: Add -XX:MinHeapSize flag to set the minimum heap size stefank parents: 55283 diff changeset	665	product(size_t, MinHeapSize, 0, \
871bc449ce06 8223837: Add -XX:MinHeapSize flag to set the minimum heap size stefank parents: 55283 diff changeset	666	"Minimum heap size (in bytes); zero means use ergonomics") \
871bc449ce06 8223837: Add -XX:MinHeapSize flag to set the minimum heap size stefank parents: 55283 diff changeset	667	constraint(MinHeapSizeConstraintFunc,AfterErgo) \
871bc449ce06 8223837: Add -XX:MinHeapSize flag to set the minimum heap size stefank parents: 55283 diff changeset	668	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	669	product(size_t, InitialHeapSize, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	670	"Initial heap size (in bytes); zero means use ergonomics") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	671	constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	672	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	673	product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	674	"Maximum heap size (in bytes)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	675	constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	676	\
55283 4556dd808daa 8222145: Add -XX:SoftMaxHeapSize flag pliden parents: 54982 diff changeset	677	manageable(size_t, SoftMaxHeapSize, 0, \
4556dd808daa 8222145: Add -XX:SoftMaxHeapSize flag pliden parents: 54982 diff changeset	678	"Soft limit for maximum heap size (in bytes)") \
4556dd808daa 8222145: Add -XX:SoftMaxHeapSize flag pliden parents: 54982 diff changeset	679	constraint(SoftMaxHeapSizeConstraintFunc,AfterMemoryInit) \
4556dd808daa 8222145: Add -XX:SoftMaxHeapSize flag pliden parents: 54982 diff changeset	680	\
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	681	product(size_t, OldSize, ScaleForWordSize(4*M), \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	682	"Initial tenured generation size (in bytes)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	683	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	684	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	685	product(size_t, NewSize, ScaleForWordSize(1*M), \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	686	"Initial new generation size (in bytes)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	687	constraint(NewSizeConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	688	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	689	product(size_t, MaxNewSize, max_uintx, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	690	"Maximum new generation size (in bytes), max_uintx means set " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	691	"ergonomically") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	692	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	693	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	694	product_pd(size_t, HeapBaseMinAddress, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	695	"OS specific low limit for heap base address") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	696	constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	697	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	698	product(size_t, PretenureSizeThreshold, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	699	"Maximum size in bytes of objects allocated in DefNew " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	700	"generation; zero means no maximum") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	701	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	702	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	703	product(size_t, MinTLABSize, 2*K, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	704	"Minimum allowed TLAB size (in bytes)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	705	range(1, max_uintx/2) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	706	constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	707	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	708	product(size_t, TLABSize, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	709	"Starting TLAB size (in bytes); zero means set ergonomically") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	710	constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	711	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	712	product(size_t, YoungPLABSize, 4096, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	713	"Size of young gen promotion LAB's (in HeapWords)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	714	constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	715	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	716	product(size_t, OldPLABSize, 1024, \
59053 ba6c248cae19 8232365: Implementation for JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector lkorinth parents: 57777 diff changeset	717	"Size of old gen promotion LAB's (in HeapWords)") \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	718	constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	719	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	720	product(uintx, TLABAllocationWeight, 35, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	721	"Allocation averaging weight") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	722	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	723	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	724	/* Limit the lower bound of this flag to 1 as it is used */ \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	725	/* in a division expression. */ \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	726	product(uintx, TLABWasteTargetPercent, 1, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	727	"Percentage of Eden that can be wasted") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	728	range(1, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	729	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	730	product(uintx, TLABRefillWasteFraction, 64, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	731	"Maximum TLAB waste at a refill (internal fragmentation)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	732	range(1, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	733	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	734	product(uintx, TLABWasteIncrement, 4, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	735	"Increment allowed waste at slow allocation") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	736	range(0, max_jint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	737	constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	738	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	739	product(uintx, SurvivorRatio, 8, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	740	"Ratio of eden/survivor space size") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	741	range(1, max_uintx-2) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	742	constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	743	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	744	product(uintx, NewRatio, 2, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	745	"Ratio of old/new generation sizes") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	746	range(0, max_uintx-1) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	747	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	748	product_pd(size_t, NewSizeThreadIncrease, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	749	"Additional size added to desired new generation size per " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	750	"non-daemon thread (in bytes)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	751	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	752	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	753	product(uintx, QueuedAllocationWarningCount, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	754	"Number of times an allocation that queues behind a GC " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	755	"will retry before printing a warning") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	756	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	757	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	758	diagnostic(uintx, VerifyGCStartAt, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	759	"GC invoke count where +VerifyBefore/AfterGC kicks in") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	760	range(0, max_uintx) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	761	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	762	diagnostic(intx, VerifyGCLevel, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	763	"Generation level at which to start +VerifyBefore/AfterGC") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	764	range(0, 1) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	765	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	766	product(uintx, MaxTenuringThreshold, 15, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	767	"Maximum value for tenuring threshold") \
57777 90ead0febf56 8229258: Rework markOop and markOopDesc into a simpler mark word value carrier stefank parents: 57774 diff changeset	768	range(0, markWord::max_age + 1) \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	769	constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	770	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	771	product(uintx, InitialTenuringThreshold, 7, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	772	"Initial value for tenuring threshold") \
57777 90ead0febf56 8229258: Rework markOop and markOopDesc into a simpler mark word value carrier stefank parents: 57774 diff changeset	773	range(0, markWord::max_age + 1) \
49715 947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	774	constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	775	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	776	product(uintx, TargetSurvivorRatio, 50, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	777	"Desired percentage of survivor space used after scavenge") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	778	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	779	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	780	product(uintx, MarkSweepDeadRatio, 5, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	781	"Percentage (0-100) of the old gen allowed as dead wood. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	782	"Serial mark sweep treats this as both the minimum and maximum " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	783	"value. " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	784	"Par compact uses a variable scale based on the density of the " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	785	"generation and treats this as the maximum value when the heap " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	786	"is either completely full or completely empty. Par compact " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	787	"also has a smaller default value; see arguments.cpp.") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	788	range(0, 100) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	789	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	790	product(uint, MarkSweepAlwaysCompactCount, 4, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	791	"How often should we fully compact the heap (ignoring the dead " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	792	"space parameters)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	793	range(1, max_juint) \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	794	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	795	develop(uintx, GCExpandToAllocateDelayMillis, 0, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	796	"Delay between expansion and allocation (in milliseconds)") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	797	\
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	798	product(uintx, GCDrainStackTargetSize, 64, \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	799	"Number of entries we will try to leave on the stack " \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	800	"during parallel gc") \
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	801	range(0, max_juint)
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	802
947560700a09 8201136: Move GC flags from globals.hpp to GC specific files stefank parents: diff changeset	803	#endif // SHARE_GC_SHARED_GC_GLOBALS_HPP

author	tschatzl
	Wed, 27 Nov 2019 10:19:45 +0100
changeset 59288	3b1afeb49a20
parent 59241	23ecaf949f8f
permissions	-rw-r--r--