annotate src/share/vm/memory/collectorPolicy.cpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children dde920245681
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1387
diff changeset
2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
26 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
27 #include "gc_implementation/shared/gcPolicyCounters.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
28 #include "gc_implementation/shared/vmGCOperations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
29 #include "memory/cardTableRS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
30 #include "memory/collectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
31 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
32 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
33 #include "memory/generationSpec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
34 #include "memory/space.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
35 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
36 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
37 #include "runtime/globals_extension.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
38 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
39 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
40 #include "runtime/vmThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
41 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
42 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
43 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
44 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
45 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
46 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
47 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
48 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
49 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
50 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
51 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
52 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1888
diff changeset
53 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
54
a61af66fc99e Initial load
duke
parents:
diff changeset
55 // CollectorPolicy methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
56
a61af66fc99e Initial load
duke
parents:
diff changeset
57 void CollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
58 if (PermSize > MaxPermSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
59 MaxPermSize = PermSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
60 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
61 PermSize = MAX2(min_alignment(), align_size_down_(PermSize, min_alignment()));
1795
a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents: 1552
diff changeset
62 // Don't increase Perm size limit above specified.
a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents: 1552
diff changeset
63 MaxPermSize = align_size_down(MaxPermSize, max_alignment());
a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents: 1552
diff changeset
64 if (PermSize > MaxPermSize) {
a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents: 1552
diff changeset
65 PermSize = MaxPermSize;
a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops
kvn
parents: 1552
diff changeset
66 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
67
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
68 MinPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MinPermHeapExpansion, min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
69 MaxPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MaxPermHeapExpansion, min_alignment()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
70
a61af66fc99e Initial load
duke
parents:
diff changeset
71 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
74 SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
75 SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
76
a61af66fc99e Initial load
duke
parents:
diff changeset
77 assert(PermSize % min_alignment() == 0, "permanent space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
78 assert(MaxPermSize % max_alignment() == 0, "maximum permanent space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
79 assert(SharedReadOnlySize % max_alignment() == 0, "read-only space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
80 assert(SharedReadWriteSize % max_alignment() == 0, "read-write space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
81 assert(SharedMiscDataSize % max_alignment() == 0, "misc-data space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
82 if (PermSize < M) {
a61af66fc99e Initial load
duke
parents:
diff changeset
83 vm_exit_during_initialization("Too small initial permanent heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85 }
a61af66fc99e Initial load
duke
parents:
diff changeset
86
a61af66fc99e Initial load
duke
parents:
diff changeset
87 void CollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // User inputs from -mx and ms are aligned
1064
473cce303f13 6887571: Increase default heap config sizes
phh
parents: 356
diff changeset
89 set_initial_heap_byte_size(InitialHeapSize);
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
90 if (initial_heap_byte_size() == 0) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
91 set_initial_heap_byte_size(NewSize + OldSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
92 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
93 set_initial_heap_byte_size(align_size_up(_initial_heap_byte_size,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
94 min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
95
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
96 set_min_heap_byte_size(Arguments::min_heap_size());
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
97 if (min_heap_byte_size() == 0) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
98 set_min_heap_byte_size(NewSize + OldSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
99 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
100 set_min_heap_byte_size(align_size_up(_min_heap_byte_size,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
101 min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
102
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
103 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
104
a61af66fc99e Initial load
duke
parents:
diff changeset
105 // Check heap parameter properties
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
106 if (initial_heap_byte_size() < M) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
107 vm_exit_during_initialization("Too small initial heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
108 }
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // Check heap parameter properties
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
110 if (min_heap_byte_size() < M) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
111 vm_exit_during_initialization("Too small minimum heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
112 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
113 if (initial_heap_byte_size() <= NewSize) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // make sure there is at least some room in old space
a61af66fc99e Initial load
duke
parents:
diff changeset
115 vm_exit_during_initialization("Too small initial heap for new size specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
116 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
117 if (max_heap_byte_size() < min_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
118 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
119 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
120 if (initial_heap_byte_size() < min_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
121 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
122 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
123 if (max_heap_byte_size() < initial_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
124 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
125 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
126
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
127 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
128 gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
129 SIZE_FORMAT " Maximum heap " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
130 min_heap_byte_size(), initial_heap_byte_size(), max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
131 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
132 }
a61af66fc99e Initial load
duke
parents:
diff changeset
133
a61af66fc99e Initial load
duke
parents:
diff changeset
134 void CollectorPolicy::initialize_perm_generation(PermGen::Name pgnm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
135 _permanent_generation =
a61af66fc99e Initial load
duke
parents:
diff changeset
136 new PermanentGenerationSpec(pgnm, PermSize, MaxPermSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
137 SharedReadOnlySize,
a61af66fc99e Initial load
duke
parents:
diff changeset
138 SharedReadWriteSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
139 SharedMiscDataSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
140 SharedMiscCodeSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
141 if (_permanent_generation == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
142 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
144 }
a61af66fc99e Initial load
duke
parents:
diff changeset
145
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
146 bool CollectorPolicy::use_should_clear_all_soft_refs(bool v) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
147 bool result = _should_clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
148 set_should_clear_all_soft_refs(false);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
149 return result;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
150 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
151
a61af66fc99e Initial load
duke
parents:
diff changeset
152 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
a61af66fc99e Initial load
duke
parents:
diff changeset
153 int max_covered_regions) {
a61af66fc99e Initial load
duke
parents:
diff changeset
154 switch (rem_set_name()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
155 case GenRemSet::CardTable: {
a61af66fc99e Initial load
duke
parents:
diff changeset
156 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions);
a61af66fc99e Initial load
duke
parents:
diff changeset
157 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
158 }
a61af66fc99e Initial load
duke
parents:
diff changeset
159 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
160 guarantee(false, "unrecognized GenRemSet::Name");
a61af66fc99e Initial load
duke
parents:
diff changeset
161 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
162 }
a61af66fc99e Initial load
duke
parents:
diff changeset
163 }
a61af66fc99e Initial load
duke
parents:
diff changeset
164
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
165 void CollectorPolicy::cleared_all_soft_refs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
166 // If near gc overhear limit, continue to clear SoftRefs. SoftRefs may
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
167 // have been cleared in the last collection but if the gc overhear
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
168 // limit continues to be near, SoftRefs should still be cleared.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
169 if (size_policy() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
170 _should_clear_all_soft_refs = size_policy()->gc_overhead_limit_near();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
171 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
172 _all_soft_refs_clear = true;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
173 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
174
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
175
0
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // GenCollectorPolicy methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
177
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
178 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
179 size_t x = base_size / (NewRatio+1);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
180 size_t new_gen_size = x > min_alignment() ?
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
181 align_size_down(x, min_alignment()) :
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
182 min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
183 return new_gen_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
184 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
185
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
186 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
187 size_t maximum_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
188 size_t alignment = min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
189 size_t max_minus = maximum_size - alignment;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
190 return desired_size < max_minus ? desired_size : max_minus;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
191 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
192
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
193
0
a61af66fc99e Initial load
duke
parents:
diff changeset
194 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
195 size_t init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
196 size_t init_survivor_size) {
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
197 const double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
198 _size_policy = new AdaptiveSizePolicy(init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
199 init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
200 init_survivor_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
201 max_gc_minor_pause_sec,
a61af66fc99e Initial load
duke
parents:
diff changeset
202 GCTimeRatio);
a61af66fc99e Initial load
duke
parents:
diff changeset
203 }
a61af66fc99e Initial load
duke
parents:
diff changeset
204
a61af66fc99e Initial load
duke
parents:
diff changeset
205 size_t GenCollectorPolicy::compute_max_alignment() {
a61af66fc99e Initial load
duke
parents:
diff changeset
206 // The card marking array and the offset arrays for old generations are
a61af66fc99e Initial load
duke
parents:
diff changeset
207 // committed in os pages as well. Make sure they are entirely full (to
a61af66fc99e Initial load
duke
parents:
diff changeset
208 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
a61af66fc99e Initial load
duke
parents:
diff changeset
209 // byte entry and the os page size is 4096, the maximum heap size should
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // be 512*4096 = 2MB aligned.
a61af66fc99e Initial load
duke
parents:
diff changeset
211 size_t alignment = GenRemSet::max_alignment_constraint(rem_set_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
212
a61af66fc99e Initial load
duke
parents:
diff changeset
213 // Parallel GC does its own alignment of the generations to avoid requiring a
a61af66fc99e Initial load
duke
parents:
diff changeset
214 // large page (256M on some platforms) for the permanent generation. The
a61af66fc99e Initial load
duke
parents:
diff changeset
215 // other collectors should also be updated to do their own alignment and then
a61af66fc99e Initial load
duke
parents:
diff changeset
216 // this use of lcm() should be removed.
a61af66fc99e Initial load
duke
parents:
diff changeset
217 if (UseLargePages && !UseParallelGC) {
a61af66fc99e Initial load
duke
parents:
diff changeset
218 // in presence of large pages we have to make sure that our
a61af66fc99e Initial load
duke
parents:
diff changeset
219 // alignment is large page aware
a61af66fc99e Initial load
duke
parents:
diff changeset
220 alignment = lcm(os::large_page_size(), alignment);
a61af66fc99e Initial load
duke
parents:
diff changeset
221 }
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 return alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 }
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 void GenCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
227 // All sizes must be multiples of the generation granularity.
a61af66fc99e Initial load
duke
parents:
diff changeset
228 set_min_alignment((uintx) Generation::GenGrain);
a61af66fc99e Initial load
duke
parents:
diff changeset
229 set_max_alignment(compute_max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
230 assert(max_alignment() >= min_alignment() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
231 max_alignment() % min_alignment() == 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
232 "invalid alignment constraints");
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234 CollectorPolicy::initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 // All generational heaps have a youngest gen; handle those flags here.
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 // Adjust max size parameters
a61af66fc99e Initial load
duke
parents:
diff changeset
239 if (NewSize > MaxNewSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
240 MaxNewSize = NewSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
241 }
a61af66fc99e Initial load
duke
parents:
diff changeset
242 NewSize = align_size_down(NewSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
243 MaxNewSize = align_size_down(MaxNewSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
244
a61af66fc99e Initial load
duke
parents:
diff changeset
245 // Check validity of heap flags
a61af66fc99e Initial load
duke
parents:
diff changeset
246 assert(NewSize % min_alignment() == 0, "eden space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
247 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
249 if (NewSize < 3*min_alignment()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // make sure there room for eden and two survivor spaces
a61af66fc99e Initial load
duke
parents:
diff changeset
251 vm_exit_during_initialization("Too small new size specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
252 }
a61af66fc99e Initial load
duke
parents:
diff changeset
253 if (SurvivorRatio < 1 || NewRatio < 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
254 vm_exit_during_initialization("Invalid heap ratio specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
255 }
a61af66fc99e Initial load
duke
parents:
diff changeset
256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258 void TwoGenerationCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
259 GenCollectorPolicy::initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
260
a61af66fc99e Initial load
duke
parents:
diff changeset
261 OldSize = align_size_down(OldSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
262 if (NewSize + OldSize > MaxHeapSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
263 MaxHeapSize = NewSize + OldSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
264 }
a61af66fc99e Initial load
duke
parents:
diff changeset
265 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
266
a61af66fc99e Initial load
duke
parents:
diff changeset
267 always_do_update_barrier = UseConcMarkSweepGC;
a61af66fc99e Initial load
duke
parents:
diff changeset
268 BlockOffsetArrayUseUnallocatedBlock =
a61af66fc99e Initial load
duke
parents:
diff changeset
269 BlockOffsetArrayUseUnallocatedBlock || ParallelGCThreads > 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
270
a61af66fc99e Initial load
duke
parents:
diff changeset
271 // Check validity of heap flags
a61af66fc99e Initial load
duke
parents:
diff changeset
272 assert(OldSize % min_alignment() == 0, "old space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
273 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
274 }
a61af66fc99e Initial load
duke
parents:
diff changeset
275
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
276 // Values set on the command line win over any ergonomically
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
277 // set command line parameters.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
278 // Ergonomic choice of parameters are done before this
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
279 // method is called. Values for command line parameters such as NewSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
280 // and MaxNewSize feed those ergonomic choices into this method.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
281 // This method makes the final generation sizings consistent with
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
282 // themselves and with overall heap sizings.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
283 // In the absence of explicitly set command line flags, policies
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
284 // such as the use of NewRatio are used to size the generation.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
285 void GenCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
286 CollectorPolicy::initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
287
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
288 // min_alignment() is used for alignment within a generation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
289 // There is additional alignment done down stream for some
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
290 // collectors that sometimes causes unwanted rounding up of
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
291 // generations sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
292
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
293 // Determine maximum size of gen0
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
294
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
295 size_t max_new_size = 0;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
296 if (FLAG_IS_CMDLINE(MaxNewSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
297 if (MaxNewSize < min_alignment()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
298 max_new_size = min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
299 } else if (MaxNewSize >= max_heap_byte_size()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
300 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
301 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
302 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
303 "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
304 "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
305 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
306 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
307 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
308 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
309
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
310 // 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
311 // 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
312 // 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
313 // 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
314 // 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
315 // 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
316 // 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
317 // 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
318 // 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
319 // 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
320 // 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
321 // 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
322 // 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
323 // not always "wise".
0
a61af66fc99e Initial load
duke
parents:
diff changeset
324 } else {
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
325 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
326 // Bound the maximum size by NewSize below (since it historically
0
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // would have been NewSize and because the NewRatio calculation could
a61af66fc99e Initial load
duke
parents:
diff changeset
328 // 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
329 // 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
330 // NewSize and MaxNewSize.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
331 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
332 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
333 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
334
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
335 // Given the maximum gen0 size, determine the initial and
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
336 // minimum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
337
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
338 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
339 // 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
340 // 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
341 // same as its maximum.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
342 set_min_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
343 set_initial_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
344 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
345 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
346 size_t desired_new_size = 0;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
347 if (!FLAG_IS_DEFAULT(NewSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
348 // 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
349 // 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
350 // 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
351 // 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
352 // 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
353 // 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
354 // 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
355 // generally small compared to the NewRatio calculation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
356 _min_gen0_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
357 desired_new_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
358 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
359 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
360 // 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
361 // 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
362 // 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
363 // 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
364 // small.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
365 _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
366 NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
367 desired_new_size =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
368 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
369 NewSize);
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
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
372 assert(_min_gen0_size > 0, "Sanity check");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
373 set_initial_gen0_size(desired_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
374 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
375
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
376 // At this point 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
377 // determined without regard to the maximum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
378
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
379 // 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
380 set_min_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
381 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
382 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
383 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
384 set_max_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
385 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
386
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
387 // 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
388 // maximum sizes but have not been checked for consistency
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
389 // among the three.
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
390
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
391 // Final check min <= initial <= max
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
392 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
393 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
394 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
395 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
396 }
a61af66fc99e Initial load
duke
parents:
diff changeset
397
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
398 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
399 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
400 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
401 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
402 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
403 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
404
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
405 // 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
406 // 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
407 // 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
408 // 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
409 // 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
410 // 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
411 // 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
412 // 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
413 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
414 size_t* gen1_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
415 size_t heap_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
416 size_t min_gen0_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
417 bool result = false;
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) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
419 if (((*gen0_size_ptr + OldSize) > heap_size) &&
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
420 (heap_size - min_gen0_size) >= min_alignment()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
421 // Adjust gen0 down to accomodate OldSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
422 *gen0_size_ptr = heap_size - min_gen0_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
444
a61af66fc99e Initial load
duke
parents:
diff changeset
445 void TwoGenerationCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
446 GenCollectorPolicy::initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
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
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
451 // and maximum heap size since not explicit flags exits
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
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // The generation minimums and the overall heap mimimum should
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
497 }
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) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
503 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
512 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
530 }
a61af66fc99e Initial load
duke
parents:
diff changeset
531
a61af66fc99e Initial load
duke
parents:
diff changeset
532 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
533 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
534 bool* gc_overhead_limit_was_exceeded) {
a61af66fc99e Initial load
duke
parents:
diff changeset
535 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
536
a61af66fc99e Initial load
duke
parents:
diff changeset
537 debug_only(gch->check_for_valid_allocation_state());
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
545 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
546
a61af66fc99e Initial load
duke
parents:
diff changeset
547 // Loop until the allocation is satisified,
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // or unsatisfied after GC.
a61af66fc99e Initial load
duke
parents:
diff changeset
549 for (int try_count = 1; /* return or throw */; try_count += 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
550 HandleMark hm; // discard any handles allocated in each iteration
a61af66fc99e Initial load
duke
parents:
diff changeset
551
a61af66fc99e Initial load
duke
parents:
diff changeset
552 // First allocation attempt is lock-free.
a61af66fc99e Initial load
duke
parents:
diff changeset
553 Generation *gen0 = gch->get_gen(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
554 assert(gen0->supports_inline_contig_alloc(),
a61af66fc99e Initial load
duke
parents:
diff changeset
555 "Otherwise, must do alloc within heap lock");
a61af66fc99e Initial load
duke
parents:
diff changeset
556 if (gen0->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
557 result = gen0->par_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
558 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
559 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
560 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
561 }
a61af66fc99e Initial load
duke
parents:
diff changeset
562 }
a61af66fc99e Initial load
duke
parents:
diff changeset
563 unsigned int gc_count_before; // read inside the Heap_lock locked region
a61af66fc99e Initial load
duke
parents:
diff changeset
564 {
a61af66fc99e Initial load
duke
parents:
diff changeset
565 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
566 if (PrintGC && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
567 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:"
a61af66fc99e Initial load
duke
parents:
diff changeset
568 " attempting locked slow path allocation");
a61af66fc99e Initial load
duke
parents:
diff changeset
569 }
a61af66fc99e Initial load
duke
parents:
diff changeset
570 // Note that only large objects get a shot at being
a61af66fc99e Initial load
duke
parents:
diff changeset
571 // allocated in later generations.
a61af66fc99e Initial load
duke
parents:
diff changeset
572 bool first_only = ! should_try_older_generation_allocation(size);
a61af66fc99e Initial load
duke
parents:
diff changeset
573
a61af66fc99e Initial load
duke
parents:
diff changeset
574 result = gch->attempt_allocation(size, is_tlab, first_only);
a61af66fc99e Initial load
duke
parents:
diff changeset
575 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
576 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
577 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
578 }
a61af66fc99e Initial load
duke
parents:
diff changeset
579
a61af66fc99e Initial load
duke
parents:
diff changeset
580 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
581 if (is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
582 return NULL; // Caller will retry allocating individual object
a61af66fc99e Initial load
duke
parents:
diff changeset
583 }
a61af66fc99e Initial load
duke
parents:
diff changeset
584 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
585 // Try and expand heap to satisfy request
a61af66fc99e Initial load
duke
parents:
diff changeset
586 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
587 // result could be null if we are out of space
a61af66fc99e Initial load
duke
parents:
diff changeset
588 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
589 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
590 }
a61af66fc99e Initial load
duke
parents:
diff changeset
591 }
a61af66fc99e Initial load
duke
parents:
diff changeset
592
a61af66fc99e Initial load
duke
parents:
diff changeset
593 // If this thread is not in a jni critical section, we stall
a61af66fc99e Initial load
duke
parents:
diff changeset
594 // the requestor until the critical section has cleared and
a61af66fc99e Initial load
duke
parents:
diff changeset
595 // GC allowed. When the critical section clears, a GC is
a61af66fc99e Initial load
duke
parents:
diff changeset
596 // initiated by the last thread exiting the critical section; so
a61af66fc99e Initial load
duke
parents:
diff changeset
597 // we retry the allocation sequence from the beginning of the loop,
a61af66fc99e Initial load
duke
parents:
diff changeset
598 // rather than causing more, now probably unnecessary, GC attempts.
a61af66fc99e Initial load
duke
parents:
diff changeset
599 JavaThread* jthr = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
600 if (!jthr->in_critical()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
601 MutexUnlocker mul(Heap_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
602 // Wait for JNI critical section to be exited
a61af66fc99e Initial load
duke
parents:
diff changeset
603 GC_locker::stall_until_clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
604 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
605 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
606 if (CheckJNICalls) {
a61af66fc99e Initial load
duke
parents:
diff changeset
607 fatal("Possible deadlock due to allocating while"
a61af66fc99e Initial load
duke
parents:
diff changeset
608 " in jni critical section");
a61af66fc99e Initial load
duke
parents:
diff changeset
609 }
a61af66fc99e Initial load
duke
parents:
diff changeset
610 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
611 }
a61af66fc99e Initial load
duke
parents:
diff changeset
612 }
a61af66fc99e Initial load
duke
parents:
diff changeset
613
a61af66fc99e Initial load
duke
parents:
diff changeset
614 // Read the gc count while the heap lock is held.
a61af66fc99e Initial load
duke
parents:
diff changeset
615 gc_count_before = Universe::heap()->total_collections();
a61af66fc99e Initial load
duke
parents:
diff changeset
616 }
a61af66fc99e Initial load
duke
parents:
diff changeset
617
a61af66fc99e Initial load
duke
parents:
diff changeset
618 VM_GenCollectForAllocation op(size,
a61af66fc99e Initial load
duke
parents:
diff changeset
619 is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
620 gc_count_before);
a61af66fc99e Initial load
duke
parents:
diff changeset
621 VMThread::execute(&op);
a61af66fc99e Initial load
duke
parents:
diff changeset
622 if (op.prologue_succeeded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
623 result = op.result();
a61af66fc99e Initial load
duke
parents:
diff changeset
624 if (op.gc_locked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
625 assert(result == NULL, "must be NULL if gc_locked() is true");
a61af66fc99e Initial load
duke
parents:
diff changeset
626 continue; // retry and/or stall as necessary
a61af66fc99e Initial load
duke
parents:
diff changeset
627 }
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
628
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
629 // 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
630 // 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
631 // 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
632 // 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
633 // 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
634
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
635 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
636 const bool softrefs_clear = all_soft_refs_clear();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
637 assert(!limit_exceeded || softrefs_clear, "Should have been cleared");
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
638 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
639 *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
640 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
641 if (op.result() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
642 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
643 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
644 return NULL;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
645 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
646 assert(result == NULL || gch->is_in_reserved(result),
a61af66fc99e Initial load
duke
parents:
diff changeset
647 "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
648 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
649 }
a61af66fc99e Initial load
duke
parents:
diff changeset
650
a61af66fc99e Initial load
duke
parents:
diff changeset
651 // Give a warning if we seem to be looping forever.
a61af66fc99e Initial load
duke
parents:
diff changeset
652 if ((QueuedAllocationWarningCount > 0) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
653 (try_count % QueuedAllocationWarningCount == 0)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
654 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t"
a61af66fc99e Initial load
duke
parents:
diff changeset
655 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : "");
a61af66fc99e Initial load
duke
parents:
diff changeset
656 }
a61af66fc99e Initial load
duke
parents:
diff changeset
657 }
a61af66fc99e Initial load
duke
parents:
diff changeset
658 }
a61af66fc99e Initial load
duke
parents:
diff changeset
659
a61af66fc99e Initial load
duke
parents:
diff changeset
660 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
661 bool is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
662 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
663 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
664 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
665 Generation *gen = gch->get_gen(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
666 if (gen->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
667 result = gen->expand_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
668 }
a61af66fc99e Initial load
duke
parents:
diff changeset
669 }
a61af66fc99e Initial load
duke
parents:
diff changeset
670 assert(result == NULL || gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
671 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
672 }
a61af66fc99e Initial load
duke
parents:
diff changeset
673
a61af66fc99e Initial load
duke
parents:
diff changeset
674 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
675 bool is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
676 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
677 GCCauseSetter x(gch, GCCause::_allocation_failure);
a61af66fc99e Initial load
duke
parents:
diff changeset
678 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
679
a61af66fc99e Initial load
duke
parents:
diff changeset
680 assert(size != 0, "Precondition violated");
a61af66fc99e Initial load
duke
parents:
diff changeset
681 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
682 // GC locker is active; instead of a collection we will attempt
a61af66fc99e Initial load
duke
parents:
diff changeset
683 // to expand the heap, if there's room for expansion.
a61af66fc99e Initial load
duke
parents:
diff changeset
684 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
685 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
686 }
a61af66fc99e Initial load
duke
parents:
diff changeset
687 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
688 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
689 // Do an incremental collection.
a61af66fc99e Initial load
duke
parents:
diff changeset
690 gch->do_collection(false /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
691 false /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
692 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
693 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
694 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
695 } else {
1994
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 1972
diff changeset
696 if (Verbose && PrintGCDetails) {
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 1972
diff changeset
697 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
698 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
699 // Try a full collection; see delta for bug id 6266275
a61af66fc99e Initial load
duke
parents:
diff changeset
700 // for the original code and why this has been simplified
a61af66fc99e Initial load
duke
parents:
diff changeset
701 // with from-space allocation criteria modified and
a61af66fc99e Initial load
duke
parents:
diff changeset
702 // such allocation moved out of the safepoint path.
a61af66fc99e Initial load
duke
parents:
diff changeset
703 gch->do_collection(true /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
704 false /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
705 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
706 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
707 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
708 }
a61af66fc99e Initial load
duke
parents:
diff changeset
709
a61af66fc99e Initial load
duke
parents:
diff changeset
710 result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
a61af66fc99e Initial load
duke
parents:
diff changeset
711
a61af66fc99e Initial load
duke
parents:
diff changeset
712 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
713 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
714 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
715 }
a61af66fc99e Initial load
duke
parents:
diff changeset
716
a61af66fc99e Initial load
duke
parents:
diff changeset
717 // OK, collection failed, try expansion.
a61af66fc99e Initial load
duke
parents:
diff changeset
718 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
719 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
720 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
721 }
a61af66fc99e Initial load
duke
parents:
diff changeset
722
a61af66fc99e Initial load
duke
parents:
diff changeset
723 // If we reach this point, we're really out of memory. Try every trick
a61af66fc99e Initial load
duke
parents:
diff changeset
724 // we can to reclaim memory. Force collection of soft references. Force
a61af66fc99e Initial load
duke
parents:
diff changeset
725 // a complete compaction of the heap. Any additional methods for finding
a61af66fc99e Initial load
duke
parents:
diff changeset
726 // free memory should be here, especially if they are expensive. If this
a61af66fc99e Initial load
duke
parents:
diff changeset
727 // attempt fails, an OOM exception will be thrown.
a61af66fc99e Initial load
duke
parents:
diff changeset
728 {
a61af66fc99e Initial load
duke
parents:
diff changeset
729 IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
a61af66fc99e Initial load
duke
parents:
diff changeset
730
a61af66fc99e Initial load
duke
parents:
diff changeset
731 gch->do_collection(true /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
732 true /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
733 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
734 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
735 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
736 }
a61af66fc99e Initial load
duke
parents:
diff changeset
737
a61af66fc99e Initial load
duke
parents:
diff changeset
738 result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
a61af66fc99e Initial load
duke
parents:
diff changeset
739 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
740 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
741 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
742 }
a61af66fc99e Initial load
duke
parents:
diff changeset
743
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1064
diff changeset
744 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
745 "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
746
0
a61af66fc99e Initial load
duke
parents:
diff changeset
747 // What else? We might try synchronous finalization later. If the total
a61af66fc99e Initial load
duke
parents:
diff changeset
748 // space available is large enough for the allocation, then a more
a61af66fc99e Initial load
duke
parents:
diff changeset
749 // complete compaction phase than we've tried so far might be
a61af66fc99e Initial load
duke
parents:
diff changeset
750 // appropriate.
a61af66fc99e Initial load
duke
parents:
diff changeset
751 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
752 }
a61af66fc99e Initial load
duke
parents:
diff changeset
753
a61af66fc99e Initial load
duke
parents:
diff changeset
754 size_t GenCollectorPolicy::large_typearray_limit() {
a61af66fc99e Initial load
duke
parents:
diff changeset
755 return FastAllocateSizeLimit;
a61af66fc99e Initial load
duke
parents:
diff changeset
756 }
a61af66fc99e Initial load
duke
parents:
diff changeset
757
a61af66fc99e Initial load
duke
parents:
diff changeset
758 // Return true if any of the following is true:
a61af66fc99e Initial load
duke
parents:
diff changeset
759 // . the allocation won't fit into the current young gen heap
a61af66fc99e Initial load
duke
parents:
diff changeset
760 // . gc locker is occupied (jni critical section)
a61af66fc99e Initial load
duke
parents:
diff changeset
761 // . heap memory is tight -- the most recent previous collection
a61af66fc99e Initial load
duke
parents:
diff changeset
762 // was a full collection because a partial collection (would
a61af66fc99e Initial load
duke
parents:
diff changeset
763 // have) failed and is likely to fail again
a61af66fc99e Initial load
duke
parents:
diff changeset
764 bool GenCollectorPolicy::should_try_older_generation_allocation(
a61af66fc99e Initial load
duke
parents:
diff changeset
765 size_t word_size) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
766 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
767 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
a61af66fc99e Initial load
duke
parents:
diff changeset
768 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
769 || 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
770 || gch->incremental_collection_failed();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
771 }
a61af66fc99e Initial load
duke
parents:
diff changeset
772
a61af66fc99e Initial load
duke
parents:
diff changeset
773
a61af66fc99e Initial load
duke
parents:
diff changeset
774 //
a61af66fc99e Initial load
duke
parents:
diff changeset
775 // MarkSweepPolicy methods
a61af66fc99e Initial load
duke
parents:
diff changeset
776 //
a61af66fc99e Initial load
duke
parents:
diff changeset
777
a61af66fc99e Initial load
duke
parents:
diff changeset
778 MarkSweepPolicy::MarkSweepPolicy() {
a61af66fc99e Initial load
duke
parents:
diff changeset
779 initialize_all();
a61af66fc99e Initial load
duke
parents:
diff changeset
780 }
a61af66fc99e Initial load
duke
parents:
diff changeset
781
a61af66fc99e Initial load
duke
parents:
diff changeset
782 void MarkSweepPolicy::initialize_generations() {
a61af66fc99e Initial load
duke
parents:
diff changeset
783 initialize_perm_generation(PermGen::MarkSweepCompact);
a61af66fc99e Initial load
duke
parents:
diff changeset
784 _generations = new GenerationSpecPtr[number_of_generations()];
a61af66fc99e Initial load
duke
parents:
diff changeset
785 if (_generations == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
786 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
787
a61af66fc99e Initial load
duke
parents:
diff changeset
788 if (UseParNewGC && ParallelGCThreads > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
789 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
790 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
791 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
792 }
a61af66fc99e Initial load
duke
parents:
diff changeset
793 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
794
a61af66fc99e Initial load
duke
parents:
diff changeset
795 if (_generations[0] == NULL || _generations[1] == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
796 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
798
a61af66fc99e Initial load
duke
parents:
diff changeset
799 void MarkSweepPolicy::initialize_gc_policy_counters() {
a61af66fc99e Initial load
duke
parents:
diff changeset
800 // initialize the policy counters - 2 collectors, 3 generations
a61af66fc99e Initial load
duke
parents:
diff changeset
801 if (UseParNewGC && ParallelGCThreads > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
802 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
803 }
a61af66fc99e Initial load
duke
parents:
diff changeset
804 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
805 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
806 }
a61af66fc99e Initial load
duke
parents:
diff changeset
807 }