Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/sharedHeap.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 | 3582bf76420e |
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_vmSymbols_oops_do, | |
50 SH_PS_SymbolTable_oops_do, | |
51 SH_PS_StringTable_oops_do, | |
52 SH_PS_CodeCache_oops_do, | |
53 // Leave this one last. | |
54 SH_PS_NumElements | |
55 }; | |
56 | |
57 SharedHeap::SharedHeap(CollectorPolicy* policy_) : | |
58 CollectedHeap(), | |
59 _collector_policy(policy_), | |
60 _perm_gen(NULL), _rem_set(NULL), | |
61 _strong_roots_parity(0), | |
62 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)), | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
63 _n_par_threads(0), |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
64 _workers(NULL) |
0 | 65 { |
66 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { | |
67 vm_exit_during_initialization("Failed necessary allocation."); | |
68 } | |
69 _sh = this; // ch is static, should be set only once. | |
70 if ((UseParNewGC || | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
71 (UseConcMarkSweepGC && CMSParallelRemarkEnabled) || |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
72 UseG1GC) && |
0 | 73 ParallelGCThreads > 0) { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
74 _workers = new FlexibleWorkGang("Parallel GC Threads", ParallelGCThreads, |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
75 /* are_GC_task_threads */true, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
76 /* are_ConcurrentGC_threads */false); |
0 | 77 if (_workers == NULL) { |
78 vm_exit_during_initialization("Failed necessary allocation."); | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
79 } else { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
80 _workers->initialize_workers(); |
0 | 81 } |
82 } | |
83 } | |
84 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
85 bool SharedHeap::heap_lock_held_for_gc() { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
86 Thread* t = Thread::current(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
87 return Heap_lock->owned_by_self() |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
88 || ( (t->is_GC_task_thread() || t->is_VM_thread()) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
89 && _thread_holds_heap_lock_for_gc); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
90 } |
0 | 91 |
92 void SharedHeap::set_par_threads(int t) { | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
93 assert(t == 0 || !UseSerialGC, "Cannot have parallel threads"); |
0 | 94 _n_par_threads = t; |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
95 _process_strong_tasks->set_n_threads(t); |
0 | 96 } |
97 | |
98 class AssertIsPermClosure: public OopClosure { | |
99 public: | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
100 virtual void do_oop(oop* p) { |
0 | 101 assert((*p) == NULL || (*p)->is_perm(), "Referent should be perm."); |
102 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
103 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
0 | 104 }; |
105 static AssertIsPermClosure assert_is_perm_closure; | |
106 | |
107 void SharedHeap::change_strong_roots_parity() { | |
108 // Also set the new collection parity. | |
109 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2, | |
110 "Not in range."); | |
111 _strong_roots_parity++; | |
112 if (_strong_roots_parity == 3) _strong_roots_parity = 1; | |
113 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2, | |
114 "Not in range."); | |
115 } | |
116 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
117 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate) |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
118 : MarkScope(activate) |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
119 { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
120 if (_active) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
121 outer->change_strong_roots_parity(); |
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 |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
125 SharedHeap::StrongRootsScope::~StrongRootsScope() { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
126 // nothing particular |
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 |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
129 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
|
130 bool collecting_perm_gen, |
0 | 131 ScanningOption so, |
132 OopClosure* roots, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
133 CodeBlobClosure* code_roots, |
0 | 134 OopsInGenClosure* perm_blk) { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
135 StrongRootsScope srs(this, activate_scope); |
0 | 136 // General strong roots. |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
137 assert(_strong_roots_parity != 0, "must have called prologue code"); |
0 | 138 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) { |
139 Universe::oops_do(roots); | |
140 ReferenceProcessor::oops_do(roots); | |
141 // Consider perm-gen discovered lists to be strong. | |
142 perm_gen()->ref_processor()->weak_oops_do(roots); | |
143 } | |
144 // Global (strong) JNI handles | |
145 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do)) | |
146 JNIHandles::oops_do(roots); | |
147 // All threads execute this; the individual threads are task groups. | |
148 if (ParallelGCThreads > 0) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
149 Threads::possibly_parallel_oops_do(roots, code_roots); |
0 | 150 } else { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
151 Threads::oops_do(roots, code_roots); |
0 | 152 } |
153 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do)) | |
154 ObjectSynchronizer::oops_do(roots); | |
155 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do)) | |
156 FlatProfiler::oops_do(roots); | |
157 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do)) | |
158 Management::oops_do(roots); | |
159 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do)) | |
160 JvmtiExport::oops_do(roots); | |
161 | |
162 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) { | |
163 if (so & SO_AllClasses) { | |
164 SystemDictionary::oops_do(roots); | |
165 } else | |
166 if (so & SO_SystemClasses) { | |
167 SystemDictionary::always_strong_oops_do(roots); | |
168 } | |
169 } | |
170 | |
171 if (!_process_strong_tasks->is_task_claimed(SH_PS_SymbolTable_oops_do)) { | |
172 if (so & SO_Symbols) { | |
173 SymbolTable::oops_do(roots); | |
174 } | |
175 // Verify if the symbol table contents are in the perm gen | |
176 NOT_PRODUCT(SymbolTable::oops_do(&assert_is_perm_closure)); | |
177 } | |
178 | |
179 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) { | |
180 if (so & SO_Strings) { | |
181 StringTable::oops_do(roots); | |
182 } | |
183 // Verify if the string table contents are in the perm gen | |
184 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure)); | |
185 } | |
186 | |
187 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
|
188 if (so & SO_CodeCache) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
189 // (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
|
190 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
|
191 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
|
192 if (code_roots != NULL) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
193 CodeCache::blobs_do(code_roots); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
194 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
195 } else if (so & (SO_SystemClasses|SO_AllClasses)) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
196 if (!collecting_perm_gen) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
197 // 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
|
198 // 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
|
199 // 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
|
200 // 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
|
201 // |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
202 // 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
|
203 // 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
|
204 // weak references, such as stale invokedynamic targets. |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
205 CodeCache::scavenge_root_nmethods_do(code_roots); |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
206 } |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
207 } |
0 | 208 // 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
|
209 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
|
210 NOT_PRODUCT(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_perm)); |
0 | 211 } |
212 | |
213 // Roots that should point only into permanent generation. | |
214 { | |
215 OopClosure* blk = NULL; | |
216 if (collecting_perm_gen) { | |
217 blk = roots; | |
218 } else { | |
219 debug_only(blk = &assert_is_perm_closure); | |
220 } | |
221 if (blk != NULL) { | |
222 if (!_process_strong_tasks->is_task_claimed(SH_PS_vmSymbols_oops_do)) | |
223 vmSymbols::oops_do(blk); | |
224 } | |
225 } | |
226 | |
227 if (!collecting_perm_gen) { | |
228 // All threads perform this; coordination is handled internally. | |
229 | |
230 rem_set()->younger_refs_iterate(perm_gen(), perm_blk); | |
231 } | |
232 _process_strong_tasks->all_tasks_completed(); | |
233 } | |
234 | |
235 class AlwaysTrueClosure: public BoolObjectClosure { | |
236 public: | |
237 void do_object(oop p) { ShouldNotReachHere(); } | |
238 bool do_object_b(oop p) { return true; } | |
239 }; | |
240 static AlwaysTrueClosure always_true; | |
241 | |
242 class SkipAdjustingSharedStrings: public OopClosure { | |
243 OopClosure* _clo; | |
244 public: | |
245 SkipAdjustingSharedStrings(OopClosure* clo) : _clo(clo) {} | |
246 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
247 virtual void do_oop(oop* p) { |
0 | 248 oop o = (*p); |
249 if (!o->is_shared_readwrite()) { | |
250 _clo->do_oop(p); | |
251 } | |
252 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
253 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
0 | 254 }; |
255 | |
256 // Unmarked shared Strings in the StringTable (which got there due to | |
257 // being in the constant pools of as-yet unloaded shared classes) were | |
258 // not marked and therefore did not have their mark words preserved. | |
259 // These entries are also deliberately not purged from the string | |
260 // table during unloading of unmarked strings. If an identity hash | |
261 // code was computed for any of these objects, it will not have been | |
262 // cleared to zero during the forwarding process or by the | |
263 // RecursiveAdjustSharedObjectClosure, and will be confused by the | |
264 // adjusting process as a forwarding pointer. We need to skip | |
265 // forwarding StringTable entries which contain unmarked shared | |
266 // Strings. Actually, since shared strings won't be moving, we can | |
267 // just skip adjusting any shared entries in the string table. | |
268 | |
269 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
|
270 CodeBlobClosure* code_roots, |
0 | 271 OopClosure* non_root_closure) { |
272 // Global (weak) JNI handles | |
273 JNIHandles::weak_oops_do(&always_true, root_closure); | |
274 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
275 CodeCache::blobs_do(code_roots); |
0 | 276 SymbolTable::oops_do(root_closure); |
277 if (UseSharedSpaces && !DumpSharedSpaces) { | |
278 SkipAdjustingSharedStrings skip_closure(root_closure); | |
279 StringTable::oops_do(&skip_closure); | |
280 } else { | |
281 StringTable::oops_do(root_closure); | |
282 } | |
283 } | |
284 | |
285 void SharedHeap::set_barrier_set(BarrierSet* bs) { | |
286 _barrier_set = bs; | |
287 // Cached barrier set for fast access in oops | |
288 oopDesc::set_bs(bs); | |
289 } | |
290 | |
291 void SharedHeap::post_initialize() { | |
292 ref_processing_init(); | |
293 } | |
294 | |
295 void SharedHeap::ref_processing_init() { | |
296 perm_gen()->ref_processor_init(); | |
297 } | |
298 | |
299 // Some utilities. | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
300 void SharedHeap::print_size_transition(outputStream* out, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
301 size_t bytes_before, |
0 | 302 size_t bytes_after, |
303 size_t capacity) { | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
304 out->print(" %d%s->%d%s(%d%s)", |
0 | 305 byte_size_in_proper_unit(bytes_before), |
306 proper_unit_for_byte_size(bytes_before), | |
307 byte_size_in_proper_unit(bytes_after), | |
308 proper_unit_for_byte_size(bytes_after), | |
309 byte_size_in_proper_unit(capacity), | |
310 proper_unit_for_byte_size(capacity)); | |
311 } |