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
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
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: 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
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: 1833
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
26 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
28 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
29 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
30 #include "memory/sharedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
31 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
32 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
33 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
34 #include "services/management.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
35 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
36 #include "utilities/workgroup.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
37
a61af66fc99e Initial load
duke
parents:
diff changeset
38 SharedHeap* SharedHeap::_sh;
a61af66fc99e Initial load
duke
parents:
diff changeset
39
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // The set of potentially parallel tasks in strong root scanning.
a61af66fc99e Initial load
duke
parents:
diff changeset
41 enum SH_process_strong_roots_tasks {
a61af66fc99e Initial load
duke
parents:
diff changeset
42 SH_PS_Universe_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
43 SH_PS_JNIHandles_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
44 SH_PS_ObjectSynchronizer_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
45 SH_PS_FlatProfiler_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
46 SH_PS_Management_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
47 SH_PS_SystemDictionary_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
48 SH_PS_jvmti_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
49 SH_PS_vmSymbols_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
50 SH_PS_SymbolTable_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
51 SH_PS_StringTable_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
52 SH_PS_CodeCache_oops_do,
a61af66fc99e Initial load
duke
parents:
diff changeset
53 // Leave this one last.
a61af66fc99e Initial load
duke
parents:
diff changeset
54 SH_PS_NumElements
a61af66fc99e Initial load
duke
parents:
diff changeset
55 };
a61af66fc99e Initial load
duke
parents:
diff changeset
56
a61af66fc99e Initial load
duke
parents:
diff changeset
57 SharedHeap::SharedHeap(CollectorPolicy* policy_) :
a61af66fc99e Initial load
duke
parents:
diff changeset
58 CollectedHeap(),
a61af66fc99e Initial load
duke
parents:
diff changeset
59 _collector_policy(policy_),
a61af66fc99e Initial load
duke
parents:
diff changeset
60 _perm_gen(NULL), _rem_set(NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
61 _strong_roots_parity(0),
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
65 {
a61af66fc99e Initial load
duke
parents:
diff changeset
66 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
67 vm_exit_during_initialization("Failed necessary allocation.");
a61af66fc99e Initial load
duke
parents:
diff changeset
68 }
a61af66fc99e Initial load
duke
parents:
diff changeset
69 _sh = this; // ch is static, should be set only once.
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
77 if (_workers == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
81 }
a61af66fc99e Initial load
duke
parents:
diff changeset
82 }
a61af66fc99e Initial load
duke
parents:
diff changeset
83 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
91
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
96 }
a61af66fc99e Initial load
duke
parents:
diff changeset
97
a61af66fc99e Initial load
duke
parents:
diff changeset
98 class AssertIsPermClosure: public OopClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
101 assert((*p) == NULL || (*p)->is_perm(), "Referent should be perm.");
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
104 };
a61af66fc99e Initial load
duke
parents:
diff changeset
105 static AssertIsPermClosure assert_is_perm_closure;
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 void SharedHeap::change_strong_roots_parity() {
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // Also set the new collection parity.
a61af66fc99e Initial load
duke
parents:
diff changeset
109 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
a61af66fc99e Initial load
duke
parents:
diff changeset
110 "Not in range.");
a61af66fc99e Initial load
duke
parents:
diff changeset
111 _strong_roots_parity++;
a61af66fc99e Initial load
duke
parents:
diff changeset
112 if (_strong_roots_parity == 3) _strong_roots_parity = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
113 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,
a61af66fc99e Initial load
duke
parents:
diff changeset
114 "Not in range.");
a61af66fc99e Initial load
duke
parents:
diff changeset
115 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
131 ScanningOption so,
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
138 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
139 Universe::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
140 ReferenceProcessor::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // Consider perm-gen discovered lists to be strong.
a61af66fc99e Initial load
duke
parents:
diff changeset
142 perm_gen()->ref_processor()->weak_oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // Global (strong) JNI handles
a61af66fc99e Initial load
duke
parents:
diff changeset
145 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
146 JNIHandles::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // All threads execute this; the individual threads are task groups.
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
152 }
a61af66fc99e Initial load
duke
parents:
diff changeset
153 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
154 ObjectSynchronizer::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
155 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
156 FlatProfiler::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
157 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
158 Management::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
159 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
160 JvmtiExport::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
163 if (so & SO_AllClasses) {
a61af66fc99e Initial load
duke
parents:
diff changeset
164 SystemDictionary::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
165 } else
a61af66fc99e Initial load
duke
parents:
diff changeset
166 if (so & SO_SystemClasses) {
a61af66fc99e Initial load
duke
parents:
diff changeset
167 SystemDictionary::always_strong_oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
168 }
a61af66fc99e Initial load
duke
parents:
diff changeset
169 }
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 if (!_process_strong_tasks->is_task_claimed(SH_PS_SymbolTable_oops_do)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
172 if (so & SO_Symbols) {
a61af66fc99e Initial load
duke
parents:
diff changeset
173 SymbolTable::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
174 }
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // Verify if the symbol table contents are in the perm gen
a61af66fc99e Initial load
duke
parents:
diff changeset
176 NOT_PRODUCT(SymbolTable::oops_do(&assert_is_perm_closure));
a61af66fc99e Initial load
duke
parents:
diff changeset
177 }
a61af66fc99e Initial load
duke
parents:
diff changeset
178
a61af66fc99e Initial load
duke
parents:
diff changeset
179 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
180 if (so & SO_Strings) {
a61af66fc99e Initial load
duke
parents:
diff changeset
181 StringTable::oops_do(roots);
a61af66fc99e Initial load
duke
parents:
diff changeset
182 }
a61af66fc99e Initial load
duke
parents:
diff changeset
183 // Verify if the string table contents are in the perm gen
a61af66fc99e Initial load
duke
parents:
diff changeset
184 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
a61af66fc99e Initial load
duke
parents:
diff changeset
185 }
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
211 }
a61af66fc99e Initial load
duke
parents:
diff changeset
212
a61af66fc99e Initial load
duke
parents:
diff changeset
213 // Roots that should point only into permanent generation.
a61af66fc99e Initial load
duke
parents:
diff changeset
214 {
a61af66fc99e Initial load
duke
parents:
diff changeset
215 OopClosure* blk = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
216 if (collecting_perm_gen) {
a61af66fc99e Initial load
duke
parents:
diff changeset
217 blk = roots;
a61af66fc99e Initial load
duke
parents:
diff changeset
218 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
219 debug_only(blk = &assert_is_perm_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
220 }
a61af66fc99e Initial load
duke
parents:
diff changeset
221 if (blk != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
222 if (!_process_strong_tasks->is_task_claimed(SH_PS_vmSymbols_oops_do))
a61af66fc99e Initial load
duke
parents:
diff changeset
223 vmSymbols::oops_do(blk);
a61af66fc99e Initial load
duke
parents:
diff changeset
224 }
a61af66fc99e Initial load
duke
parents:
diff changeset
225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
226
a61af66fc99e Initial load
duke
parents:
diff changeset
227 if (!collecting_perm_gen) {
a61af66fc99e Initial load
duke
parents:
diff changeset
228 // All threads perform this; coordination is handled internally.
a61af66fc99e Initial load
duke
parents:
diff changeset
229
a61af66fc99e Initial load
duke
parents:
diff changeset
230 rem_set()->younger_refs_iterate(perm_gen(), perm_blk);
a61af66fc99e Initial load
duke
parents:
diff changeset
231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
232 _process_strong_tasks->all_tasks_completed();
a61af66fc99e Initial load
duke
parents:
diff changeset
233 }
a61af66fc99e Initial load
duke
parents:
diff changeset
234
a61af66fc99e Initial load
duke
parents:
diff changeset
235 class AlwaysTrueClosure: public BoolObjectClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
236 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
237 void do_object(oop p) { ShouldNotReachHere(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
238 bool do_object_b(oop p) { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
239 };
a61af66fc99e Initial load
duke
parents:
diff changeset
240 static AlwaysTrueClosure always_true;
a61af66fc99e Initial load
duke
parents:
diff changeset
241
a61af66fc99e Initial load
duke
parents:
diff changeset
242 class SkipAdjustingSharedStrings: public OopClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
243 OopClosure* _clo;
a61af66fc99e Initial load
duke
parents:
diff changeset
244 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
245 SkipAdjustingSharedStrings(OopClosure* clo) : _clo(clo) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
248 oop o = (*p);
a61af66fc99e Initial load
duke
parents:
diff changeset
249 if (!o->is_shared_readwrite()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
250 _clo->do_oop(p);
a61af66fc99e Initial load
duke
parents:
diff changeset
251 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
254 };
a61af66fc99e Initial load
duke
parents:
diff changeset
255
a61af66fc99e Initial load
duke
parents:
diff changeset
256 // Unmarked shared Strings in the StringTable (which got there due to
a61af66fc99e Initial load
duke
parents:
diff changeset
257 // being in the constant pools of as-yet unloaded shared classes) were
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // not marked and therefore did not have their mark words preserved.
a61af66fc99e Initial load
duke
parents:
diff changeset
259 // These entries are also deliberately not purged from the string
a61af66fc99e Initial load
duke
parents:
diff changeset
260 // table during unloading of unmarked strings. If an identity hash
a61af66fc99e Initial load
duke
parents:
diff changeset
261 // code was computed for any of these objects, it will not have been
a61af66fc99e Initial load
duke
parents:
diff changeset
262 // cleared to zero during the forwarding process or by the
a61af66fc99e Initial load
duke
parents:
diff changeset
263 // RecursiveAdjustSharedObjectClosure, and will be confused by the
a61af66fc99e Initial load
duke
parents:
diff changeset
264 // adjusting process as a forwarding pointer. We need to skip
a61af66fc99e Initial load
duke
parents:
diff changeset
265 // forwarding StringTable entries which contain unmarked shared
a61af66fc99e Initial load
duke
parents:
diff changeset
266 // Strings. Actually, since shared strings won't be moving, we can
a61af66fc99e Initial load
duke
parents:
diff changeset
267 // just skip adjusting any shared entries in the string table.
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
271 OopClosure* non_root_closure) {
a61af66fc99e Initial load
duke
parents:
diff changeset
272 // Global (weak) JNI handles
a61af66fc99e Initial load
duke
parents:
diff changeset
273 JNIHandles::weak_oops_do(&always_true, root_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
276 SymbolTable::oops_do(root_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
277 if (UseSharedSpaces && !DumpSharedSpaces) {
a61af66fc99e Initial load
duke
parents:
diff changeset
278 SkipAdjustingSharedStrings skip_closure(root_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
279 StringTable::oops_do(&skip_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
280 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
281 StringTable::oops_do(root_closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
282 }
a61af66fc99e Initial load
duke
parents:
diff changeset
283 }
a61af66fc99e Initial load
duke
parents:
diff changeset
284
a61af66fc99e Initial load
duke
parents:
diff changeset
285 void SharedHeap::set_barrier_set(BarrierSet* bs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
286 _barrier_set = bs;
a61af66fc99e Initial load
duke
parents:
diff changeset
287 // Cached barrier set for fast access in oops
a61af66fc99e Initial load
duke
parents:
diff changeset
288 oopDesc::set_bs(bs);
a61af66fc99e Initial load
duke
parents:
diff changeset
289 }
a61af66fc99e Initial load
duke
parents:
diff changeset
290
a61af66fc99e Initial load
duke
parents:
diff changeset
291 void SharedHeap::post_initialize() {
a61af66fc99e Initial load
duke
parents:
diff changeset
292 ref_processing_init();
a61af66fc99e Initial load
duke
parents:
diff changeset
293 }
a61af66fc99e Initial load
duke
parents:
diff changeset
294
a61af66fc99e Initial load
duke
parents:
diff changeset
295 void SharedHeap::ref_processing_init() {
a61af66fc99e Initial load
duke
parents:
diff changeset
296 perm_gen()->ref_processor_init();
a61af66fc99e Initial load
duke
parents:
diff changeset
297 }
a61af66fc99e Initial load
duke
parents:
diff changeset
298
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
302 size_t bytes_after,
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
305 byte_size_in_proper_unit(bytes_before),
a61af66fc99e Initial load
duke
parents:
diff changeset
306 proper_unit_for_byte_size(bytes_before),
a61af66fc99e Initial load
duke
parents:
diff changeset
307 byte_size_in_proper_unit(bytes_after),
a61af66fc99e Initial load
duke
parents:
diff changeset
308 proper_unit_for_byte_size(bytes_after),
a61af66fc99e Initial load
duke
parents:
diff changeset
309 byte_size_in_proper_unit(capacity),
a61af66fc99e Initial load
duke
parents:
diff changeset
310 proper_unit_for_byte_size(capacity));
a61af66fc99e Initial load
duke
parents:
diff changeset
311 }