| author | lkorinth |
| Wed, 13 Nov 2019 11:37:29 +0100 | |
| changeset 59053 | ba6c248cae19 |
| parent 57777 | 90ead0febf56 |
| child 59115 | a129f10e1b9a |
| permissions | -rw-r--r-- |
|
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 | 28 |
#include "runtime/globals_shared.hpp" |
| 49982 | 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 | 33 |
#if INCLUDE_G1GC |
34 |
#include "gc/g1/g1_globals.hpp" |
|
35 |
#endif |
|
36 |
#if INCLUDE_PARALLELGC |
|
37 |
#include "gc/parallel/parallel_globals.hpp" |
|
38 |
#endif |
|
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 | 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 | 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 | 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 | 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, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
169 |
"Use the Parallel Scavenge garbage collector") \ |
|
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, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
172 |
"Use the Parallel Old garbage collector") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
173 |
\ |
|
50523
7b7c75d87f9b
8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector
shade
parents:
49982
diff
changeset
|
174 |
experimental(bool, UseEpsilonGC, false, \ |
|
7b7c75d87f9b
8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector
shade
parents:
49982
diff
changeset
|
175 |
"Use the Epsilon (no-op) garbage collector") \ |
|
7b7c75d87f9b
8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector
shade
parents:
49982
diff
changeset
|
176 |
\ |
|
50525
767cdb97f103
8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents:
50523
diff
changeset
|
177 |
experimental(bool, UseZGC, false, \ |
|
767cdb97f103
8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents:
50523
diff
changeset
|
178 |
"Use the Z garbage collector") \ |
|
767cdb97f103
8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents:
50523
diff
changeset
|
179 |
\ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
52905
diff
changeset
|
180 |
experimental(bool, UseShenandoahGC, false, \ |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
52905
diff
changeset
|
181 |
"Use the Shenandoah garbage collector") \ |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
52905
diff
changeset
|
182 |
\ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
183 |
product(uint, ParallelGCThreads, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
184 |
"Number of parallel threads parallel gc will use") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
185 |
constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
186 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
187 |
diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
188 |
"Use semaphore synchronization for the GC Threads, " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
189 |
"instead of synchronization based on mutexes") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
190 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
191 |
product(bool, UseDynamicNumberOfGCThreads, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
192 |
"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
|
193 |
"ParallelGCThreads parallel collectors will use for garbage " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
194 |
"collection work") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
195 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
196 |
diagnostic(bool, InjectGCWorkerCreationFailure, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
197 |
"Inject thread creation failures for " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
198 |
"UseDynamicNumberOfGCThreads") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
199 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
200 |
diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
201 |
"Force dynamic selection of the number of " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
202 |
"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
|
203 |
\ |
|
49741
0d8ed8b2ac4f
8200228: Change default value of HeapSizePerGCThread
sjohanss
parents:
49715
diff
changeset
|
204 |
product(size_t, HeapSizePerGCThread, ScaleForWordSize(32*M), \ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
205 |
"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
|
206 |
"number of GC threads") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
207 |
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
|
208 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
209 |
product(uint, ConcGCThreads, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
210 |
"Number of threads concurrent gc will use") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
211 |
constraint(ConcGCThreadsConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
212 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
213 |
product(uint, GCTaskTimeStampEntries, 200, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
214 |
"Number of time stamp entries per gc worker thread") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
215 |
range(1, max_jint) \ |
|
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, AlwaysTenure, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
218 |
"Always tenure objects in eden (ParallelGC only)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
219 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
220 |
product(bool, NeverTenure, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
221 |
"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
|
222 |
"(ParallelGC only)") \ |
|
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, ScavengeBeforeFullGC, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
225 |
"Scavenge youngest generation before each full GC.") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
226 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
227 |
product(bool, ExplicitGCInvokesConcurrent, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
228 |
"A System.gc() request invokes a concurrent collection; " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
229 |
"(effective only when using concurrent collectors)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
230 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
231 |
product(bool, GCLockerInvokesConcurrent, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
232 |
"The exit of a JNI critical section necessitating a scavenge, " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
233 |
"also kicks off a background concurrent collection") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
234 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
235 |
product(uintx, GCLockerEdenExpansionPercent, 5, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
236 |
"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
|
237 |
"is active (as a percentage)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
238 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
239 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
240 |
diagnostic(uintx, GCLockerRetryAllocationCount, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
241 |
"Number of times to retry allocations when " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
242 |
"blocked by the GC locker") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
243 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
244 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
245 |
product(uintx, ParallelGCBufferWastePct, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
246 |
"Wasted fraction of parallel allocation buffer") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
247 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
248 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
249 |
product(uintx, TargetPLABWastePct, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
250 |
"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
|
251 |
"allocation") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
252 |
range(1, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
253 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
254 |
product(uintx, PLABWeight, 75, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
255 |
"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
|
256 |
"computing exponentially decaying average for ResizePLAB") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
257 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
258 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
259 |
product(bool, ResizePLAB, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
260 |
"Dynamically resize (survivor space) promotion LAB's") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
261 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
262 |
product(int, ParGCArrayScanChunk, 50, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
263 |
"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
|
264 |
"bigger than this") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
265 |
range(1, max_jint/3) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
266 |
\ |
|
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 |
product(bool, AlwaysPreTouch, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
269 |
"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
|
270 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
271 |
product(size_t, PreTouchParallelChunkSize, 1 * G, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
272 |
"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
|
273 |
range(1, SIZE_MAX / 2) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
274 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
275 |
/* 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
|
276 |
product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
277 |
"Maximum size of marking stack") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
278 |
range(1, (max_jint - 1)) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
279 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
280 |
product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
281 |
"Size of marking stack") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
282 |
constraint(MarkStackSizeConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
283 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
284 |
product(intx, RefDiscoveryPolicy, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
285 |
"Select type of reference discovery policy: " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
286 |
"reference-based(0) or referent-based(1)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
287 |
range(ReferenceProcessor::DiscoveryPolicyMin, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
288 |
ReferenceProcessor::DiscoveryPolicyMax) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
289 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
290 |
product(bool, ParallelRefProcEnabled, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
291 |
"Enable parallel reference processing whenever possible") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
292 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
293 |
product(bool, ParallelRefProcBalancingEnabled, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
294 |
"Enable balancing of reference processing queues") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
295 |
\ |
|
50606
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
296 |
experimental(size_t, ReferencesPerThread, 1000, \ |
|
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
297 |
"Ergonomically start one thread for this amount of " \ |
|
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
298 |
"references for reference processing if " \ |
|
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
299 |
"ParallelRefProcEnabled is true. Specify 0 to disable and " \ |
|
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
300 |
"use all threads.") \ |
|
8f1d5d706bdd
8043575: Dynamically parallelize reference processing work
tschatzl
parents:
50525
diff
changeset
|
301 |
\ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
302 |
product(uintx, InitiatingHeapOccupancyPercent, 45, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
303 |
"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
|
304 |
"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
|
305 |
"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
|
306 |
"otherwise the value remains constant. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
307 |
"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
|
308 |
"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
|
309 |
"concurrent marking. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
310 |
"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
|
311 |
"free space in this calculation. (G1 collector only)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
312 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
313 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
314 |
notproduct(bool, ScavengeALot, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
315 |
"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
|
316 |
"(N=ScavengeALotInterval)") \ |
|
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 |
develop(bool, FullGCALot, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
319 |
"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
|
320 |
"(N=FullGCALotInterval)") \ |
|
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 |
notproduct(bool, GCALotAtAllSafepoints, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
323 |
"Enforce ScavengeALot/GCALot at all potential safepoints") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
324 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
325 |
notproduct(bool, PromotionFailureALot, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
326 |
"Use promotion failure handling on every youngest generation " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
327 |
"collection") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
328 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
329 |
develop(uintx, PromotionFailureALotCount, 1000, \ |
|
59053
ba6c248cae19
8232365: Implementation for JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector
lkorinth
parents:
57777
diff
changeset
|
330 |
"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
|
331 |
"attempts at young collectors") \ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
332 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
333 |
develop(uintx, PromotionFailureALotInterval, 5, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
334 |
"Total collections between promotion failures a lot") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
335 |
\ |
|
52905
bec57b4a6d69
8204947: Port ShenandoahTaskTerminator to mainline and make it default
zgu
parents:
52396
diff
changeset
|
336 |
diagnostic(bool, UseOWSTTaskTerminator, true, \ |
|
bec57b4a6d69
8204947: Port ShenandoahTaskTerminator to mainline and make it default
zgu
parents:
52396
diff
changeset
|
337 |
"Use Optimized Work Stealing Threads task termination " \ |
|
bec57b4a6d69
8204947: Port ShenandoahTaskTerminator to mainline and make it default
zgu
parents:
52396
diff
changeset
|
338 |
"protocol") \ |
|
bec57b4a6d69
8204947: Port ShenandoahTaskTerminator to mainline and make it default
zgu
parents:
52396
diff
changeset
|
339 |
\ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
340 |
experimental(uintx, WorkStealingSleepMillis, 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
341 |
"Sleep time when sleep is used for yields") \ |
|
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, WorkStealingYieldsBeforeSleep, 5000, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
344 |
"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
|
345 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
346 |
experimental(uintx, WorkStealingHardSpins, 4096, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
347 |
"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
|
348 |
"time out of hard spin") \ |
|
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 |
experimental(uintx, WorkStealingSpinToYieldRatio, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
351 |
"Ratio of hard spins to calls to yield") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
352 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
353 |
develop(uintx, ObjArrayMarkingStride, 2048, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
354 |
"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
|
355 |
"before pushing a continuation entry") \ |
|
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 |
develop(bool, MetadataAllocationFailALot, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
358 |
"Fail metadata allocations at intervals controlled by " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
359 |
"MetadataAllocationFailALotInterval") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
360 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
361 |
develop(uintx, MetadataAllocationFailALotInterval, 1000, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
362 |
"Metadata allocation failure a lot interval") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
363 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
364 |
product(bool, ExecutingUnitTests, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
365 |
"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
|
366 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
367 |
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
|
368 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
369 |
product_pd(bool, ResizeTLAB, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
370 |
"Dynamically resize TLAB size for threads") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
371 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
372 |
product(bool, ZeroTLAB, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
373 |
"Zero out the newly created TLAB") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
374 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
375 |
product(bool, TLABStats, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
376 |
"Provide more detailed and expensive TLAB statistics.") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
377 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
378 |
product_pd(bool, NeverActAsServerClassMachine, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
379 |
"Never act like a server-class machine") \ |
|
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, AlwaysActAsServerClassMachine, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
382 |
"Always act like a server-class machine") \ |
|
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_pd(uint64_t, MaxRAM, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
385 |
"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
|
386 |
range(0, 0XFFFFFFFFFFFFFFFF) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
387 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
388 |
product(bool, AggressiveHeap, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
389 |
"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
|
390 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
391 |
product(size_t, ErgoHeapSizeLimit, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
392 |
"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
|
393 |
"MaxRAM * MaxRAMPercentage / 100") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
394 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
395 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
396 |
product(uintx, MaxRAMFraction, 4, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
397 |
"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
|
398 |
"size. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
399 |
"Deprecated, use MaxRAMPercentage instead") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
400 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
401 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
402 |
product(uintx, MinRAMFraction, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
403 |
"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
|
404 |
"size on systems with small physical memory size. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
405 |
"Deprecated, use MinRAMPercentage instead") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
406 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
407 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
408 |
product(uintx, InitialRAMFraction, 64, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
409 |
"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
|
410 |
"Deprecated, use InitialRAMPercentage instead") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
411 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
412 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
413 |
product(double, MaxRAMPercentage, 25.0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
414 |
"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
|
415 |
range(0.0, 100.0) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
416 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
417 |
product(double, MinRAMPercentage, 50.0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
418 |
"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
|
419 |
"size on systems with small physical memory size") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
420 |
range(0.0, 100.0) \ |
|
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 |
product(double, InitialRAMPercentage, 1.5625, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
423 |
"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
|
424 |
range(0.0, 100.0) \ |
|
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(int, ActiveProcessorCount, -1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
427 |
"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
|
428 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
429 |
develop(uintx, MaxVirtMemFraction, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
430 |
"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
|
431 |
"determining maximum heap size") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
432 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
433 |
product(bool, UseAdaptiveSizePolicy, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
434 |
"Use adaptive generation sizing policies") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
435 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
436 |
product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
437 |
"Use adaptive survivor sizing policies") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
438 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
439 |
product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
440 |
"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
|
441 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
442 |
product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
443 |
"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
|
444 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
445 |
product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
446 |
"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
|
447 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
448 |
product(bool, UseAdaptiveGCBoundary, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
449 |
"Allow young-old boundary to move") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
450 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
451 |
develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
452 |
"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
|
453 |
range(-1, 1) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
454 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
455 |
product(uintx, AdaptiveSizeThroughPutPolicy, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
456 |
"Policy for changing generation size for throughput goals") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
457 |
range(0, 1) \ |
|
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, AdaptiveSizePolicyInitializingSteps, 20, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
460 |
"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
|
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 |
develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
464 |
"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
|
465 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
466 |
product(uintx, AdaptiveSizePolicyOutputInterval, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
467 |
"Collection interval for printing information; zero means never") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
468 |
range(0, max_uintx) \ |
|
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(bool, UseAdaptiveSizePolicyFootprintGoal, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
471 |
"Use adaptive minimum footprint as a goal") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
472 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
473 |
product(uintx, AdaptiveSizePolicyWeight, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
474 |
"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
|
475 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
476 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
477 |
product(uintx, AdaptiveTimeWeight, 25, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
478 |
"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
|
479 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
480 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
481 |
product(uintx, PausePadding, 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
482 |
"How much buffer to keep for pause time") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
483 |
range(0, max_juint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
484 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
485 |
product(uintx, PromotedPadding, 3, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
486 |
"How much buffer to keep for promotion failure") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
487 |
range(0, max_juint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
488 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
489 |
product(uintx, SurvivorPadding, 3, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
490 |
"How much buffer to keep for survivor overflow") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
491 |
range(0, max_juint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
492 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
493 |
product(uintx, ThresholdTolerance, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
494 |
"Allowed collection cost difference between generations") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
495 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
496 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
497 |
product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
498 |
"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
|
499 |
"delta") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
500 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
501 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
502 |
product(uintx, YoungGenerationSizeIncrement, 20, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
503 |
"Adaptive size percentage change in young generation") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
504 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
505 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
506 |
product(uintx, YoungGenerationSizeSupplement, 80, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
507 |
"Supplement to YoungedGenerationSizeIncrement used at startup") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
508 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
509 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
510 |
product(uintx, YoungGenerationSizeSupplementDecay, 8, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
511 |
"Decay factor to YoungedGenerationSizeSupplement") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
512 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
513 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
514 |
product(uintx, TenuredGenerationSizeIncrement, 20, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
515 |
"Adaptive size percentage change in tenured generation") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
516 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
517 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
518 |
product(uintx, TenuredGenerationSizeSupplement, 80, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
519 |
"Supplement to TenuredGenerationSizeIncrement used at startup") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
520 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
521 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
522 |
product(uintx, TenuredGenerationSizeSupplementDecay, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
523 |
"Decay factor to TenuredGenerationSizeIncrement") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
524 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
525 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
526 |
product(uintx, MaxGCPauseMillis, max_uintx - 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
527 |
"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
|
528 |
"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
|
529 |
range(1, max_uintx - 1) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
530 |
constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
531 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
532 |
product(uintx, GCPauseIntervalMillis, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
533 |
"Time slice for MMU specification") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
534 |
constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
535 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
536 |
product(uintx, MaxGCMinorPauseMillis, max_uintx, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
537 |
"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
|
538 |
"in millisecond") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
539 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
540 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
541 |
product(uintx, GCTimeRatio, 99, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
542 |
"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
|
543 |
range(0, max_juint) \ |
|
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, AdaptiveSizeDecrementScaleFactor, 4, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
546 |
"Adaptive size scale down factor for shrinking") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
547 |
range(1, 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(bool, UseAdaptiveSizeDecayMajorGCCost, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
550 |
"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
|
551 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
552 |
product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
553 |
"Time scale over which major costs decay") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
554 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
555 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
556 |
product(uintx, MinSurvivorRatio, 3, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
557 |
"Minimum ratio of young generation/survivor space size") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
558 |
range(3, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
559 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
560 |
product(uintx, InitialSurvivorRatio, 8, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
561 |
"Initial ratio of young generation/survivor space size") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
562 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
563 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
564 |
product(size_t, BaseFootPrintEstimate, 256*M, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
565 |
"Estimate of footprint other than Java Heap") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
566 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
567 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
568 |
product(bool, UseGCOverheadLimit, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
569 |
"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
|
570 |
"before an OutOfMemory error is thrown") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
571 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
572 |
product(uintx, GCTimeLimit, 98, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
573 |
"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
|
574 |
"an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
575 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
576 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
577 |
product(uintx, GCHeapFreeLimit, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
578 |
"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
|
579 |
"OutOfMemoryError is thrown (used with GCTimeLimit)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
580 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
581 |
\ |
|
54085
ab87b06dfdc0
8212206: Refactor AdaptiveSizePolicy to separate out code related to GC overhead
manc
parents:
52925
diff
changeset
|
582 |
develop(uintx, GCOverheadLimitThreshold, 5, \ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
583 |
"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
|
584 |
range(1, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
585 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
586 |
product(intx, PrefetchCopyIntervalInBytes, -1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
587 |
"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
|
588 |
range(-1, max_jint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
589 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
590 |
product(intx, PrefetchScanIntervalInBytes, -1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
591 |
"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
|
592 |
range(-1, max_jint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
593 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
594 |
product(intx, PrefetchFieldsAhead, -1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
595 |
"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
|
596 |
range(-1, max_jint) \ |
|
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, VerifyDuringStartup, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
599 |
"Verify memory system before executing any Java code " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
600 |
"during VM initialization") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
601 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
602 |
diagnostic(bool, VerifyBeforeExit, trueInDebug, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
603 |
"Verify system before exiting") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
604 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
605 |
diagnostic(bool, VerifyBeforeGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
606 |
"Verify memory system before GC") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
607 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
608 |
diagnostic(bool, VerifyAfterGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
609 |
"Verify memory system after GC") \ |
|
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(bool, VerifyDuringGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
612 |
"Verify memory system during GC (between phases)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
613 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
614 |
diagnostic(ccstrlist, VerifyGCType, "", \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
615 |
"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
|
616 |
"Available types are collector specific.") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
617 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
618 |
diagnostic(ccstrlist, VerifySubSet, "", \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
619 |
"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
|
620 |
"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
|
621 |
"in a comma separated string. Sub-systems are: " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
622 |
"threads, heap, symbol_table, string_table, codecache, " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
623 |
"dictionary, classloader_data_graph, metaspace, jni_handles, " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
624 |
"codecache_oops") \ |
|
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 |
diagnostic(bool, GCParallelVerificationEnabled, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
627 |
"Enable parallel memory system verification") \ |
|
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, DeferInitialCardMark, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
630 |
"When +ReduceInitialCardMarks, explicitly defer any that " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
631 |
"may arise from new_pre_store_barrier") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
632 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
633 |
product(bool, UseCondCardMark, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
634 |
"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
|
635 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
636 |
diagnostic(bool, VerifyRememberedSets, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
637 |
"Verify GC remembered sets") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
638 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
639 |
diagnostic(bool, VerifyObjectStartArray, true, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
640 |
"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
|
641 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
642 |
product(bool, DisableExplicitGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
643 |
"Ignore calls to System.gc()") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
644 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
645 |
product(bool, PrintGC, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
646 |
"Print message at garbage collection. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
647 |
"Deprecated, use -Xlog:gc instead.") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
648 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
649 |
product(bool, PrintGCDetails, false, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
650 |
"Print more details at garbage collection. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
651 |
"Deprecated, use -Xlog:gc* instead.") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
652 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
653 |
develop(intx, ConcGCYieldTimeout, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
654 |
"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
|
655 |
"number of milliseconds") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
656 |
range(0, max_intx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
657 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
658 |
notproduct(intx, ScavengeALotInterval, 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
659 |
"Interval between which scavenge will occur with +ScavengeALot") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
660 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
661 |
notproduct(intx, FullGCALotInterval, 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
662 |
"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
|
663 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
664 |
notproduct(intx, FullGCALotStart, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
665 |
"For which invocation to start FullGCAlot") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
666 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
667 |
notproduct(intx, FullGCALotDummies, 32*K, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
668 |
"Dummy object allocated with +FullGCALot, forcing all objects " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
669 |
"to move") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
670 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
671 |
/* gc parameters */ \ |
|
55308
871bc449ce06
8223837: Add -XX:MinHeapSize flag to set the minimum heap size
stefank
parents:
55283
diff
changeset
|
672 |
product(size_t, MinHeapSize, 0, \ |
|
871bc449ce06
8223837: Add -XX:MinHeapSize flag to set the minimum heap size
stefank
parents:
55283
diff
changeset
|
673 |
"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
|
674 |
constraint(MinHeapSizeConstraintFunc,AfterErgo) \ |
|
871bc449ce06
8223837: Add -XX:MinHeapSize flag to set the minimum heap size
stefank
parents:
55283
diff
changeset
|
675 |
\ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
676 |
product(size_t, InitialHeapSize, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
677 |
"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
|
678 |
constraint(InitialHeapSizeConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
679 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
680 |
product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
681 |
"Maximum heap size (in bytes)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
682 |
constraint(MaxHeapSizeConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
683 |
\ |
| 55283 | 684 |
manageable(size_t, SoftMaxHeapSize, 0, \ |
685 |
"Soft limit for maximum heap size (in bytes)") \ |
|
686 |
constraint(SoftMaxHeapSizeConstraintFunc,AfterMemoryInit) \ |
|
687 |
\ |
|
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
688 |
product(size_t, OldSize, ScaleForWordSize(4*M), \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
689 |
"Initial tenured generation size (in bytes)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
690 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
691 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
692 |
product(size_t, NewSize, ScaleForWordSize(1*M), \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
693 |
"Initial new generation size (in bytes)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
694 |
constraint(NewSizeConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
695 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
696 |
product(size_t, MaxNewSize, max_uintx, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
697 |
"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
|
698 |
"ergonomically") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
699 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
700 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
701 |
product_pd(size_t, HeapBaseMinAddress, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
702 |
"OS specific low limit for heap base address") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
703 |
constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
704 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
705 |
product(size_t, PretenureSizeThreshold, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
706 |
"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
|
707 |
"generation; zero means no maximum") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
708 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
709 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
710 |
product(size_t, MinTLABSize, 2*K, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
711 |
"Minimum allowed TLAB size (in bytes)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
712 |
range(1, max_uintx/2) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
713 |
constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
714 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
715 |
product(size_t, TLABSize, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
716 |
"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
|
717 |
constraint(TLABSizeConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
718 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
719 |
product(size_t, YoungPLABSize, 4096, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
720 |
"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
|
721 |
constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
722 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
723 |
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
|
724 |
"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
|
725 |
constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
726 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
727 |
product(uintx, TLABAllocationWeight, 35, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
728 |
"Allocation averaging weight") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
729 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
730 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
731 |
/* 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
|
732 |
/* in a division expression. */ \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
733 |
product(uintx, TLABWasteTargetPercent, 1, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
734 |
"Percentage of Eden that can be wasted") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
735 |
range(1, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
736 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
737 |
product(uintx, TLABRefillWasteFraction, 64, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
738 |
"Maximum TLAB waste at a refill (internal fragmentation)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
739 |
range(1, max_juint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
740 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
741 |
product(uintx, TLABWasteIncrement, 4, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
742 |
"Increment allowed waste at slow allocation") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
743 |
range(0, max_jint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
744 |
constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
745 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
746 |
product(uintx, SurvivorRatio, 8, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
747 |
"Ratio of eden/survivor space size") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
748 |
range(1, max_uintx-2) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
749 |
constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
750 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
751 |
product(uintx, NewRatio, 2, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
752 |
"Ratio of old/new generation sizes") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
753 |
range(0, max_uintx-1) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
754 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
755 |
product_pd(size_t, NewSizeThreadIncrease, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
756 |
"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
|
757 |
"non-daemon thread (in bytes)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
758 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
759 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
760 |
product(uintx, QueuedAllocationWarningCount, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
761 |
"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
|
762 |
"will retry before printing a warning") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
763 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
764 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
765 |
diagnostic(uintx, VerifyGCStartAt, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
766 |
"GC invoke count where +VerifyBefore/AfterGC kicks in") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
767 |
range(0, max_uintx) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
768 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
769 |
diagnostic(intx, VerifyGCLevel, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
770 |
"Generation level at which to start +VerifyBefore/AfterGC") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
771 |
range(0, 1) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
772 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
773 |
product(uintx, MaxTenuringThreshold, 15, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
774 |
"Maximum value for tenuring threshold") \ |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
57774
diff
changeset
|
775 |
range(0, markWord::max_age + 1) \ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
776 |
constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
777 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
778 |
product(uintx, InitialTenuringThreshold, 7, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
779 |
"Initial value for tenuring threshold") \ |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
57774
diff
changeset
|
780 |
range(0, markWord::max_age + 1) \ |
|
49715
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
781 |
constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
782 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
783 |
product(uintx, TargetSurvivorRatio, 50, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
784 |
"Desired percentage of survivor space used after scavenge") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
785 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
786 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
787 |
product(uintx, MarkSweepDeadRatio, 5, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
788 |
"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
|
789 |
"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
|
790 |
"value. " \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
791 |
"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
|
792 |
"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
|
793 |
"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
|
794 |
"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
|
795 |
range(0, 100) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
796 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
797 |
product(uint, MarkSweepAlwaysCompactCount, 4, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
798 |
"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
|
799 |
"space parameters)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
800 |
range(1, max_juint) \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
801 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
802 |
develop(uintx, GCExpandToAllocateDelayMillis, 0, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
803 |
"Delay between expansion and allocation (in milliseconds)") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
804 |
\ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
805 |
product(uintx, GCDrainStackTargetSize, 64, \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
806 |
"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
|
807 |
"during parallel gc") \ |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
808 |
range(0, max_juint) |
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
809 |
|
|
947560700a09
8201136: Move GC flags from globals.hpp to GC specific files
stefank
parents:
diff
changeset
|
810 |
#endif // SHARE_GC_SHARED_GC_GLOBALS_HPP |