Mercurial > hg > truffle
annotate src/share/vm/memory/collectorPolicy.cpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
| author | ysr |
|---|---|
| date | Wed, 16 Mar 2011 10:37:08 -0700 |
| parents | 6cd6d394f280 |
| children | a1d5f532838d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
2 * Copyright (c) 2001, 2011, 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" | |
| 40 #include "runtime/vmThread.hpp" | |
| 41 #ifdef TARGET_OS_FAMILY_linux | |
| 42 # include "thread_linux.inline.hpp" | |
| 43 #endif | |
| 44 #ifdef TARGET_OS_FAMILY_solaris | |
| 45 # include "thread_solaris.inline.hpp" | |
| 46 #endif | |
| 47 #ifdef TARGET_OS_FAMILY_windows | |
| 48 # include "thread_windows.inline.hpp" | |
| 49 #endif | |
| 50 #ifndef SERIALGC | |
| 51 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" | |
| 52 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp" | |
| 53 #endif | |
| 0 | 54 |
| 55 // CollectorPolicy methods. | |
| 56 | |
| 57 void CollectorPolicy::initialize_flags() { | |
| 58 if (PermSize > MaxPermSize) { | |
| 59 MaxPermSize = PermSize; | |
| 60 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
61 PermSize = MAX2(min_alignment(), align_size_down_(PermSize, min_alignment())); |
|
1795
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
62 // Don't increase Perm size limit above specified. |
|
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
63 MaxPermSize = align_size_down(MaxPermSize, max_alignment()); |
|
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
64 if (PermSize > MaxPermSize) { |
|
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
65 PermSize = MaxPermSize; |
|
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
66 } |
| 0 | 67 |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
68 MinPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MinPermHeapExpansion, min_alignment())); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
69 MaxPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MaxPermHeapExpansion, min_alignment())); |
| 0 | 70 |
| 71 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment()); | |
| 72 | |
| 73 SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment()); | |
| 74 SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment()); | |
| 75 SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment()); | |
| 76 | |
| 77 assert(PermSize % min_alignment() == 0, "permanent space alignment"); | |
| 78 assert(MaxPermSize % max_alignment() == 0, "maximum permanent space alignment"); | |
| 79 assert(SharedReadOnlySize % max_alignment() == 0, "read-only space alignment"); | |
| 80 assert(SharedReadWriteSize % max_alignment() == 0, "read-write space alignment"); | |
| 81 assert(SharedMiscDataSize % max_alignment() == 0, "misc-data space alignment"); | |
| 82 if (PermSize < M) { | |
| 83 vm_exit_during_initialization("Too small initial permanent heap"); | |
| 84 } | |
| 85 } | |
| 86 | |
| 87 void CollectorPolicy::initialize_size_info() { | |
| 88 // User inputs from -mx and ms are aligned | |
| 1064 | 89 set_initial_heap_byte_size(InitialHeapSize); |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
90 if (initial_heap_byte_size() == 0) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
91 set_initial_heap_byte_size(NewSize + OldSize); |
| 0 | 92 } |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
93 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
|
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_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
|
97 if (min_heap_byte_size() == 0) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
98 set_min_heap_byte_size(NewSize + OldSize); |
| 0 | 99 } |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
100 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
|
101 min_alignment())); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
102 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
103 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment())); |
| 0 | 104 |
| 105 // Check heap parameter properties | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
106 if (initial_heap_byte_size() < M) { |
| 0 | 107 vm_exit_during_initialization("Too small initial heap"); |
| 108 } | |
| 109 // Check heap parameter properties | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
110 if (min_heap_byte_size() < M) { |
| 0 | 111 vm_exit_during_initialization("Too small minimum heap"); |
| 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() <= NewSize) { |
| 0 | 114 // make sure there is at least some room in old space |
| 115 vm_exit_during_initialization("Too small initial heap for new size specified"); | |
| 116 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
117 if (max_heap_byte_size() < min_heap_byte_size()) { |
| 0 | 118 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified"); |
| 119 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
120 if (initial_heap_byte_size() < min_heap_byte_size()) { |
| 0 | 121 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified"); |
| 122 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
123 if (max_heap_byte_size() < initial_heap_byte_size()) { |
| 0 | 124 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified"); |
| 125 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
126 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
127 if (PrintGCDetails && Verbose) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
128 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
|
129 SIZE_FORMAT " Maximum heap " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
130 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
|
131 } |
| 0 | 132 } |
| 133 | |
| 134 void CollectorPolicy::initialize_perm_generation(PermGen::Name pgnm) { | |
| 135 _permanent_generation = | |
| 136 new PermanentGenerationSpec(pgnm, PermSize, MaxPermSize, | |
| 137 SharedReadOnlySize, | |
| 138 SharedReadWriteSize, | |
| 139 SharedMiscDataSize, | |
| 140 SharedMiscCodeSize); | |
| 141 if (_permanent_generation == NULL) { | |
| 142 vm_exit_during_initialization("Unable to allocate gen spec"); | |
| 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 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
|
147 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
|
148 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
|
149 return result; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
150 } |
| 0 | 151 |
| 152 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap, | |
| 153 int max_covered_regions) { | |
| 154 switch (rem_set_name()) { | |
| 155 case GenRemSet::CardTable: { | |
| 156 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions); | |
| 157 return res; | |
| 158 } | |
| 159 default: | |
| 160 guarantee(false, "unrecognized GenRemSet::Name"); | |
| 161 return NULL; | |
| 162 } | |
| 163 } | |
| 164 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
165 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
|
166 // 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
|
167 // 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
|
168 // 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
|
169 if (size_policy() != NULL) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
170 _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
|
171 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
172 _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
|
173 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
174 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
175 |
| 0 | 176 // GenCollectorPolicy methods. |
| 177 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
178 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
|
179 size_t x = base_size / (NewRatio+1); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
180 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
|
181 align_size_down(x, min_alignment()) : |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
182 min_alignment(); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
183 return new_gen_size; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
184 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
185 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
186 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
|
187 size_t maximum_size) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
188 size_t alignment = min_alignment(); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
189 size_t max_minus = maximum_size - alignment; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
190 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
|
191 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
192 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
193 |
| 0 | 194 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size, |
| 195 size_t init_promo_size, | |
| 196 size_t init_survivor_size) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
197 const double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0; |
| 0 | 198 _size_policy = new AdaptiveSizePolicy(init_eden_size, |
| 199 init_promo_size, | |
| 200 init_survivor_size, | |
| 201 max_gc_minor_pause_sec, | |
| 202 GCTimeRatio); | |
| 203 } | |
| 204 | |
| 205 size_t GenCollectorPolicy::compute_max_alignment() { | |
| 206 // The card marking array and the offset arrays for old generations are | |
| 207 // committed in os pages as well. Make sure they are entirely full (to | |
| 208 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1 | |
| 209 // byte entry and the os page size is 4096, the maximum heap size should | |
| 210 // be 512*4096 = 2MB aligned. | |
| 211 size_t alignment = GenRemSet::max_alignment_constraint(rem_set_name()); | |
| 212 | |
| 213 // Parallel GC does its own alignment of the generations to avoid requiring a | |
| 214 // large page (256M on some platforms) for the permanent generation. The | |
| 215 // other collectors should also be updated to do their own alignment and then | |
| 216 // this use of lcm() should be removed. | |
| 217 if (UseLargePages && !UseParallelGC) { | |
| 218 // in presence of large pages we have to make sure that our | |
| 219 // alignment is large page aware | |
| 220 alignment = lcm(os::large_page_size(), alignment); | |
| 221 } | |
| 222 | |
| 223 return alignment; | |
| 224 } | |
| 225 | |
| 226 void GenCollectorPolicy::initialize_flags() { | |
| 227 // All sizes must be multiples of the generation granularity. | |
| 228 set_min_alignment((uintx) Generation::GenGrain); | |
| 229 set_max_alignment(compute_max_alignment()); | |
| 230 assert(max_alignment() >= min_alignment() && | |
| 231 max_alignment() % min_alignment() == 0, | |
| 232 "invalid alignment constraints"); | |
| 233 | |
| 234 CollectorPolicy::initialize_flags(); | |
| 235 | |
| 236 // All generational heaps have a youngest gen; handle those flags here. | |
| 237 | |
| 238 // Adjust max size parameters | |
| 239 if (NewSize > MaxNewSize) { | |
| 240 MaxNewSize = NewSize; | |
| 241 } | |
| 242 NewSize = align_size_down(NewSize, min_alignment()); | |
| 243 MaxNewSize = align_size_down(MaxNewSize, min_alignment()); | |
| 244 | |
| 245 // Check validity of heap flags | |
| 246 assert(NewSize % min_alignment() == 0, "eden space alignment"); | |
| 247 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment"); | |
| 248 | |
| 249 if (NewSize < 3*min_alignment()) { | |
| 250 // make sure there room for eden and two survivor spaces | |
| 251 vm_exit_during_initialization("Too small new size specified"); | |
| 252 } | |
| 253 if (SurvivorRatio < 1 || NewRatio < 1) { | |
| 254 vm_exit_during_initialization("Invalid heap ratio specified"); | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 void TwoGenerationCollectorPolicy::initialize_flags() { | |
| 259 GenCollectorPolicy::initialize_flags(); | |
| 260 | |
| 261 OldSize = align_size_down(OldSize, min_alignment()); | |
| 262 if (NewSize + OldSize > MaxHeapSize) { | |
| 263 MaxHeapSize = NewSize + OldSize; | |
| 264 } | |
| 265 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); | |
| 266 | |
| 267 always_do_update_barrier = UseConcMarkSweepGC; | |
| 268 BlockOffsetArrayUseUnallocatedBlock = | |
| 269 BlockOffsetArrayUseUnallocatedBlock || ParallelGCThreads > 0; | |
| 270 | |
| 271 // Check validity of heap flags | |
| 272 assert(OldSize % min_alignment() == 0, "old space alignment"); | |
| 273 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment"); | |
| 274 } | |
| 275 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
276 // 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
|
277 // set command line parameters. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
278 // 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
|
279 // 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
|
280 // 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
|
281 // 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
|
282 // themselves and with overall heap sizings. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
283 // 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
|
284 // such as the use of NewRatio are used to size the generation. |
| 0 | 285 void GenCollectorPolicy::initialize_size_info() { |
| 286 CollectorPolicy::initialize_size_info(); | |
| 287 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
288 // 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
|
289 // 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
|
290 // 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
|
291 // generations sizes. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
292 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
293 // Determine maximum size of gen0 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
294 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
295 size_t max_new_size = 0; |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
296 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
|
297 if (MaxNewSize < min_alignment()) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
298 max_new_size = min_alignment(); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
299 } |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
300 if (MaxNewSize >= max_heap_byte_size()) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
301 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
|
302 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
303 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
|
304 "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
|
305 "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
|
306 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
|
307 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
308 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
|
309 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
310 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
311 // 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
|
312 // 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
|
313 // 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
|
314 // 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
|
315 // 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
|
316 // 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
|
317 // 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
|
318 // 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
|
319 // 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
|
320 // 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
|
321 // 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
|
322 // 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
|
323 // 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
|
324 // not always "wise". |
| 0 | 325 } else { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
326 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
|
327 // Bound the maximum size by NewSize below (since it historically |
| 0 | 328 // would have been NewSize and because the NewRatio calculation could |
| 329 // 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
|
330 // 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
|
331 // NewSize and MaxNewSize. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
332 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
|
333 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
334 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
|
335 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
336 // 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
|
337 // minimum gen0 sizes. |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
338 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
339 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
|
340 // 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
|
341 // 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
|
342 // same as its maximum. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
343 set_min_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
344 set_initial_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
345 set_max_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
346 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
347 size_t desired_new_size = 0; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
348 if (!FLAG_IS_DEFAULT(NewSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
349 // 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
|
350 // 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
|
351 // 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
|
352 // 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
|
353 // 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
|
354 // 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
|
355 // 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
|
356 // generally small compared to the NewRatio calculation. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
357 _min_gen0_size = NewSize; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
358 desired_new_size = NewSize; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
359 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
|
360 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
361 // 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
|
362 // 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
|
363 // 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
|
364 // 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
|
365 // small. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
366 _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
|
367 NewSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
368 desired_new_size = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
369 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
|
370 NewSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
371 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
372 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
373 assert(_min_gen0_size > 0, "Sanity check"); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
374 set_initial_gen0_size(desired_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
375 set_max_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
376 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
377 // 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
|
378 // determined without regard to the maximum sizes. |
|
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 // 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
|
381 set_min_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
382 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
|
383 set_initial_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
384 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
|
385 set_max_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
386 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
|
387 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
388 // 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
|
389 // maximum sizes but have not been checked for consistency |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
390 // among the three. |
|
13
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 // Final check min <= initial <= max |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
393 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
|
394 set_initial_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
395 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
|
396 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size)); |
| 0 | 397 } |
| 398 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
399 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
400 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
|
401 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
402 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
|
403 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
404 } |
| 0 | 405 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
406 // 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
|
407 // 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
|
408 // 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
|
409 // 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
|
410 // 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
|
411 // 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
|
412 // 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
|
413 // 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
|
414 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
|
415 size_t* gen1_size_ptr, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
416 size_t heap_size, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
417 size_t min_gen0_size) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
418 bool result = false; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
419 if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
420 if (((*gen0_size_ptr + OldSize) > heap_size) && |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
421 (heap_size - min_gen0_size) >= min_alignment()) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
422 // Adjust gen0 down to accomodate OldSize |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
423 *gen0_size_ptr = heap_size - min_gen0_size; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
424 *gen0_size_ptr = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
425 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
|
426 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
427 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
|
428 result = true; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
429 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
430 *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
|
431 *gen1_size_ptr = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
432 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
|
433 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
434 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
435 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
436 return result; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
437 } |
| 0 | 438 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
439 // 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
|
440 // 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
|
441 // 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
|
442 // 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
|
443 // 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
|
444 // but allow the values to pass. |
| 0 | 445 |
| 446 void TwoGenerationCollectorPolicy::initialize_size_info() { | |
| 447 GenCollectorPolicy::initialize_size_info(); | |
| 448 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
449 // 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
|
450 // 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
|
451 // 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
|
452 // 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
|
453 // for setting the gen1 maximum. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
454 _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
|
455 _max_gen1_size = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
456 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
|
457 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
458 // 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
|
459 // 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
|
460 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
|
461 // 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
|
462 // 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
|
463 // 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
|
464 // the minimum, maximum and initial sizes consistent |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
465 // 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
|
466 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
|
467 "gen0 has an unexpected minimum size"); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
468 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
|
469 set_min_gen1_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
470 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
|
471 min_alignment())); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
472 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
|
473 set_initial_gen1_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
474 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
|
475 min_alignment())); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
476 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
477 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
478 // 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
|
479 // OldSize and then determine the consequences. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
480 set_min_gen1_size(OldSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
481 set_initial_gen1_size(OldSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
482 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
483 // 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
|
484 // with other command line flags, issue a warning. |
| 0 | 485 // The generation minimums and the overall heap mimimum should |
| 486 // be within one heap alignment. | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
487 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
|
488 min_heap_byte_size()) { |
| 0 | 489 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
|
490 "generation sizes: using minimum heap = " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
491 min_heap_byte_size()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
492 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
493 if ((OldSize > _max_gen1_size)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
494 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
|
495 "generation sizes: using maximum heap = " SIZE_FORMAT |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
496 " -XX:OldSize flag is being ignored", |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
497 max_heap_byte_size()); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
498 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
499 // 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
|
500 // 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
|
501 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
|
502 min_heap_byte_size(), OldSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
503 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
504 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
|
505 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
506 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
|
507 } |
| 0 | 508 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
509 // Initial size |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
510 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
|
511 initial_heap_byte_size(), OldSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
512 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
513 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
|
514 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
515 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
|
516 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
517 } |
| 0 | 518 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
519 // Enforce the maximum gen1 size. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
520 set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size)); |
| 0 | 521 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
522 // 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
|
523 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
|
524 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
|
525 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
526 if (PrintGCDetails && Verbose) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
527 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
|
528 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
529 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
|
530 } |
| 0 | 531 } |
| 532 | |
| 533 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size, | |
| 534 bool is_tlab, | |
| 535 bool* gc_overhead_limit_was_exceeded) { | |
| 536 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 537 | |
| 538 debug_only(gch->check_for_valid_allocation_state()); | |
| 539 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
|
540 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
541 // 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
|
542 // 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
|
543 // 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
|
544 *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
|
545 |
| 0 | 546 HeapWord* result = NULL; |
| 547 | |
| 548 // Loop until the allocation is satisified, | |
| 549 // or unsatisfied after GC. | |
| 550 for (int try_count = 1; /* return or throw */; try_count += 1) { | |
| 551 HandleMark hm; // discard any handles allocated in each iteration | |
| 552 | |
| 553 // First allocation attempt is lock-free. | |
| 554 Generation *gen0 = gch->get_gen(0); | |
| 555 assert(gen0->supports_inline_contig_alloc(), | |
| 556 "Otherwise, must do alloc within heap lock"); | |
| 557 if (gen0->should_allocate(size, is_tlab)) { | |
| 558 result = gen0->par_allocate(size, is_tlab); | |
| 559 if (result != NULL) { | |
| 560 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 561 return result; | |
| 562 } | |
| 563 } | |
| 564 unsigned int gc_count_before; // read inside the Heap_lock locked region | |
| 565 { | |
| 566 MutexLocker ml(Heap_lock); | |
| 567 if (PrintGC && Verbose) { | |
| 568 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:" | |
| 569 " attempting locked slow path allocation"); | |
| 570 } | |
| 571 // Note that only large objects get a shot at being | |
| 572 // allocated in later generations. | |
| 573 bool first_only = ! should_try_older_generation_allocation(size); | |
| 574 | |
| 575 result = gch->attempt_allocation(size, is_tlab, first_only); | |
| 576 if (result != NULL) { | |
| 577 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 578 return result; | |
| 579 } | |
| 580 | |
| 581 if (GC_locker::is_active_and_needs_gc()) { | |
| 582 if (is_tlab) { | |
| 583 return NULL; // Caller will retry allocating individual object | |
| 584 } | |
| 585 if (!gch->is_maximal_no_gc()) { | |
| 586 // Try and expand heap to satisfy request | |
| 587 result = expand_heap_and_allocate(size, is_tlab); | |
| 588 // result could be null if we are out of space | |
| 589 if (result != NULL) { | |
| 590 return result; | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 // If this thread is not in a jni critical section, we stall | |
| 595 // the requestor until the critical section has cleared and | |
| 596 // GC allowed. When the critical section clears, a GC is | |
| 597 // initiated by the last thread exiting the critical section; so | |
| 598 // we retry the allocation sequence from the beginning of the loop, | |
| 599 // rather than causing more, now probably unnecessary, GC attempts. | |
| 600 JavaThread* jthr = JavaThread::current(); | |
| 601 if (!jthr->in_critical()) { | |
| 602 MutexUnlocker mul(Heap_lock); | |
| 603 // Wait for JNI critical section to be exited | |
| 604 GC_locker::stall_until_clear(); | |
| 605 continue; | |
| 606 } else { | |
| 607 if (CheckJNICalls) { | |
| 608 fatal("Possible deadlock due to allocating while" | |
| 609 " in jni critical section"); | |
| 610 } | |
| 611 return NULL; | |
| 612 } | |
| 613 } | |
| 614 | |
| 615 // Read the gc count while the heap lock is held. | |
| 616 gc_count_before = Universe::heap()->total_collections(); | |
| 617 } | |
| 618 | |
| 619 VM_GenCollectForAllocation op(size, | |
| 620 is_tlab, | |
| 621 gc_count_before); | |
| 622 VMThread::execute(&op); | |
| 623 if (op.prologue_succeeded()) { | |
| 624 result = op.result(); | |
| 625 if (op.gc_locked()) { | |
| 626 assert(result == NULL, "must be NULL if gc_locked() is true"); | |
| 627 continue; // retry and/or stall as necessary | |
| 628 } | |
|
1387
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 // 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
|
631 // 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
|
632 // 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
|
633 // 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
|
634 // 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
|
635 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
636 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
|
637 const bool softrefs_clear = all_soft_refs_clear(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
638 assert(!limit_exceeded || softrefs_clear, "Should have been cleared"); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
639 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
|
640 *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
|
641 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
|
642 if (op.result() != NULL) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
643 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
|
644 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
645 return NULL; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
646 } |
| 0 | 647 assert(result == NULL || gch->is_in_reserved(result), |
| 648 "result not in heap"); | |
| 649 return result; | |
| 650 } | |
| 651 | |
| 652 // Give a warning if we seem to be looping forever. | |
| 653 if ((QueuedAllocationWarningCount > 0) && | |
| 654 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 655 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t" | |
| 656 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : ""); | |
| 657 } | |
| 658 } | |
| 659 } | |
| 660 | |
| 661 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size, | |
| 662 bool is_tlab) { | |
| 663 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 664 HeapWord* result = NULL; | |
| 665 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) { | |
| 666 Generation *gen = gch->get_gen(i); | |
| 667 if (gen->should_allocate(size, is_tlab)) { | |
| 668 result = gen->expand_and_allocate(size, is_tlab); | |
| 669 } | |
| 670 } | |
| 671 assert(result == NULL || gch->is_in_reserved(result), "result not in heap"); | |
| 672 return result; | |
| 673 } | |
| 674 | |
| 675 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size, | |
| 676 bool is_tlab) { | |
| 677 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 678 GCCauseSetter x(gch, GCCause::_allocation_failure); | |
| 679 HeapWord* result = NULL; | |
| 680 | |
| 681 assert(size != 0, "Precondition violated"); | |
| 682 if (GC_locker::is_active_and_needs_gc()) { | |
| 683 // GC locker is active; instead of a collection we will attempt | |
| 684 // to expand the heap, if there's room for expansion. | |
| 685 if (!gch->is_maximal_no_gc()) { | |
| 686 result = expand_heap_and_allocate(size, is_tlab); | |
| 687 } | |
| 688 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
|
689 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) { |
| 0 | 690 // Do an incremental collection. |
| 691 gch->do_collection(false /* full */, | |
| 692 false /* clear_all_soft_refs */, | |
| 693 size /* size */, | |
| 694 is_tlab /* is_tlab */, | |
| 695 number_of_generations() - 1 /* max_level */); | |
| 696 } else { | |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
697 if (Verbose && PrintGCDetails) { |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
698 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
|
699 } |
| 0 | 700 // Try a full collection; see delta for bug id 6266275 |
| 701 // for the original code and why this has been simplified | |
| 702 // with from-space allocation criteria modified and | |
| 703 // such allocation moved out of the safepoint path. | |
| 704 gch->do_collection(true /* full */, | |
| 705 false /* clear_all_soft_refs */, | |
| 706 size /* size */, | |
| 707 is_tlab /* is_tlab */, | |
| 708 number_of_generations() - 1 /* max_level */); | |
| 709 } | |
| 710 | |
| 711 result = gch->attempt_allocation(size, is_tlab, false /*first_only*/); | |
| 712 | |
| 713 if (result != NULL) { | |
| 714 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 715 return result; | |
| 716 } | |
| 717 | |
| 718 // OK, collection failed, try expansion. | |
| 719 result = expand_heap_and_allocate(size, is_tlab); | |
| 720 if (result != NULL) { | |
| 721 return result; | |
| 722 } | |
| 723 | |
| 724 // If we reach this point, we're really out of memory. Try every trick | |
| 725 // we can to reclaim memory. Force collection of soft references. Force | |
| 726 // a complete compaction of the heap. Any additional methods for finding | |
| 727 // free memory should be here, especially if they are expensive. If this | |
| 728 // attempt fails, an OOM exception will be thrown. | |
| 729 { | |
| 730 IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted | |
| 731 | |
| 732 gch->do_collection(true /* full */, | |
| 733 true /* clear_all_soft_refs */, | |
| 734 size /* size */, | |
| 735 is_tlab /* is_tlab */, | |
| 736 number_of_generations() - 1 /* max_level */); | |
| 737 } | |
| 738 | |
| 739 result = gch->attempt_allocation(size, is_tlab, false /* first_only */); | |
| 740 if (result != NULL) { | |
| 741 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 742 return result; | |
| 743 } | |
| 744 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
745 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
|
746 "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
|
747 |
| 0 | 748 // What else? We might try synchronous finalization later. If the total |
| 749 // space available is large enough for the allocation, then a more | |
| 750 // complete compaction phase than we've tried so far might be | |
| 751 // appropriate. | |
| 752 return NULL; | |
| 753 } | |
| 754 | |
| 755 size_t GenCollectorPolicy::large_typearray_limit() { | |
| 756 return FastAllocateSizeLimit; | |
| 757 } | |
| 758 | |
| 759 // Return true if any of the following is true: | |
| 760 // . the allocation won't fit into the current young gen heap | |
| 761 // . gc locker is occupied (jni critical section) | |
| 762 // . heap memory is tight -- the most recent previous collection | |
| 763 // was a full collection because a partial collection (would | |
| 764 // have) failed and is likely to fail again | |
| 765 bool GenCollectorPolicy::should_try_older_generation_allocation( | |
| 766 size_t word_size) const { | |
| 767 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 768 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc(); | |
| 769 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
|
770 || 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
|
771 || gch->incremental_collection_failed(); |
| 0 | 772 } |
| 773 | |
| 774 | |
| 775 // | |
| 776 // MarkSweepPolicy methods | |
| 777 // | |
| 778 | |
| 779 MarkSweepPolicy::MarkSweepPolicy() { | |
| 780 initialize_all(); | |
| 781 } | |
| 782 | |
| 783 void MarkSweepPolicy::initialize_generations() { | |
| 784 initialize_perm_generation(PermGen::MarkSweepCompact); | |
| 785 _generations = new GenerationSpecPtr[number_of_generations()]; | |
| 786 if (_generations == NULL) | |
| 787 vm_exit_during_initialization("Unable to allocate gen spec"); | |
| 788 | |
| 789 if (UseParNewGC && ParallelGCThreads > 0) { | |
| 790 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size); | |
| 791 } else { | |
| 792 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size); | |
| 793 } | |
| 794 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size); | |
| 795 | |
| 796 if (_generations[0] == NULL || _generations[1] == NULL) | |
| 797 vm_exit_during_initialization("Unable to allocate gen spec"); | |
| 798 } | |
| 799 | |
| 800 void MarkSweepPolicy::initialize_gc_policy_counters() { | |
| 801 // initialize the policy counters - 2 collectors, 3 generations | |
| 802 if (UseParNewGC && ParallelGCThreads > 0) { | |
| 803 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3); | |
| 804 } | |
| 805 else { | |
| 806 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3); | |
| 807 } | |
| 808 } |