Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/collectorPolicy.cpp @ 10241:d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
Summary: Make processing of minimum, initial and maximum heap size more intiutive by removing previous limitations on allowed values, and make error reporting consistent. Further, fix errors in ergonomic heap sizing.
Reviewed-by: johnc, jwilhelm, tamao
| author | tschatzl |
|---|---|
| date | Mon, 06 May 2013 17:19:42 +0200 |
| parents | f14063dcd52a |
| children | f9be75d21404 7a95933197d0 |
| 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 |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
58 if (MaxHeapSize < InitialHeapSize) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
59 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified"); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
60 } |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
61 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
62 if (MetaspaceSize > MaxMetaspaceSize) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
63 MaxMetaspaceSize = MetaspaceSize; |
| 0 | 64 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
65 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
|
66 // Don't increase Metaspace size limit above specified. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
67 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
68 if (MetaspaceSize > MaxMetaspaceSize) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
69 MetaspaceSize = MaxMetaspaceSize; |
|
1795
a8b66e00933b
6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents:
1552
diff
changeset
|
70 } |
| 0 | 71 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
72 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
|
73 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment())); |
| 0 | 74 |
| 75 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment()); | |
| 76 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
77 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
78 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
79 if (MetaspaceSize < 256*K) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
80 vm_exit_during_initialization("Too small initial Metaspace size"); |
| 0 | 81 } |
| 82 } | |
| 83 | |
| 84 void CollectorPolicy::initialize_size_info() { | |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
85 // User inputs from -mx and ms must be aligned |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
86 set_min_heap_byte_size(align_size_up(Arguments::min_heap_size(), min_alignment())); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
87 set_initial_heap_byte_size(align_size_up(InitialHeapSize, min_alignment())); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
88 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment())); |
| 0 | 89 |
| 90 // Check heap parameter properties | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
91 if (initial_heap_byte_size() < M) { |
| 0 | 92 vm_exit_during_initialization("Too small initial heap"); |
| 93 } | |
| 94 // Check heap parameter properties | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
95 if (min_heap_byte_size() < M) { |
| 0 | 96 vm_exit_during_initialization("Too small minimum heap"); |
| 97 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
98 if (initial_heap_byte_size() <= NewSize) { |
| 0 | 99 // make sure there is at least some room in old space |
| 100 vm_exit_during_initialization("Too small initial heap for new size specified"); | |
| 101 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
102 if (max_heap_byte_size() < min_heap_byte_size()) { |
| 0 | 103 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified"); |
| 104 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
105 if (initial_heap_byte_size() < min_heap_byte_size()) { |
| 0 | 106 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified"); |
| 107 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
108 if (max_heap_byte_size() < initial_heap_byte_size()) { |
| 0 | 109 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified"); |
| 110 } | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
111 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
112 if (PrintGCDetails && Verbose) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
113 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
|
114 SIZE_FORMAT " Maximum heap " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
115 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
|
116 } |
| 0 | 117 } |
| 118 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
119 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
|
120 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
|
121 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
|
122 return result; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
123 } |
| 0 | 124 |
| 125 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap, | |
| 126 int max_covered_regions) { | |
| 127 switch (rem_set_name()) { | |
| 128 case GenRemSet::CardTable: { | |
| 129 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions); | |
| 130 return res; | |
| 131 } | |
| 132 default: | |
| 133 guarantee(false, "unrecognized GenRemSet::Name"); | |
| 134 return NULL; | |
| 135 } | |
| 136 } | |
| 137 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
138 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
|
139 // 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
|
140 // 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
|
141 // 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
|
142 if (size_policy() != NULL) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
143 _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
|
144 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
145 _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
|
146 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
147 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
148 |
| 0 | 149 // GenCollectorPolicy methods. |
| 150 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
151 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
|
152 size_t x = base_size / (NewRatio+1); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
153 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
|
154 align_size_down(x, min_alignment()) : |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
155 min_alignment(); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
156 return new_gen_size; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
157 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
158 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
159 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
|
160 size_t maximum_size) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
161 size_t alignment = min_alignment(); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
162 size_t max_minus = maximum_size - alignment; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
163 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
|
164 } |
|
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 |
| 0 | 167 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size, |
| 168 size_t init_promo_size, | |
| 169 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
|
170 const double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0; |
| 0 | 171 _size_policy = new AdaptiveSizePolicy(init_eden_size, |
| 172 init_promo_size, | |
| 173 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
|
174 max_gc_pause_sec, |
| 0 | 175 GCTimeRatio); |
| 176 } | |
| 177 | |
| 178 size_t GenCollectorPolicy::compute_max_alignment() { | |
| 179 // The card marking array and the offset arrays for old generations are | |
| 180 // committed in os pages as well. Make sure they are entirely full (to | |
| 181 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1 | |
| 182 // byte entry and the os page size is 4096, the maximum heap size should | |
| 183 // be 512*4096 = 2MB aligned. | |
| 184 size_t alignment = GenRemSet::max_alignment_constraint(rem_set_name()); | |
| 185 | |
| 186 // Parallel GC does its own alignment of the generations to avoid requiring a | |
| 187 // large page (256M on some platforms) for the permanent generation. The | |
| 188 // other collectors should also be updated to do their own alignment and then | |
| 189 // this use of lcm() should be removed. | |
| 190 if (UseLargePages && !UseParallelGC) { | |
| 191 // in presence of large pages we have to make sure that our | |
| 192 // alignment is large page aware | |
| 193 alignment = lcm(os::large_page_size(), alignment); | |
| 194 } | |
| 195 | |
| 196 return alignment; | |
| 197 } | |
| 198 | |
| 199 void GenCollectorPolicy::initialize_flags() { | |
| 200 // All sizes must be multiples of the generation granularity. | |
| 201 set_min_alignment((uintx) Generation::GenGrain); | |
| 202 set_max_alignment(compute_max_alignment()); | |
| 203 | |
| 204 CollectorPolicy::initialize_flags(); | |
| 205 | |
| 206 // All generational heaps have a youngest gen; handle those flags here. | |
| 207 | |
| 208 // Adjust max size parameters | |
| 209 if (NewSize > MaxNewSize) { | |
| 210 MaxNewSize = NewSize; | |
| 211 } | |
| 212 NewSize = align_size_down(NewSize, min_alignment()); | |
| 213 MaxNewSize = align_size_down(MaxNewSize, min_alignment()); | |
| 214 | |
| 215 // Check validity of heap flags | |
| 216 assert(NewSize % min_alignment() == 0, "eden space alignment"); | |
| 217 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment"); | |
| 218 | |
| 219 if (NewSize < 3*min_alignment()) { | |
| 220 // make sure there room for eden and two survivor spaces | |
| 221 vm_exit_during_initialization("Too small new size specified"); | |
| 222 } | |
| 223 if (SurvivorRatio < 1 || NewRatio < 1) { | |
| 224 vm_exit_during_initialization("Invalid heap ratio specified"); | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 void TwoGenerationCollectorPolicy::initialize_flags() { | |
| 229 GenCollectorPolicy::initialize_flags(); | |
| 230 | |
| 231 OldSize = align_size_down(OldSize, min_alignment()); | |
|
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
232 |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
233 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) { |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
234 // 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
|
235 // 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
|
236 // and NewRatio. |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
237 assert(NewRatio > 0, "NewRatio should have been set up earlier"); |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
238 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1); |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
239 |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
240 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment()); |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
241 MaxHeapSize = calculated_heapsize; |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
242 InitialHeapSize = calculated_heapsize; |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
243 } |
| 0 | 244 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); |
| 245 | |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
246 // adjust max heap size if necessary |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
247 if (NewSize + OldSize > MaxHeapSize) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
248 if (FLAG_IS_CMDLINE(MaxHeapSize)) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
249 // somebody set a maximum heap size with the intention that we should not |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
250 // exceed it. Adjust New/OldSize as necessary. |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
251 uintx calculated_size = NewSize + OldSize; |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
252 double shrink_factor = (double) MaxHeapSize / calculated_size; |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
253 // align |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
254 NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment()); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
255 // OldSize is already aligned because above we aligned MaxHeapSize to |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
256 // max_alignment(), and we just made sure that NewSize is aligned to |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
257 // min_alignment(). In initialize_flags() we verified that max_alignment() |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
258 // is a multiple of min_alignment(). |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
259 OldSize = MaxHeapSize - NewSize; |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
260 } else { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
261 MaxHeapSize = NewSize + OldSize; |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
262 } |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
263 } |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
264 // need to do this again |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
265 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10239
diff
changeset
|
266 |
| 0 | 267 always_do_update_barrier = UseConcMarkSweepGC; |
| 268 | |
| 269 // Check validity of heap flags | |
| 270 assert(OldSize % min_alignment() == 0, "old space alignment"); | |
| 271 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment"); | |
| 272 } | |
| 273 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
274 // 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
|
275 // set command line parameters. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
276 // 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
|
277 // 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
|
278 // 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
|
279 // 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
|
280 // themselves and with overall heap sizings. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
281 // 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
|
282 // such as the use of NewRatio are used to size the generation. |
| 0 | 283 void GenCollectorPolicy::initialize_size_info() { |
| 284 CollectorPolicy::initialize_size_info(); | |
| 285 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
286 // 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
|
287 // 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
|
288 // 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
|
289 // generations sizes. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
290 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
291 // Determine maximum size of gen0 |
|
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 size_t max_new_size = 0; |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
294 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
|
295 if (MaxNewSize < min_alignment()) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
296 max_new_size = min_alignment(); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
297 } |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
298 if (MaxNewSize >= max_heap_byte_size()) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
299 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
|
300 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
301 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
|
302 "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
|
303 "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
|
304 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
|
305 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
306 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
|
307 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
308 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
309 // 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
|
310 // 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
|
311 // 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
|
312 // 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
|
313 // 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
|
314 // 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
|
315 // 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
|
316 // 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
|
317 // 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
|
318 // 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
|
319 // 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
|
320 // 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
|
321 // 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
|
322 // not always "wise". |
| 0 | 323 } else { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
324 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
|
325 // Bound the maximum size by NewSize below (since it historically |
| 0 | 326 // would have been NewSize and because the NewRatio calculation could |
| 327 // 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
|
328 // 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
|
329 // NewSize and MaxNewSize. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
330 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
|
331 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
332 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
|
333 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
334 // 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
|
335 // minimum gen0 sizes. |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
336 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
337 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
|
338 // 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
|
339 // 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
|
340 // same as its maximum. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
341 set_min_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
342 set_initial_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
343 set_max_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
344 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
345 size_t desired_new_size = 0; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
346 if (!FLAG_IS_DEFAULT(NewSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
347 // 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
|
348 // 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
|
349 // 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
|
350 // 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
|
351 // 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
|
352 // 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
|
353 // 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
|
354 // generally small compared to the NewRatio calculation. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
355 _min_gen0_size = NewSize; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
356 desired_new_size = NewSize; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
357 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
|
358 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
359 // 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
|
360 // 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
|
361 // 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
|
362 // 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
|
363 // small. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
364 _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
|
365 NewSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
366 desired_new_size = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
367 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
|
368 NewSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
369 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
370 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
371 assert(_min_gen0_size > 0, "Sanity check"); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
372 set_initial_gen0_size(desired_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
373 set_max_gen0_size(max_new_size); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
374 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
375 // 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
|
376 // determined without regard to the maximum sizes. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
377 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
378 // 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
|
379 set_min_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
380 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
|
381 set_initial_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
382 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
|
383 set_max_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
384 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
|
385 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
386 // 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
|
387 // maximum sizes but have not been checked for consistency |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
13
diff
changeset
|
388 // among the three. |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
389 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
390 // Final check min <= initial <= max |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
391 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
|
392 set_initial_gen0_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
393 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
|
394 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size)); |
| 0 | 395 } |
| 396 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
397 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
398 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
|
399 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
400 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
|
401 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
402 } |
| 0 | 403 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
404 // 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
|
405 // 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
|
406 // 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
|
407 // 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
|
408 // 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
|
409 // 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
|
410 // 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
|
411 // 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
|
412 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
|
413 size_t* gen1_size_ptr, |
|
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
414 const size_t heap_size, |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
415 const size_t min_gen1_size) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
416 bool result = false; |
|
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
417 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
418 if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) { |
|
8013
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
419 if ((heap_size < (*gen0_size_ptr + min_gen1_size)) && |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
420 (heap_size >= min_gen1_size + min_alignment())) { |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
421 // Adjust gen0 down to accommodate min_gen1_size |
|
95ccff9eee8e
6348447: Specifying -XX:OldSize crashes 64-bit VMs
jwilhelm
parents:
7451
diff
changeset
|
422 *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
|
423 *gen0_size_ptr = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
424 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
|
425 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
426 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
|
427 result = true; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
428 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
429 *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
|
430 *gen1_size_ptr = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
431 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
|
432 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
433 } |
|
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 return result; |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
436 } |
| 0 | 437 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
438 // 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
|
439 // 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
|
440 // 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
|
441 // 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
|
442 // 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
|
443 // but allow the values to pass. |
| 0 | 444 |
| 445 void TwoGenerationCollectorPolicy::initialize_size_info() { | |
| 446 GenCollectorPolicy::initialize_size_info(); | |
| 447 | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
448 // 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
|
449 // 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
|
450 // 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
|
451 // 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
|
452 // for setting the gen1 maximum. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
453 _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
|
454 _max_gen1_size = |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
455 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
|
456 min_alignment()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
457 // 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
|
458 // 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
|
459 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
|
460 // 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
|
461 // 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
|
462 // 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
|
463 // the minimum, maximum and initial sizes consistent |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
464 // 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
|
465 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
|
466 "gen0 has an unexpected minimum size"); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
467 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
|
468 set_min_gen1_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
469 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
|
470 min_alignment())); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
471 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
|
472 set_initial_gen1_size( |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
473 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
|
474 min_alignment())); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
475 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
476 } else { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
477 // 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
|
478 // OldSize and then determine the consequences. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
479 set_min_gen1_size(OldSize); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
480 set_initial_gen1_size(OldSize); |
|
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 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
|
483 // with other command line flags, issue a warning. |
| 0 | 484 // The generation minimums and the overall heap mimimum should |
| 485 // be within one heap alignment. | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
486 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
|
487 min_heap_byte_size()) { |
| 0 | 488 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
|
489 "generation sizes: using minimum heap = " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
490 min_heap_byte_size()); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
491 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
492 if ((OldSize > _max_gen1_size)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
493 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
|
494 "generation sizes: using maximum heap = " SIZE_FORMAT |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
495 " -XX:OldSize flag is being ignored", |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
496 max_heap_byte_size()); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
497 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
498 // 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
|
499 // 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
|
500 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
|
501 min_heap_byte_size(), OldSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
502 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
503 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
|
504 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
505 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
|
506 } |
| 0 | 507 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
508 // Initial size |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
509 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
|
510 initial_heap_byte_size(), OldSize)) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
511 if (PrintGCDetails && Verbose) { |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
1994
diff
changeset
|
512 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
|
513 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
514 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
|
515 } |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
516 } |
| 0 | 517 } |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
518 // Enforce the maximum gen1 size. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
519 set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size)); |
| 0 | 520 |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
521 // 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
|
522 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
|
523 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
|
524 |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
525 if (PrintGCDetails && Verbose) { |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
526 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
|
527 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT, |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
0
diff
changeset
|
528 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
|
529 } |
| 0 | 530 } |
| 531 | |
| 532 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size, | |
| 533 bool is_tlab, | |
| 534 bool* gc_overhead_limit_was_exceeded) { | |
| 535 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 536 | |
| 537 debug_only(gch->check_for_valid_allocation_state()); | |
| 538 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
|
539 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
540 // 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
|
541 // 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
|
542 // 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
|
543 *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
|
544 |
| 0 | 545 HeapWord* result = NULL; |
| 546 | |
| 547 // Loop until the allocation is satisified, | |
| 548 // or unsatisfied after GC. | |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
549 for (int try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) { |
| 0 | 550 HandleMark hm; // discard any handles allocated in each iteration |
| 551 | |
| 552 // First allocation attempt is lock-free. | |
| 553 Generation *gen0 = gch->get_gen(0); | |
| 554 assert(gen0->supports_inline_contig_alloc(), | |
| 555 "Otherwise, must do alloc within heap lock"); | |
| 556 if (gen0->should_allocate(size, is_tlab)) { | |
| 557 result = gen0->par_allocate(size, is_tlab); | |
| 558 if (result != NULL) { | |
| 559 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 560 return result; | |
| 561 } | |
| 562 } | |
| 563 unsigned int gc_count_before; // read inside the Heap_lock locked region | |
| 564 { | |
| 565 MutexLocker ml(Heap_lock); | |
| 566 if (PrintGC && Verbose) { | |
| 567 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:" | |
| 568 " attempting locked slow path allocation"); | |
| 569 } | |
| 570 // Note that only large objects get a shot at being | |
| 571 // allocated in later generations. | |
| 572 bool first_only = ! should_try_older_generation_allocation(size); | |
| 573 | |
| 574 result = gch->attempt_allocation(size, is_tlab, first_only); | |
| 575 if (result != NULL) { | |
| 576 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 577 return result; | |
| 578 } | |
| 579 | |
| 580 if (GC_locker::is_active_and_needs_gc()) { | |
| 581 if (is_tlab) { | |
| 582 return NULL; // Caller will retry allocating individual object | |
| 583 } | |
| 584 if (!gch->is_maximal_no_gc()) { | |
| 585 // Try and expand heap to satisfy request | |
| 586 result = expand_heap_and_allocate(size, is_tlab); | |
| 587 // result could be null if we are out of space | |
| 588 if (result != NULL) { | |
| 589 return result; | |
| 590 } | |
| 591 } | |
| 592 | |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
593 if (gclocker_stalled_count > GCLockerRetryAllocationCount) { |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
594 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
|
595 } |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
596 |
| 0 | 597 // If this thread is not in a jni critical section, we stall |
| 598 // the requestor until the critical section has cleared and | |
| 599 // GC allowed. When the critical section clears, a GC is | |
| 600 // initiated by the last thread exiting the critical section; so | |
| 601 // we retry the allocation sequence from the beginning of the loop, | |
| 602 // rather than causing more, now probably unnecessary, GC attempts. | |
| 603 JavaThread* jthr = JavaThread::current(); | |
| 604 if (!jthr->in_critical()) { | |
| 605 MutexUnlocker mul(Heap_lock); | |
| 606 // Wait for JNI critical section to be exited | |
| 607 GC_locker::stall_until_clear(); | |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8743
diff
changeset
|
608 gclocker_stalled_count += 1; |
| 0 | 609 continue; |
| 610 } else { | |
| 611 if (CheckJNICalls) { | |
| 612 fatal("Possible deadlock due to allocating while" | |
| 613 " in jni critical section"); | |
| 614 } | |
| 615 return NULL; | |
| 616 } | |
| 617 } | |
| 618 | |
| 619 // Read the gc count while the heap lock is held. | |
| 620 gc_count_before = Universe::heap()->total_collections(); | |
| 621 } | |
| 622 | |
| 623 VM_GenCollectForAllocation op(size, | |
| 624 is_tlab, | |
| 625 gc_count_before); | |
| 626 VMThread::execute(&op); | |
| 627 if (op.prologue_succeeded()) { | |
| 628 result = op.result(); | |
| 629 if (op.gc_locked()) { | |
| 630 assert(result == NULL, "must be NULL if gc_locked() is true"); | |
| 631 continue; // retry and/or stall as necessary | |
| 632 } | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
633 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
634 // 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
|
635 // 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
|
636 // 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
|
637 // 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
|
638 // 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
|
639 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
640 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
|
641 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
|
642 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
643 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
|
644 *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
|
645 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
|
646 if (op.result() != NULL) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
647 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
|
648 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
649 return NULL; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
650 } |
| 0 | 651 assert(result == NULL || gch->is_in_reserved(result), |
| 652 "result not in heap"); | |
| 653 return result; | |
| 654 } | |
| 655 | |
| 656 // Give a warning if we seem to be looping forever. | |
| 657 if ((QueuedAllocationWarningCount > 0) && | |
| 658 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 659 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t" | |
| 660 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : ""); | |
| 661 } | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size, | |
| 666 bool is_tlab) { | |
| 667 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 668 HeapWord* result = NULL; | |
| 669 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) { | |
| 670 Generation *gen = gch->get_gen(i); | |
| 671 if (gen->should_allocate(size, is_tlab)) { | |
| 672 result = gen->expand_and_allocate(size, is_tlab); | |
| 673 } | |
| 674 } | |
| 675 assert(result == NULL || gch->is_in_reserved(result), "result not in heap"); | |
| 676 return result; | |
| 677 } | |
| 678 | |
| 679 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size, | |
| 680 bool is_tlab) { | |
| 681 GenCollectedHeap *gch = GenCollectedHeap::heap(); | |
| 682 GCCauseSetter x(gch, GCCause::_allocation_failure); | |
| 683 HeapWord* result = NULL; | |
| 684 | |
| 685 assert(size != 0, "Precondition violated"); | |
| 686 if (GC_locker::is_active_and_needs_gc()) { | |
| 687 // GC locker is active; instead of a collection we will attempt | |
| 688 // to expand the heap, if there's room for expansion. | |
| 689 if (!gch->is_maximal_no_gc()) { | |
| 690 result = expand_heap_and_allocate(size, is_tlab); | |
| 691 } | |
| 692 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
|
693 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) { |
| 0 | 694 // Do an incremental collection. |
| 695 gch->do_collection(false /* full */, | |
| 696 false /* clear_all_soft_refs */, | |
| 697 size /* size */, | |
| 698 is_tlab /* is_tlab */, | |
| 699 number_of_generations() - 1 /* max_level */); | |
| 700 } else { | |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
701 if (Verbose && PrintGCDetails) { |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
702 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
|
703 } |
| 0 | 704 // Try a full collection; see delta for bug id 6266275 |
| 705 // for the original code and why this has been simplified | |
| 706 // with from-space allocation criteria modified and | |
| 707 // such allocation moved out of the safepoint path. | |
| 708 gch->do_collection(true /* full */, | |
| 709 false /* clear_all_soft_refs */, | |
| 710 size /* size */, | |
| 711 is_tlab /* is_tlab */, | |
| 712 number_of_generations() - 1 /* max_level */); | |
| 713 } | |
| 714 | |
| 715 result = gch->attempt_allocation(size, is_tlab, false /*first_only*/); | |
| 716 | |
| 717 if (result != NULL) { | |
| 718 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 719 return result; | |
| 720 } | |
| 721 | |
| 722 // OK, collection failed, try expansion. | |
| 723 result = expand_heap_and_allocate(size, is_tlab); | |
| 724 if (result != NULL) { | |
| 725 return result; | |
| 726 } | |
| 727 | |
| 728 // If we reach this point, we're really out of memory. Try every trick | |
| 729 // we can to reclaim memory. Force collection of soft references. Force | |
| 730 // a complete compaction of the heap. Any additional methods for finding | |
| 731 // free memory should be here, especially if they are expensive. If this | |
| 732 // attempt fails, an OOM exception will be thrown. | |
| 733 { | |
| 734 IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted | |
| 735 | |
| 736 gch->do_collection(true /* full */, | |
| 737 true /* clear_all_soft_refs */, | |
| 738 size /* size */, | |
| 739 is_tlab /* is_tlab */, | |
| 740 number_of_generations() - 1 /* max_level */); | |
| 741 } | |
| 742 | |
| 743 result = gch->attempt_allocation(size, is_tlab, false /* first_only */); | |
| 744 if (result != NULL) { | |
| 745 assert(gch->is_in_reserved(result), "result not in heap"); | |
| 746 return result; | |
| 747 } | |
| 748 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1064
diff
changeset
|
749 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
|
750 "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
|
751 |
| 0 | 752 // What else? We might try synchronous finalization later. If the total |
| 753 // space available is large enough for the allocation, then a more | |
| 754 // complete compaction phase than we've tried so far might be | |
| 755 // appropriate. | |
| 756 return NULL; | |
| 757 } | |
| 758 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
759 MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation( |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
760 ClassLoaderData* loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
761 size_t word_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
762 Metaspace::MetadataType mdtype) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
763 uint loop_count = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
764 uint gc_count = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
765 uint full_gc_count = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
766 |
|
6923
3fadc0e8cffe
8000988: VM deadlock when running btree006 on windows-i586
jmasa
parents:
6753
diff
changeset
|
767 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
|
768 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
769 do { |
|
6753
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
770 MetaWord* result = NULL; |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
771 if (GC_locker::is_active_and_needs_gc()) { |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
772 // 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
|
773 // 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
|
774 // in a critical section itself. |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
775 result = |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
776 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
|
777 mdtype); |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
778 if (result != NULL) { |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
779 return result; |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
780 } |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
781 JavaThread* jthr = JavaThread::current(); |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
782 if (!jthr->in_critical()) { |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
783 // Wait for JNI critical section to be exited |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
784 GC_locker::stall_until_clear(); |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
785 // 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
|
786 // 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
|
787 // is (currently) needed for unloading classes so continue |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
788 // 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
|
789 continue; |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
790 } else { |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
791 if (CheckJNICalls) { |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
792 fatal("Possible deadlock due to allocating while" |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
793 " in jni critical section"); |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
794 } |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
795 return NULL; |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
796 } |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
797 } |
|
8da5e203b993
7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently
jmasa
parents:
6725
diff
changeset
|
798 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
799 { // 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
|
800 MutexLocker ml(Heap_lock); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
801 gc_count = Universe::heap()->total_collections(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
802 full_gc_count = Universe::heap()->total_full_collections(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
803 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
804 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
805 // Generate a VM operation |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
806 VM_CollectForMetadataAllocation op(loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
807 word_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
808 mdtype, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
809 gc_count, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
810 full_gc_count, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
811 GCCause::_metadata_GC_threshold); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
812 VMThread::execute(&op); |
|
7446
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
813 |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
814 // 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
|
815 // before checking success because the prologue |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
816 // 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
|
817 // been locked out. |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
818 if (op.gc_locked()) { |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
819 continue; |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
820 } |
|
e51c9860cf66
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
7180
diff
changeset
|
821 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
822 if (op.prologue_succeeded()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
823 return op.result(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
824 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
825 loop_count++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
826 if ((QueuedAllocationWarningCount > 0) && |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
827 (loop_count % QueuedAllocationWarningCount == 0)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
828 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
|
829 " size=%d", loop_count, word_size); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
830 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
831 } while (true); // Until a GC is done |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
832 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
833 |
| 0 | 834 // Return true if any of the following is true: |
| 835 // . the allocation won't fit into the current young gen heap | |
| 836 // . gc locker is occupied (jni critical section) | |
| 837 // . heap memory is tight -- the most recent previous collection | |
| 838 // was a full collection because a partial collection (would | |
| 839 // have) failed and is likely to fail again | |
| 840 bool GenCollectorPolicy::should_try_older_generation_allocation( | |
| 841 size_t word_size) const { | |
| 842 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 843 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc(); | |
| 844 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
|
845 || 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
|
846 || gch->incremental_collection_failed(); |
| 0 | 847 } |
| 848 | |
| 849 | |
| 850 // | |
| 851 // MarkSweepPolicy methods | |
| 852 // | |
| 853 | |
| 854 MarkSweepPolicy::MarkSweepPolicy() { | |
| 855 initialize_all(); | |
| 856 } | |
| 857 | |
| 858 void MarkSweepPolicy::initialize_generations() { | |
| 10135 | 859 _generations = new GenerationSpecPtr[number_of_generations()]; |
| 0 | 860 if (_generations == NULL) |
| 861 vm_exit_during_initialization("Unable to allocate gen spec"); | |
| 862 | |
|
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
|
863 if (UseParNewGC) { |
| 0 | 864 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size); |
| 865 } else { | |
| 866 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size); | |
| 867 } | |
| 868 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size); | |
| 869 | |
| 870 if (_generations[0] == NULL || _generations[1] == NULL) | |
| 871 vm_exit_during_initialization("Unable to allocate gen spec"); | |
| 872 } | |
| 873 | |
| 874 void MarkSweepPolicy::initialize_gc_policy_counters() { | |
| 875 // 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
|
876 if (UseParNewGC) { |
| 0 | 877 _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
|
878 } else { |
| 0 | 879 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3); |
| 880 } | |
| 881 } |