Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/sharedHeap.cpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
author | ysr |
---|---|
date | Wed, 16 Mar 2011 10:37:08 -0700 |
parents | 3582bf76420e |
children | b099aaf51bf8 |
rev | line source |
---|---|
0 | 1 /* |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
989
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
989
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:
989
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/symbolTable.hpp" | |
27 #include "classfile/systemDictionary.hpp" | |
28 #include "code/codeCache.hpp" | |
29 #include "gc_interface/collectedHeap.inline.hpp" | |
30 #include "memory/sharedHeap.hpp" | |
31 #include "oops/oop.inline.hpp" | |
32 #include "runtime/fprofiler.hpp" | |
33 #include "runtime/java.hpp" | |
34 #include "services/management.hpp" | |
35 #include "utilities/copy.hpp" | |
36 #include "utilities/workgroup.hpp" | |
0 | 37 |
38 SharedHeap* SharedHeap::_sh; | |
39 | |
40 // The set of potentially parallel tasks in strong root scanning. | |
41 enum SH_process_strong_roots_tasks { | |
42 SH_PS_Universe_oops_do, | |
43 SH_PS_JNIHandles_oops_do, | |
44 SH_PS_ObjectSynchronizer_oops_do, | |
45 SH_PS_FlatProfiler_oops_do, | |
46 SH_PS_Management_oops_do, | |
47 SH_PS_SystemDictionary_oops_do, | |
48 SH_PS_jvmti_oops_do, | |
49 SH_PS_SymbolTable_oops_do, | |
50 SH_PS_StringTable_oops_do, | |
51 SH_PS_CodeCache_oops_do, | |
52 // Leave this one last. | |
53 SH_PS_NumElements | |
54 }; | |
55 | |
56 SharedHeap::SharedHeap(CollectorPolicy* policy_) : | |
57 CollectedHeap(), | |
58 _collector_policy(policy_), | |
59 _perm_gen(NULL), _rem_set(NULL), | |
60 _strong_roots_parity(0), | |
61 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)), | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
62 _n_par_threads(0), |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
63 _workers(NULL) |
0 | 64 { |
65 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { | |
66 vm_exit_during_initialization("Failed necessary allocation."); | |
67 } | |
68 _sh = this; // ch is static, should be set only once. | |
69 if ((UseParNewGC || | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
70 (UseConcMarkSweepGC && CMSParallelRemarkEnabled) || |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
71 UseG1GC) && |
0 | 72 ParallelGCThreads > 0) { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
73 _workers = new FlexibleWorkGang("Parallel GC Threads", ParallelGCThreads, |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
74 /* are_GC_task_threads */true, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
75 /* are_ConcurrentGC_threads */false); |
0 | 76 if (_workers == NULL) { |
77 vm_exit_during_initialization("Failed necessary allocation."); | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
78 } else { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
79 _workers->initialize_workers(); |
0 | 80 } |
81 } | |
82 } | |
83 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
84 bool SharedHeap::heap_lock_held_for_gc() { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
85 Thread* t = Thread::current(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
86 return Heap_lock->owned_by_self() |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
87 || ( (t->is_GC_task_thread() || t->is_VM_thread()) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
88 && _thread_holds_heap_lock_for_gc); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
89 } |
0 | 90 |
91 void SharedHeap::set_par_threads(int t) { | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
92 assert(t == 0 || !UseSerialGC, "Cannot have parallel threads"); |
0 | 93 _n_par_threads = t; |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
94 _process_strong_tasks->set_n_threads(t); |
0 | 95 } |
96 | |
97 class AssertIsPermClosure: public OopClosure { | |
98 public: | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
99 virtual void do_oop(oop* p) { |
0 | 100 assert((*p) == NULL || (*p)->is_perm(), "Referent should be perm."); |
101 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
102 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
0 | 103 }; |
104 static AssertIsPermClosure assert_is_perm_closure; | |
105 | |
106 void SharedHeap::change_strong_roots_parity() { | |
107 // Also set the new collection parity. | |
108 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2, | |
109 "Not in range."); | |
110 _strong_roots_parity++; | |
111 if (_strong_roots_parity == 3) _strong_roots_parity = 1; | |
112 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2, | |
113 "Not in range."); | |
114 } | |
115 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
116 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate) |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
117 : MarkScope(activate) |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
118 { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
119 if (_active) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
120 outer->change_strong_roots_parity(); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
121 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
122 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
123 |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
124 SharedHeap::StrongRootsScope::~StrongRootsScope() { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
125 // nothing particular |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
126 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
127 |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
128 void SharedHeap::process_strong_roots(bool activate_scope, |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
129 bool collecting_perm_gen, |
0 | 130 ScanningOption so, |
131 OopClosure* roots, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
132 CodeBlobClosure* code_roots, |
0 | 133 OopsInGenClosure* perm_blk) { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
134 StrongRootsScope srs(this, activate_scope); |
0 | 135 // General strong roots. |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
136 assert(_strong_roots_parity != 0, "must have called prologue code"); |
0 | 137 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) { |
138 Universe::oops_do(roots); | |
139 ReferenceProcessor::oops_do(roots); | |
140 // Consider perm-gen discovered lists to be strong. | |
141 perm_gen()->ref_processor()->weak_oops_do(roots); | |
142 } | |
143 // Global (strong) JNI handles | |
144 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do)) | |
145 JNIHandles::oops_do(roots); | |
146 // All threads execute this; the individual threads are task groups. | |
147 if (ParallelGCThreads > 0) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
148 Threads::possibly_parallel_oops_do(roots, code_roots); |
0 | 149 } else { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
150 Threads::oops_do(roots, code_roots); |
0 | 151 } |
152 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do)) | |
153 ObjectSynchronizer::oops_do(roots); | |
154 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do)) | |
155 FlatProfiler::oops_do(roots); | |
156 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do)) | |
157 Management::oops_do(roots); | |
158 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do)) | |
159 JvmtiExport::oops_do(roots); | |
160 | |
161 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) { | |
162 if (so & SO_AllClasses) { | |
163 SystemDictionary::oops_do(roots); | |
164 } else | |
165 if (so & SO_SystemClasses) { | |
166 SystemDictionary::always_strong_oops_do(roots); | |
167 } | |
168 } | |
169 | |
170 if (!_process_strong_tasks->is_task_claimed(SH_PS_SymbolTable_oops_do)) { | |
171 } | |
172 | |
173 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) { | |
174 if (so & SO_Strings) { | |
175 StringTable::oops_do(roots); | |
176 } | |
177 // Verify if the string table contents are in the perm gen | |
178 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure)); | |
179 } | |
180 | |
181 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
182 if (so & SO_CodeCache) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
183 // (Currently, CMSCollector uses this to do intermediate-strength collections.) |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
184 assert(collecting_perm_gen, "scanning all of code cache"); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
185 assert(code_roots != NULL, "must supply closure for code cache"); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
186 if (code_roots != NULL) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
187 CodeCache::blobs_do(code_roots); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
188 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
189 } else if (so & (SO_SystemClasses|SO_AllClasses)) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
190 if (!collecting_perm_gen) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
191 // If we are collecting from class statics, but we are not going to |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
192 // visit all of the CodeCache, collect from the non-perm roots if any. |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
193 // This makes the code cache function temporarily as a source of strong |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
194 // roots for oops, until the next major collection. |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
195 // |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
196 // If collecting_perm_gen is true, we require that this phase will call |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
197 // CodeCache::do_unloading. This will kill off nmethods with expired |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
198 // weak references, such as stale invokedynamic targets. |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
199 CodeCache::scavenge_root_nmethods_do(code_roots); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
200 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
201 } |
0 | 202 // Verify if the code cache contents are in the perm gen |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
203 NOT_PRODUCT(CodeBlobToOopClosure assert_code_is_perm(&assert_is_perm_closure, /*do_marking=*/ false)); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
204 NOT_PRODUCT(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_perm)); |
0 | 205 } |
206 | |
207 if (!collecting_perm_gen) { | |
208 // All threads perform this; coordination is handled internally. | |
209 | |
210 rem_set()->younger_refs_iterate(perm_gen(), perm_blk); | |
211 } | |
212 _process_strong_tasks->all_tasks_completed(); | |
213 } | |
214 | |
215 class AlwaysTrueClosure: public BoolObjectClosure { | |
216 public: | |
217 void do_object(oop p) { ShouldNotReachHere(); } | |
218 bool do_object_b(oop p) { return true; } | |
219 }; | |
220 static AlwaysTrueClosure always_true; | |
221 | |
222 class SkipAdjustingSharedStrings: public OopClosure { | |
223 OopClosure* _clo; | |
224 public: | |
225 SkipAdjustingSharedStrings(OopClosure* clo) : _clo(clo) {} | |
226 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
227 virtual void do_oop(oop* p) { |
0 | 228 oop o = (*p); |
229 if (!o->is_shared_readwrite()) { | |
230 _clo->do_oop(p); | |
231 } | |
232 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
233 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
0 | 234 }; |
235 | |
236 // Unmarked shared Strings in the StringTable (which got there due to | |
237 // being in the constant pools of as-yet unloaded shared classes) were | |
238 // not marked and therefore did not have their mark words preserved. | |
239 // These entries are also deliberately not purged from the string | |
240 // table during unloading of unmarked strings. If an identity hash | |
241 // code was computed for any of these objects, it will not have been | |
242 // cleared to zero during the forwarding process or by the | |
243 // RecursiveAdjustSharedObjectClosure, and will be confused by the | |
244 // adjusting process as a forwarding pointer. We need to skip | |
245 // forwarding StringTable entries which contain unmarked shared | |
246 // Strings. Actually, since shared strings won't be moving, we can | |
247 // just skip adjusting any shared entries in the string table. | |
248 | |
249 void SharedHeap::process_weak_roots(OopClosure* root_closure, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
250 CodeBlobClosure* code_roots, |
0 | 251 OopClosure* non_root_closure) { |
252 // Global (weak) JNI handles | |
253 JNIHandles::weak_oops_do(&always_true, root_closure); | |
254 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
255 CodeCache::blobs_do(code_roots); |
0 | 256 if (UseSharedSpaces && !DumpSharedSpaces) { |
257 SkipAdjustingSharedStrings skip_closure(root_closure); | |
258 StringTable::oops_do(&skip_closure); | |
259 } else { | |
260 StringTable::oops_do(root_closure); | |
261 } | |
262 } | |
263 | |
264 void SharedHeap::set_barrier_set(BarrierSet* bs) { | |
265 _barrier_set = bs; | |
266 // Cached barrier set for fast access in oops | |
267 oopDesc::set_bs(bs); | |
268 } | |
269 | |
270 void SharedHeap::post_initialize() { | |
271 ref_processing_init(); | |
272 } | |
273 | |
274 void SharedHeap::ref_processing_init() { | |
275 perm_gen()->ref_processor_init(); | |
276 } | |
277 | |
278 // Some utilities. | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
279 void SharedHeap::print_size_transition(outputStream* out, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
280 size_t bytes_before, |
0 | 281 size_t bytes_after, |
282 size_t capacity) { | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
283 out->print(" %d%s->%d%s(%d%s)", |
0 | 284 byte_size_in_proper_unit(bytes_before), |
285 proper_unit_for_byte_size(bytes_before), | |
286 byte_size_in_proper_unit(bytes_after), | |
287 proper_unit_for_byte_size(bytes_after), | |
288 byte_size_in_proper_unit(capacity), | |
289 proper_unit_for_byte_size(capacity)); | |
290 } |