Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/collectorPolicy.cpp @ 10239:f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
Summary: Make sure max alignemnt is at least as large as min alignment
Reviewed-by: johnc, jmasa, tschatzl
author | brutisso |
---|---|
date | Mon, 06 May 2013 09:16:14 +0200 |
parents | 5a9fa2ba85f0 |
children | d17700c82d7d |
rev | line source |
---|---|
0 | 1 /* |
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "gc_implementation/shared/adaptiveSizePolicy.hpp" | |
27 #include "gc_implementation/shared/gcPolicyCounters.hpp" | |
28 #include "gc_implementation/shared/vmGCOperations.hpp" | |
29 #include "memory/cardTableRS.hpp" | |
30 #include "memory/collectorPolicy.hpp" | |
31 #include "memory/gcLocker.inline.hpp" | |
32 #include "memory/genCollectedHeap.hpp" | |
33 #include "memory/generationSpec.hpp" | |
34 #include "memory/space.hpp" | |
35 #include "memory/universe.hpp" | |
36 #include "runtime/arguments.hpp" | |
37 #include "runtime/globals_extension.hpp" | |
38 #include "runtime/handles.inline.hpp" | |
39 #include "runtime/java.hpp" | |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6923
diff
changeset
|
40 #include "runtime/thread.inline.hpp" |
1972 | 41 #include "runtime/vmThread.hpp" |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7451
diff
changeset
|
42 #include "utilities/macros.hpp" |
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7451
diff
changeset
|
43 #if INCLUDE_ALL_GCS |
1972 | 44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" |
45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7451
diff
changeset
|
46 #endif // INCLUDE_ALL_GCS |
0 | 47 |
48 // CollectorPolicy methods. | |
49 | |
50 void CollectorPolicy::initialize_flags() { | |
10239
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
51 assert(max_alignment() >= min_alignment(), |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
52 err_msg("max_alignment: " SIZE_FORMAT " less than min_alignment: " SIZE_FORMAT, |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
53 max_alignment(), min_alignment())); |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
54 assert(max_alignment() % min_alignment() == 0, |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
55 err_msg("max_alignment: " SIZE_FORMAT " not aligned by min_alignment: " SIZE_FORMAT, |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
56 max_alignment(), min_alignment())); |
f14063dcd52a
8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment
brutisso
parents:
10135
diff
changeset
|
57 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
58 if (MetaspaceSize > MaxMetaspaceSize) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
59 MaxMetaspaceSize = MetaspaceSize; |
0 | 60 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
61 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment())); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
62 // Don't increase Metaspace size limit above specified. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
63 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
64 if (MetaspaceSize > MaxMetaspaceSize) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
65 MetaspaceSize = MaxMetaspaceSize; |
1795
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
66 } |
0 | 67 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
68 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment())); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
69 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment())); |
0 | 70 |
71 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment()); | |
72 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
73 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
74 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
75 if (MetaspaceSize < 256*K) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
76 vm_exit_during_initialization("Too small initial Metaspace size"); |
0 | 77 } |
78 } | |
79 | |
80 void CollectorPolicy::initialize_size_info() { | |
81 // User inputs from -mx and ms are aligned | |
1064 | 82 set_initial_heap_byte_size(InitialHeapSize); |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
83 if (initial_heap_byte_size() == 0) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
84 set_initial_heap_byte_size(NewSize + OldSize); |
0 | 85 } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
86 set_initial_heap_byte_size(align_size_up(_initial_heap_byte_size, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
87 min_alignment())); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
88 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
89 set_min_heap_byte_size(Arguments::min_heap_size()); |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
90 if (min_heap_byte_size() == 0) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
91 set_min_heap_byte_size(NewSize + OldSize); |
0 | 92 } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
93 set_min_heap_byte_size(align_size_up(_min_heap_byte_size, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
94 min_alignment())); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
95 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
96 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment())); |
0 | 97 |
98 // Check heap parameter properties | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
99 if (initial_heap_byte_size() < M) { |
0 | 100 vm_exit_during_initialization("Too small initial heap"); |
101 } | |
102 // Check heap parameter properties | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
103 if (min_heap_byte_size() < M) { |
0 | 104 vm_exit_during_initialization("Too small minimum heap"); |
105 } | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
106 if (initial_heap_byte_size() <= NewSize) { |
0 | 107 // make sure there is at least some room in old space |
108 vm_exit_during_initialization("Too small initial heap for new size specified"); | |
109 } | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
110 if (max_heap_byte_size() < min_heap_byte_size()) { |
0 | 111 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified"); |
112 } | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
113 if (initial_heap_byte_size() < min_heap_byte_size()) { |
0 | 114 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified"); |
115 } | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
116 if (max_heap_byte_size() < initial_heap_byte_size()) { |
0 | 117 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified"); |
118 } | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
119 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
120 if (PrintGCDetails && Verbose) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
121 gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
122 SIZE_FORMAT " Maximum heap " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
123 min_heap_byte_size(), initial_heap_byte_size(), max_heap_byte_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
124 } |
0 | 125 } |
126 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
127 bool CollectorPolicy::use_should_clear_all_soft_refs(bool v) { |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
128 bool result = _should_clear_all_soft_refs; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
129 set_should_clear_all_soft_refs(false); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
130 return result; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
131 } |
0 | 132 |
133 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap, | |
134 int max_covered_regions) { | |
135 switch (rem_set_name()) { | |
136 case GenRemSet::CardTable: { | |
137 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions); | |
138 return res; | |
139 } | |
140 default: | |
141 guarantee(false, "unrecognized GenRemSet::Name"); | |
142 return NULL; | |
143 } | |
144 } | |
145 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
146 void CollectorPolicy::cleared_all_soft_refs() { |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
147 // If near gc overhear limit, continue to clear SoftRefs. SoftRefs may |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
148 // have been cleared in the last collection but if the gc overhear |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
149 // limit continues to be near, SoftRefs should still be cleared. |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
150 if (size_policy() != NULL) { |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
151 _should_clear_all_soft_refs = size_policy()->gc_overhead_limit_near(); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
152 } |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
153 _all_soft_refs_clear = true; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
154 } |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
155 |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
156 |
0 | 157 // GenCollectorPolicy methods. |
158 | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
159 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
160 size_t x = base_size / (NewRatio+1); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
161 size_t new_gen_size = x > min_alignment() ? |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
162 align_size_down(x, min_alignment()) : |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
163 min_alignment(); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
164 return new_gen_size; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
165 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
166 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
167 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
168 size_t maximum_size) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
169 size_t alignment = min_alignment(); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
170 size_t max_minus = maximum_size - alignment; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
171 return desired_size < max_minus ? desired_size : max_minus; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
172 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
173 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
174 |
0 | 175 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size, |
176 size_t init_promo_size, | |
177 size_t init_survivor_size) { | |
8072
fd7b3770c77e
8007764: Wrong initialized value of max_gc_pause_sec for an instance of class AdaptiveSizePolicy
tamao
parents:
8016
diff
changeset
|
178 const double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0; |
0 | 179 _size_policy = new AdaptiveSizePolicy(init_eden_size, |
180 init_promo_size, | |
181 init_survivor_size, | |
8072
fd7b3770c77e
8007764: Wrong initialized value of max_gc_pause_sec for an instance of class AdaptiveSizePolicy
tamao
parents:
8016
diff
changeset
|
182 max_gc_pause_sec, |
0 | 183 GCTimeRatio); |
184 } | |
185 | |
186 size_t GenCollectorPolicy::compute_max_alignment() { | |
187 // The card marking array and the offset arrays for old generations are | |
188 // committed in os pages as well. Make sure they are entirely full (to | |
189 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1 | |
190 // byte entry and the os page size is 4096, the maximum heap size should | |
191 // be 512*4096 = 2MB aligned. | |
192 size_t alignment = GenRemSet::max_alignment_constraint(rem_set_name()); | |
193 | |
194 // Parallel GC does its own alignment of the generations to avoid requiring a | |
195 // large page (256M on some platforms) for the permanent generation. The | |
196 // other collectors should also be updated to do their own alignment and then | |
197 // this use of lcm() should be removed. | |
198 if (UseLargePages && !UseParallelGC) { | |
199 // in presence of large pages we have to make sure that our | |
200 // alignment is large page aware | |
201 alignment = lcm(os::large_page_size(), alignment); | |
202 } | |
203 | |
204 return alignment; | |
205 } | |
206 | |
207 void GenCollectorPolicy::initialize_flags() { | |
208 // All sizes must be multiples of the generation granularity. | |
209 set_min_alignment((uintx) Generation::GenGrain); | |
210 set_max_alignment(compute_max_alignment()); | |
211 | |
212 CollectorPolicy::initialize_flags(); | |
213 | |
214 // All generational heaps have a youngest gen; handle those flags here. | |
215 | |
216 // Adjust max size parameters | |
217 if (NewSize > MaxNewSize) { | |
218 MaxNewSize = NewSize; | |
219 } | |
220 NewSize = align_size_down(NewSize, min_alignment()); | |
221 MaxNewSize = align_size_down(MaxNewSize, min_alignment()); | |
222 | |
223 // Check validity of heap flags | |
224 assert(NewSize % min_alignment() == 0, "eden space alignment"); | |
225 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment"); | |
226 | |
227 if (NewSize < 3*min_alignment()) { | |
228 // make sure there room for eden and two survivor spaces | |
229 vm_exit_during_initialization("Too small new size specified"); | |
230 } | |
231 if (SurvivorRatio < 1 || NewRatio < 1) { | |
232 vm_exit_during_initialization("Invalid heap ratio specified"); | |
233 } | |
234 } | |
235 | |
236 void TwoGenerationCollectorPolicy::initialize_flags() { | |
237 GenCollectorPolicy::initialize_flags(); | |
238 | |
239 OldSize = align_size_down(OldSize, min_alignment()); | |
240 if (NewSize + OldSize > MaxHeapSize) { | |
241 MaxHeapSize = NewSize + OldSize; | |
242 } | |
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
243 |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
244 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) { |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
245 // NewRatio will be used later to set the young generation size so we use |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
246 // it to calculate how big the heap should be based on the requested OldSize |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
247 // and NewRatio. |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
248 assert(NewRatio > 0, "NewRatio should have been set up earlier"); |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
249 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1); |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
250 |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
251 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment()); |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
252 MaxHeapSize = calculated_heapsize; |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
253 InitialHeapSize = calculated_heapsize; |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
254 } |
0 | 255 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); |
256 | |
257 always_do_update_barrier = UseConcMarkSweepGC; | |
258 | |
259 // Check validity of heap flags | |
260 assert(OldSize % min_alignment() == 0, "old space alignment"); | |
261 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment"); | |
262 } | |
263 | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
264 // Values set on the command line win over any ergonomically |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
265 // set command line parameters. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
266 // Ergonomic choice of parameters are done before this |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
267 // method is called. Values for command line parameters such as NewSize |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
268 // and MaxNewSize feed those ergonomic choices into this method. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
269 // This method makes the final generation sizings consistent with |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
270 // themselves and with overall heap sizings. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
271 // In the absence of explicitly set command line flags, policies |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
272 // such as the use of NewRatio are used to size the generation. |
0 | 273 void GenCollectorPolicy::initialize_size_info() { |
274 CollectorPolicy::initialize_size_info(); | |
275 | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
276 // min_alignment() is used for alignment within a generation. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
277 // There is additional alignment done down stream for some |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
278 // collectors that sometimes causes unwanted rounding up of |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
279 // generations sizes. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
280 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
281 // Determine maximum size of gen0 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
282 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
283 size_t max_new_size = 0; |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
284 if (FLAG_IS_CMDLINE(MaxNewSize) || FLAG_IS_ERGO(MaxNewSize)) { |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
285 if (MaxNewSize < min_alignment()) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
286 max_new_size = min_alignment(); |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
287 } |
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
288 if (MaxNewSize >= max_heap_byte_size()) { |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
289 max_new_size = align_size_down(max_heap_byte_size() - min_alignment(), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
290 min_alignment()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
291 warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or " |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
292 "greater than the entire heap (" SIZE_FORMAT "k). A " |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
293 "new generation size of " SIZE_FORMAT "k will be used.", |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
294 MaxNewSize/K, max_heap_byte_size()/K, max_new_size/K); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
295 } else { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
296 max_new_size = align_size_down(MaxNewSize, min_alignment()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
297 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
298 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
299 // The case for FLAG_IS_ERGO(MaxNewSize) could be treated |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
300 // specially at this point to just use an ergonomically set |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
301 // MaxNewSize to set max_new_size. For cases with small |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
302 // heaps such a policy often did not work because the MaxNewSize |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
303 // was larger than the entire heap. The interpretation given |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
304 // to ergonomically set flags is that the flags are set |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
305 // by different collectors for their own special needs but |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
306 // are not allowed to badly shape the heap. This allows the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
307 // different collectors to decide what's best for themselves |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
308 // without having to factor in the overall heap shape. It |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
309 // can be the case in the future that the collectors would |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
310 // only make "wise" ergonomics choices and this policy could |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
311 // just accept those choices. The choices currently made are |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
312 // not always "wise". |
0 | 313 } else { |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
314 max_new_size = scale_by_NewRatio_aligned(max_heap_byte_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
315 // Bound the maximum size by NewSize below (since it historically |
0 | 316 // would have been NewSize and because the NewRatio calculation could |
317 // yield a size that is too small) and bound it by MaxNewSize above. | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
318 // Ergonomics plays here by previously calculating the desired |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
319 // NewSize and MaxNewSize. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
320 max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
321 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
322 assert(max_new_size > 0, "All paths should set max_new_size"); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
323 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
324 // Given the maximum gen0 size, determine the initial and |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
325 // minimum gen0 sizes. |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
326 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
327 if (max_heap_byte_size() == min_heap_byte_size()) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
328 // The maximum and minimum heap sizes are the same so |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
329 // the generations minimum and initial must be the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
330 // same as its maximum. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
331 set_min_gen0_size(max_new_size); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
332 set_initial_gen0_size(max_new_size); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
333 set_max_gen0_size(max_new_size); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
334 } else { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
335 size_t desired_new_size = 0; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
336 if (!FLAG_IS_DEFAULT(NewSize)) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
337 // If NewSize is set ergonomically (for example by cms), it |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
338 // would make sense to use it. If it is used, also use it |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
339 // to set the initial size. Although there is no reason |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
340 // the minimum size and the initial size have to be the same, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
341 // the current implementation gets into trouble during the calculation |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
342 // of the tenured generation sizes if they are different. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
343 // Note that this makes the initial size and the minimum size |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
344 // generally small compared to the NewRatio calculation. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
345 _min_gen0_size = NewSize; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
346 desired_new_size = NewSize; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
347 max_new_size = MAX2(max_new_size, NewSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
348 } else { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
349 // For the case where NewSize is the default, use NewRatio |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
350 // to size the minimum and initial generation sizes. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
351 // Use the default NewSize as the floor for these values. If |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
352 // NewRatio is overly large, the resulting sizes can be too |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
353 // small. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
354 _min_gen0_size = MAX2(scale_by_NewRatio_aligned(min_heap_byte_size()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
355 NewSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
356 desired_new_size = |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
357 MAX2(scale_by_NewRatio_aligned(initial_heap_byte_size()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
358 NewSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
359 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
360 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
361 assert(_min_gen0_size > 0, "Sanity check"); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
362 set_initial_gen0_size(desired_new_size); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
363 set_max_gen0_size(max_new_size); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
364 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
365 // At this point the desirable initial and minimum sizes have been |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
366 // determined without regard to the maximum sizes. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
367 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
368 // Bound the sizes by the corresponding overall heap sizes. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
369 set_min_gen0_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
370 bound_minus_alignment(_min_gen0_size, min_heap_byte_size())); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
371 set_initial_gen0_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
372 bound_minus_alignment(_initial_gen0_size, initial_heap_byte_size())); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
373 set_max_gen0_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
374 bound_minus_alignment(_max_gen0_size, max_heap_byte_size())); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
375 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
376 // At this point all three sizes have been checked against the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
377 // maximum sizes but have not been checked for consistency |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
378 // among the three. |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
379 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
380 // Final check min <= initial <= max |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
381 set_min_gen0_size(MIN2(_min_gen0_size, _max_gen0_size)); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
382 set_initial_gen0_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
383 MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size)); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
384 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size)); |
0 | 385 } |
386 | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
387 if (PrintGCDetails && Verbose) { |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
388 gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT " Initial gen0 " |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
389 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
390 min_gen0_size(), initial_gen0_size(), max_gen0_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
391 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
392 } |
0 | 393 |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
394 // Call this method during the sizing of the gen1 to make |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
395 // adjustments to gen0 because of gen1 sizing policy. gen0 initially has |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
396 // the most freedom in sizing because it is done before the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
397 // policy for gen1 is applied. Once gen1 policies have been applied, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
398 // there may be conflicts in the shape of the heap and this method |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
399 // is used to make the needed adjustments. The application of the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
400 // policies could be more sophisticated (iterative for example) but |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
401 // keeping it simple also seems a worthwhile goal. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
402 bool TwoGenerationCollectorPolicy::adjust_gen0_sizes(size_t* gen0_size_ptr, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
403 size_t* gen1_size_ptr, |
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
404 const size_t heap_size, |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
405 const size_t min_gen1_size) { |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
406 bool result = false; |
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
407 |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
408 if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) { |
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
409 if ((heap_size < (*gen0_size_ptr + min_gen1_size)) && |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
410 (heap_size >= min_gen1_size + min_alignment())) { |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
411 // Adjust gen0 down to accommodate min_gen1_size |
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
412 *gen0_size_ptr = heap_size - min_gen1_size; |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
413 *gen0_size_ptr = |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
414 MAX2((uintx)align_size_down(*gen0_size_ptr, min_alignment()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
415 min_alignment()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
416 assert(*gen0_size_ptr > 0, "Min gen0 is too large"); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
417 result = true; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
418 } else { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
419 *gen1_size_ptr = heap_size - *gen0_size_ptr; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
420 *gen1_size_ptr = |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
421 MAX2((uintx)align_size_down(*gen1_size_ptr, min_alignment()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
422 min_alignment()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
423 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
424 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
425 return result; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
426 } |
0 | 427 |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
428 // Minimum sizes of the generations may be different than |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
429 // the initial sizes. An inconsistently is permitted here |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
430 // in the total size that can be specified explicitly by |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
431 // command line specification of OldSize and NewSize and |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
432 // also a command line specification of -Xms. Issue a warning |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
433 // but allow the values to pass. |
0 | 434 |
435 void TwoGenerationCollectorPolicy::initialize_size_info() { | |
436 GenCollectorPolicy::initialize_size_info(); | |
437 | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
438 // At this point the minimum, initial and maximum sizes |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
439 // of the overall heap and of gen0 have been determined. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
440 // The maximum gen1 size can be determined from the maximum gen0 |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
441 // and maximum heap size since no explicit flags exits |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
442 // for setting the gen1 maximum. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
443 _max_gen1_size = max_heap_byte_size() - _max_gen0_size; |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
444 _max_gen1_size = |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
445 MAX2((uintx)align_size_down(_max_gen1_size, min_alignment()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
446 min_alignment()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
447 // If no explicit command line flag has been set for the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
448 // gen1 size, use what is left for gen1. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
449 if (FLAG_IS_DEFAULT(OldSize) || FLAG_IS_ERGO(OldSize)) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
450 // The user has not specified any value or ergonomics |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
451 // has chosen a value (which may or may not be consistent |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
452 // with the overall heap size). In either case make |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
453 // the minimum, maximum and initial sizes consistent |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
454 // with the gen0 sizes and the overall heap sizes. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
455 assert(min_heap_byte_size() > _min_gen0_size, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
456 "gen0 has an unexpected minimum size"); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
457 set_min_gen1_size(min_heap_byte_size() - min_gen0_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
458 set_min_gen1_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
459 MAX2((uintx)align_size_down(_min_gen1_size, min_alignment()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
460 min_alignment())); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
461 set_initial_gen1_size(initial_heap_byte_size() - initial_gen0_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
462 set_initial_gen1_size( |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
463 MAX2((uintx)align_size_down(_initial_gen1_size, min_alignment()), |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
464 min_alignment())); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
465 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
466 } else { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
467 // It's been explicitly set on the command line. Use the |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
468 // OldSize and then determine the consequences. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
469 set_min_gen1_size(OldSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
470 set_initial_gen1_size(OldSize); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
471 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
472 // If the user has explicitly set an OldSize that is inconsistent |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
473 // with other command line flags, issue a warning. |
0 | 474 // The generation minimums and the overall heap mimimum should |
475 // be within one heap alignment. | |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
476 if ((_min_gen1_size + _min_gen0_size + min_alignment()) < |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
477 min_heap_byte_size()) { |
0 | 478 warning("Inconsistency between minimum heap size and minimum " |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
479 "generation sizes: using minimum heap = " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
480 min_heap_byte_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
481 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
482 if ((OldSize > _max_gen1_size)) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
483 warning("Inconsistency between maximum heap size and maximum " |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
484 "generation sizes: using maximum heap = " SIZE_FORMAT |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
485 " -XX:OldSize flag is being ignored", |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
486 max_heap_byte_size()); |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
487 } |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
488 // If there is an inconsistency between the OldSize and the minimum and/or |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
489 // initial size of gen0, since OldSize was explicitly set, OldSize wins. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
490 if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
491 min_heap_byte_size(), OldSize)) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
492 if (PrintGCDetails && Verbose) { |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
493 gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT " Initial gen0 " |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
494 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
495 min_gen0_size(), initial_gen0_size(), max_gen0_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
496 } |
0 | 497 } |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
498 // Initial size |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
499 if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
500 initial_heap_byte_size(), OldSize)) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
501 if (PrintGCDetails && Verbose) { |
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
502 gclog_or_tty->print_cr("3: Minimum gen0 " SIZE_FORMAT " Initial gen0 " |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
503 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
504 min_gen0_size(), initial_gen0_size(), max_gen0_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
505 } |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
506 } |
0 | 507 } |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
508 // Enforce the maximum gen1 size. |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
509 set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size)); |
0 | 510 |
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
511 // Check that min gen1 <= initial gen1 <= max gen1 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
512 set_initial_gen1_size(MAX2(_initial_gen1_size, _min_gen1_size)); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
513 set_initial_gen1_size(MIN2(_initial_gen1_size, _max_gen1_size)); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
514 |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
515 if (PrintGCDetails && Verbose) { |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
516 gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT " Initial gen1 " |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
517 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT, |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
518 min_gen1_size(), initial_gen1_size(), max_gen1_size()); |
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
519 } |
0 | 520 } |
521 | |
522 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size, | |
523 bool is_tlab, | |
524 bool* gc_overhead_limit_was_exceeded) { | |
525 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
526 | |
527 debug_only(gch->check_for_valid_allocation_state()); | |
528 assert(gch->no_gc_in_progress(), "Allocation during gc not allowed"); | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
529 |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
530 // In general gc_overhead_limit_was_exceeded should be false so |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
531 // set it so here and reset it to true only if the gc time |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
532 // limit is being exceeded as checked below. |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
533 *gc_overhead_limit_was_exceeded = false; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
534 |
0 | 535 HeapWord* result = NULL; |
536 | |
537 // Loop until the allocation is satisified, | |
538 // or unsatisfied after GC. | |
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
539 for (int try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) { |
0 | 540 HandleMark hm; // discard any handles allocated in each iteration |
541 | |
542 // First allocation attempt is lock-free. | |
543 Generation *gen0 = gch->get_gen(0); | |
544 assert(gen0->supports_inline_contig_alloc(), | |
545 "Otherwise, must do alloc within heap lock"); | |
546 if (gen0->should_allocate(size, is_tlab)) { | |
547 result = gen0->par_allocate(size, is_tlab); | |
548 if (result != NULL) { | |
549 assert(gch->is_in_reserved(result), "result not in heap"); | |
550 return result; | |
551 } | |
552 } | |
553 unsigned int gc_count_before; // read inside the Heap_lock locked region | |
554 { | |
555 MutexLocker ml(Heap_lock); | |
556 if (PrintGC && Verbose) { | |
557 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:" | |
558 " attempting locked slow path allocation"); | |
559 } | |
560 // Note that only large objects get a shot at being | |
561 // allocated in later generations. | |
562 bool first_only = ! should_try_older_generation_allocation(size); | |
563 | |
564 result = gch->attempt_allocation(size, is_tlab, first_only); | |
565 if (result != NULL) { | |
566 assert(gch->is_in_reserved(result), "result not in heap"); | |
567 return result; | |
568 } | |
569 | |
570 if (GC_locker::is_active_and_needs_gc()) { | |
571 if (is_tlab) { | |
572 return NULL; // Caller will retry allocating individual object | |
573 } | |
574 if (!gch->is_maximal_no_gc()) { | |
575 // Try and expand heap to satisfy request | |
576 result = expand_heap_and_allocate(size, is_tlab); | |
577 // result could be null if we are out of space | |
578 if (result != NULL) { | |
579 return result; | |
580 } | |
581 } | |
582 | |
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
583 if (gclocker_stalled_count > GCLockerRetryAllocationCount) { |
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
584 return NULL; // we didn't get to do a GC and we didn't get any memory |
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
585 } |
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
586 |
0 | 587 // If this thread is not in a jni critical section, we stall |
588 // the requestor until the critical section has cleared and | |
589 // GC allowed. When the critical section clears, a GC is | |
590 // initiated by the last thread exiting the critical section; so | |
591 // we retry the allocation sequence from the beginning of the loop, | |
592 // rather than causing more, now probably unnecessary, GC attempts. | |
593 JavaThread* jthr = JavaThread::current(); | |
594 if (!jthr->in_critical()) { | |
595 MutexUnlocker mul(Heap_lock); | |
596 // Wait for JNI critical section to be exited | |
597 GC_locker::stall_until_clear(); | |
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
598 gclocker_stalled_count += 1; |
0 | 599 continue; |
600 } else { | |
601 if (CheckJNICalls) { | |
602 fatal("Possible deadlock due to allocating while" | |
603 " in jni critical section"); | |
604 } | |
605 return NULL; | |
606 } | |
607 } | |
608 | |
609 // Read the gc count while the heap lock is held. | |
610 gc_count_before = Universe::heap()->total_collections(); | |
611 } | |
612 | |
613 VM_GenCollectForAllocation op(size, | |
614 is_tlab, | |
615 gc_count_before); | |
616 VMThread::execute(&op); | |
617 if (op.prologue_succeeded()) { | |
618 result = op.result(); | |
619 if (op.gc_locked()) { | |
620 assert(result == NULL, "must be NULL if gc_locked() is true"); | |
621 continue; // retry and/or stall as necessary | |
622 } | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
623 |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
624 // Allocation has failed and a collection |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
625 // has been done. If the gc time limit was exceeded the |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
626 // this time, return NULL so that an out-of-memory |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
627 // will be thrown. Clear gc_overhead_limit_exceeded |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
628 // so that the overhead exceeded does not persist. |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
629 |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
630 const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded(); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
631 const bool softrefs_clear = all_soft_refs_clear(); |
8743
82657b6a8cc0
6976528: PS: assert(!limit_exceeded || softrefs_clear) failed: Should have been cleared
jmasa
parents:
8072
diff
changeset
|
632 |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
633 if (limit_exceeded && softrefs_clear) { |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
634 *gc_overhead_limit_was_exceeded = true; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
635 size_policy()->set_gc_overhead_limit_exceeded(false); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
636 if (op.result() != NULL) { |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
637 CollectedHeap::fill_with_object(op.result(), size); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
638 } |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
639 return NULL; |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
640 } |
0 | 641 assert(result == NULL || gch->is_in_reserved(result), |
642 "result not in heap"); | |
643 return result; | |
644 } | |
645 | |
646 // Give a warning if we seem to be looping forever. | |
647 if ((QueuedAllocationWarningCount > 0) && | |
648 (try_count % QueuedAllocationWarningCount == 0)) { | |
649 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t" | |
650 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : ""); | |
651 } | |
652 } | |
653 } | |
654 | |
655 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size, | |
656 bool is_tlab) { | |
657 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
658 HeapWord* result = NULL; | |
659 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) { | |
660 Generation *gen = gch->get_gen(i); | |
661 if (gen->should_allocate(size, is_tlab)) { | |
662 result = gen->expand_and_allocate(size, is_tlab); | |
663 } | |
664 } | |
665 assert(result == NULL || gch->is_in_reserved(result), "result not in heap"); | |
666 return result; | |
667 } | |
668 | |
669 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size, | |
670 bool is_tlab) { | |
671 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
672 GCCauseSetter x(gch, GCCause::_allocation_failure); | |
673 HeapWord* result = NULL; | |
674 | |
675 assert(size != 0, "Precondition violated"); | |
676 if (GC_locker::is_active_and_needs_gc()) { | |
677 // GC locker is active; instead of a collection we will attempt | |
678 // to expand the heap, if there's room for expansion. | |
679 if (!gch->is_maximal_no_gc()) { | |
680 result = expand_heap_and_allocate(size, is_tlab); | |
681 } | |
682 return result; // could be null if we are out of space | |
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
683 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) { |
0 | 684 // Do an incremental collection. |
685 gch->do_collection(false /* full */, | |
686 false /* clear_all_soft_refs */, | |
687 size /* size */, | |
688 is_tlab /* is_tlab */, | |
689 number_of_generations() - 1 /* max_level */); | |
690 } else { | |
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
691 if (Verbose && PrintGCDetails) { |
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
692 gclog_or_tty->print(" :: Trying full because partial may fail :: "); |
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
693 } |
0 | 694 // Try a full collection; see delta for bug id 6266275 |
695 // for the original code and why this has been simplified | |
696 // with from-space allocation criteria modified and | |
697 // such allocation moved out of the safepoint path. | |
698 gch->do_collection(true /* full */, | |
699 false /* clear_all_soft_refs */, | |
700 size /* size */, | |
701 is_tlab /* is_tlab */, | |
702 number_of_generations() - 1 /* max_level */); | |
703 } | |
704 | |
705 result = gch->attempt_allocation(size, is_tlab, false /*first_only*/); | |
706 | |
707 if (result != NULL) { | |
708 assert(gch->is_in_reserved(result), "result not in heap"); | |
709 return result; | |
710 } | |
711 | |
712 // OK, collection failed, try expansion. | |
713 result = expand_heap_and_allocate(size, is_tlab); | |
714 if (result != NULL) { | |
715 return result; | |
716 } | |
717 | |
718 // If we reach this point, we're really out of memory. Try every trick | |
719 // we can to reclaim memory. Force collection of soft references. Force | |
720 // a complete compaction of the heap. Any additional methods for finding | |
721 // free memory should be here, especially if they are expensive. If this | |
722 // attempt fails, an OOM exception will be thrown. | |
723 { | |
724 IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted | |
725 | |
726 gch->do_collection(true /* full */, | |
727 true /* clear_all_soft_refs */, | |
728 size /* size */, | |
729 is_tlab /* is_tlab */, | |
730 number_of_generations() - 1 /* max_level */); | |
731 } | |
732 | |
733 result = gch->attempt_allocation(size, is_tlab, false /* first_only */); | |
734 if (result != NULL) { | |
735 assert(gch->is_in_reserved(result), "result not in heap"); | |
736 return result; | |
737 } | |
738 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
739 assert(!should_clear_all_soft_refs(), |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
740 "Flag should have been handled and cleared prior to this point"); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
741 |
0 | 742 // What else? We might try synchronous finalization later. If the total |
743 // space available is large enough for the allocation, then a more | |
744 // complete compaction phase than we've tried so far might be | |
745 // appropriate. | |
746 return NULL; | |
747 } | |
748 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
749 MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation( |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
750 ClassLoaderData* loader_data, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
751 size_t word_size, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
752 Metaspace::MetadataType mdtype) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
753 uint loop_count = 0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
754 uint gc_count = 0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
755 uint full_gc_count = 0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
756 |
6923
3fadc0e8cffe
8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents:
6753
diff
changeset
|
757 assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock"); |
3fadc0e8cffe
8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents:
6753
diff
changeset
|
758 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
759 do { |
6753
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
760 MetaWord* result = NULL; |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
761 if (GC_locker::is_active_and_needs_gc()) { |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
762 // If the GC_locker is active, just expand and allocate. |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
763 // If that does not succeed, wait if this thread is not |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
764 // in a critical section itself. |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
765 result = |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
766 loader_data->metaspace_non_null()->expand_and_allocate(word_size, |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
767 mdtype); |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
768 if (result != NULL) { |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
769 return result; |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
770 } |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
771 JavaThread* jthr = JavaThread::current(); |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
772 if (!jthr->in_critical()) { |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
773 // Wait for JNI critical section to be exited |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
774 GC_locker::stall_until_clear(); |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
775 // The GC invoked by the last thread leaving the critical |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
776 // section will be a young collection and a full collection |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
777 // is (currently) needed for unloading classes so continue |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
778 // to the next iteration to get a full GC. |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
779 continue; |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
780 } else { |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
781 if (CheckJNICalls) { |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
782 fatal("Possible deadlock due to allocating while" |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
783 " in jni critical section"); |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
784 } |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
785 return NULL; |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
786 } |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
787 } |
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
788 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
789 { // Need lock to get self consistent gc_count's |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
790 MutexLocker ml(Heap_lock); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
791 gc_count = Universe::heap()->total_collections(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
792 full_gc_count = Universe::heap()->total_full_collections(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
793 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
794 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
795 // Generate a VM operation |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
796 VM_CollectForMetadataAllocation op(loader_data, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
797 word_size, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
798 mdtype, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
799 gc_count, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
800 full_gc_count, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
801 GCCause::_metadata_GC_threshold); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
802 VMThread::execute(&op); |
7446
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
803 |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
804 // If GC was locked out, try again. Check |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
805 // before checking success because the prologue |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
806 // could have succeeded and the GC still have |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
807 // been locked out. |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
808 if (op.gc_locked()) { |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
809 continue; |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
810 } |
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
811 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
812 if (op.prologue_succeeded()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
813 return op.result(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
814 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
815 loop_count++; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
816 if ((QueuedAllocationWarningCount > 0) && |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
817 (loop_count % QueuedAllocationWarningCount == 0)) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
818 warning("satisfy_failed_metadata_allocation() retries %d times \n\t" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
819 " size=%d", loop_count, word_size); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
820 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
821 } while (true); // Until a GC is done |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
822 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
823 |
0 | 824 // Return true if any of the following is true: |
825 // . the allocation won't fit into the current young gen heap | |
826 // . gc locker is occupied (jni critical section) | |
827 // . heap memory is tight -- the most recent previous collection | |
828 // was a full collection because a partial collection (would | |
829 // have) failed and is likely to fail again | |
830 bool GenCollectorPolicy::should_try_older_generation_allocation( | |
831 size_t word_size) const { | |
832 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
833 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc(); | |
834 return (word_size > heap_word_size(gen0_capacity)) | |
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1795
diff
changeset
|
835 || GC_locker::is_active_and_needs_gc() |
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1795
diff
changeset
|
836 || gch->incremental_collection_failed(); |
0 | 837 } |
838 | |
839 | |
840 // | |
841 // MarkSweepPolicy methods | |
842 // | |
843 | |
844 MarkSweepPolicy::MarkSweepPolicy() { | |
845 initialize_all(); | |
846 } | |
847 | |
848 void MarkSweepPolicy::initialize_generations() { | |
10135 | 849 _generations = new GenerationSpecPtr[number_of_generations()]; |
0 | 850 if (_generations == NULL) |
851 vm_exit_during_initialization("Unable to allocate gen spec"); | |
852 | |
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7446
diff
changeset
|
853 if (UseParNewGC) { |
0 | 854 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size); |
855 } else { | |
856 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size); | |
857 } | |
858 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size); | |
859 | |
860 if (_generations[0] == NULL || _generations[1] == NULL) | |
861 vm_exit_during_initialization("Unable to allocate gen spec"); | |
862 } | |
863 | |
864 void MarkSweepPolicy::initialize_gc_policy_counters() { | |
865 // initialize the policy counters - 2 collectors, 3 generations | |
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7446
diff
changeset
|
866 if (UseParNewGC) { |
0 | 867 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3); |
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7446
diff
changeset
|
868 } else { |
0 | 869 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3); |
870 } | |
871 } |