1 /*
2 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
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"
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_StringTable_oops_do,
50 SH_PS_CodeCache_oops_do,
51 // Leave this one last.
52 SH_PS_NumElements
53 };
54
55 SharedHeap::SharedHeap(CollectorPolicy* policy_) :
56 CollectedHeap(),
57 _collector_policy(policy_),
58 _perm_gen(NULL), _rem_set(NULL),
59 _strong_roots_parity(0),
60 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)),
61 _workers(NULL)
62 {
63 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) {
64 vm_exit_during_initialization("Failed necessary allocation.");
65 }
66 _sh = this; // ch is static, should be set only once.
67 if ((UseParNewGC ||
68 (UseConcMarkSweepGC && CMSParallelRemarkEnabled) ||
69 UseG1GC) &&
118 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
119 };
120 static AssertNonScavengableClosure assert_is_non_scavengable_closure;
121 #endif
122
123 void SharedHeap::change_strong_roots_parity() {
124 // Also set the new collection parity.
125 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
126 "Not in range.");
127 _strong_roots_parity++;
128 if (_strong_roots_parity == 3) _strong_roots_parity = 1;
129 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,
130 "Not in range.");
131 }
132
133 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate)
134 : MarkScope(activate)
135 {
136 if (_active) {
137 outer->change_strong_roots_parity();
138 }
139 }
140
141 SharedHeap::StrongRootsScope::~StrongRootsScope() {
142 // nothing particular
143 }
144
145 void SharedHeap::process_strong_roots(bool activate_scope,
146 bool collecting_perm_gen,
147 ScanningOption so,
148 OopClosure* roots,
149 CodeBlobClosure* code_roots,
150 OopsInGenClosure* perm_blk) {
151 StrongRootsScope srs(this, activate_scope);
152 // General strong roots.
153 assert(_strong_roots_parity != 0, "must have called prologue code");
154 // _n_termination for _process_strong_tasks should be set up stream
155 // in a method not running in a GC worker. Otherwise the GC worker
156 // could be trying to change the termination condition while the task
157 // is executing in another GC worker.
158 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
159 Universe::oops_do(roots);
160 // Consider perm-gen discovered lists to be strong.
161 perm_gen()->ref_processor()->weak_oops_do(roots);
162 }
163 // Global (strong) JNI handles
164 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
165 JNIHandles::oops_do(roots);
166 // All threads execute this; the individual threads are task groups.
167 if (ParallelGCThreads > 0) {
168 Threads::possibly_parallel_oops_do(roots, code_roots);
169 } else {
170 Threads::oops_do(roots, code_roots);
171 }
172 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
173 ObjectSynchronizer::oops_do(roots);
174 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
175 FlatProfiler::oops_do(roots);
176 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
177 Management::oops_do(roots);
178 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
179 JvmtiExport::oops_do(roots);
180
181 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
182 if (so & SO_AllClasses) {
183 SystemDictionary::oops_do(roots);
184 } else if (so & SO_SystemClasses) {
185 SystemDictionary::always_strong_oops_do(roots);
186 }
187 }
188
189 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
190 if (so & SO_Strings || (!collecting_perm_gen && !JavaObjectsInPerm)) {
191 StringTable::oops_do(roots);
192 }
193 if (JavaObjectsInPerm) {
194 // Verify the string table contents are in the perm gen
195 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
196 }
197 }
198
199 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
200 if (so & SO_CodeCache) {
201 // (Currently, CMSCollector uses this to do intermediate-strength collections.)
202 assert(collecting_perm_gen, "scanning all of code cache");
203 assert(code_roots != NULL, "must supply closure for code cache");
204 if (code_roots != NULL) {
205 CodeCache::blobs_do(code_roots);
206 }
207 } else if (so & (SO_SystemClasses|SO_AllClasses)) {
208 if (!collecting_perm_gen) {
209 // If we are collecting from class statics, but we are not going to
210 // visit all of the CodeCache, collect from the non-perm roots if any.
211 // This makes the code cache function temporarily as a source of strong
212 // roots for oops, until the next major collection.
213 //
214 // If collecting_perm_gen is true, we require that this phase will call
|
1 /*
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
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"
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_CodeCache_oops_do,
50 // Leave this one last.
51 SH_PS_NumElements
52 };
53
54 SharedHeap::SharedHeap(CollectorPolicy* policy_) :
55 CollectedHeap(),
56 _collector_policy(policy_),
57 _perm_gen(NULL), _rem_set(NULL),
58 _strong_roots_parity(0),
59 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)),
60 _workers(NULL)
61 {
62 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) {
63 vm_exit_during_initialization("Failed necessary allocation.");
64 }
65 _sh = this; // ch is static, should be set only once.
66 if ((UseParNewGC ||
67 (UseConcMarkSweepGC && CMSParallelRemarkEnabled) ||
68 UseG1GC) &&
117 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
118 };
119 static AssertNonScavengableClosure assert_is_non_scavengable_closure;
120 #endif
121
122 void SharedHeap::change_strong_roots_parity() {
123 // Also set the new collection parity.
124 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
125 "Not in range.");
126 _strong_roots_parity++;
127 if (_strong_roots_parity == 3) _strong_roots_parity = 1;
128 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,
129 "Not in range.");
130 }
131
132 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate)
133 : MarkScope(activate)
134 {
135 if (_active) {
136 outer->change_strong_roots_parity();
137 // Zero the claimed high water mark in the StringTable
138 StringTable::clear_parallel_claimed_index();
139 }
140 }
141
142 SharedHeap::StrongRootsScope::~StrongRootsScope() {
143 // nothing particular
144 }
145
146 void SharedHeap::process_strong_roots(bool activate_scope,
147 bool collecting_perm_gen,
148 ScanningOption so,
149 OopClosure* roots,
150 CodeBlobClosure* code_roots,
151 OopsInGenClosure* perm_blk) {
152 StrongRootsScope srs(this, activate_scope);
153 // General strong roots.
154 assert(_strong_roots_parity != 0, "must have called prologue code");
155 // _n_termination for _process_strong_tasks should be set up stream
156 // in a method not running in a GC worker. Otherwise the GC worker
157 // could be trying to change the termination condition while the task
158 // is executing in another GC worker.
159 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
160 Universe::oops_do(roots);
161 // Consider perm-gen discovered lists to be strong.
162 perm_gen()->ref_processor()->weak_oops_do(roots);
163 }
164 // Global (strong) JNI handles
165 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
166 JNIHandles::oops_do(roots);
167
168 // All threads execute this; the individual threads are task groups.
169 if (CollectedHeap::use_parallel_gc_threads()) {
170 Threads::possibly_parallel_oops_do(roots, code_roots);
171 } else {
172 Threads::oops_do(roots, code_roots);
173 }
174
175 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
176 ObjectSynchronizer::oops_do(roots);
177 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
178 FlatProfiler::oops_do(roots);
179 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
180 Management::oops_do(roots);
181 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
182 JvmtiExport::oops_do(roots);
183
184 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
185 if (so & SO_AllClasses) {
186 SystemDictionary::oops_do(roots);
187 } else if (so & SO_SystemClasses) {
188 SystemDictionary::always_strong_oops_do(roots);
189 }
190 }
191
192 // All threads execute the following. A specific chunk of buckets
193 // from the StringTable are the individual tasks.
194 if (so & SO_Strings || (!collecting_perm_gen && !JavaObjectsInPerm)) {
195 if (CollectedHeap::use_parallel_gc_threads()) {
196 StringTable::possibly_parallel_oops_do(roots);
197 } else {
198 StringTable::oops_do(roots);
199 }
200 }
201 if (JavaObjectsInPerm) {
202 // Verify the string table contents are in the perm gen
203 if (CollectedHeap::use_parallel_gc_threads()) {
204 NOT_PRODUCT(StringTable::possibly_parallel_oops_do(&assert_is_perm_closure));
205 } else {
206 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
207 }
208 }
209
210 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
211 if (so & SO_CodeCache) {
212 // (Currently, CMSCollector uses this to do intermediate-strength collections.)
213 assert(collecting_perm_gen, "scanning all of code cache");
214 assert(code_roots != NULL, "must supply closure for code cache");
215 if (code_roots != NULL) {
216 CodeCache::blobs_do(code_roots);
217 }
218 } else if (so & (SO_SystemClasses|SO_AllClasses)) {
219 if (!collecting_perm_gen) {
220 // If we are collecting from class statics, but we are not going to
221 // visit all of the CodeCache, collect from the non-perm roots if any.
222 // This makes the code cache function temporarily as a source of strong
223 // roots for oops, until the next major collection.
224 //
225 // If collecting_perm_gen is true, we require that this phase will call
|