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"
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 _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 ||
156 // All threads execute this; the individual threads are task groups.
157 CLDToOopClosure roots_from_clds(roots);
158 CLDToOopClosure* roots_from_clds_p = (is_scavenging ? NULL : &roots_from_clds);
159 if (ParallelGCThreads > 0) {
160 Threads::possibly_parallel_oops_do(roots, roots_from_clds_p ,code_roots);
161 } else {
162 Threads::oops_do(roots, roots_from_clds_p, code_roots);
163 }
164 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
165 ObjectSynchronizer::oops_do(roots);
166 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
167 FlatProfiler::oops_do(roots);
168 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
169 Management::oops_do(roots);
170 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
171 JvmtiExport::oops_do(roots);
172
173 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
174 if (so & SO_AllClasses) {
175 SystemDictionary::oops_do(roots);
176 ClassLoaderDataGraph::oops_do(roots, klass_closure, !is_scavenging);
177 } else if (so & SO_SystemClasses) {
178 SystemDictionary::always_strong_oops_do(roots);
179 ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, !is_scavenging);
180 } else {
181 fatal("We should always have selected either SO_AllClasses or SO_SystemClasses");
182 }
183 }
184
185 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
186 if (so & SO_Strings) {
187 StringTable::oops_do(roots);
188 }
189 }
190
191 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
192 if (so & SO_CodeCache) {
193 assert(code_roots != NULL, "must supply closure for code cache");
194
195 if (is_scavenging) {
196 // We only visit parts of the CodeCache when scavenging.
197 CodeCache::scavenge_root_nmethods_do(code_roots);
198 } else {
199 // CMSCollector uses this to do intermediate-strength collections.
200 // We scan the entire code cache, since CodeCache::do_unloading is not called.
201 CodeCache::blobs_do(code_roots);
|
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"
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_ClassLoaderDataGraph_oops_do,
49 SH_PS_jvmti_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 _rem_set(NULL),
60 _strong_roots_parity(0),
61 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)),
62 _workers(NULL)
63 {
64 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) {
65 vm_exit_during_initialization("Failed necessary allocation.");
66 }
67 _sh = this; // ch is static, should be set only once.
68 if ((UseParNewGC ||
157 // All threads execute this; the individual threads are task groups.
158 CLDToOopClosure roots_from_clds(roots);
159 CLDToOopClosure* roots_from_clds_p = (is_scavenging ? NULL : &roots_from_clds);
160 if (ParallelGCThreads > 0) {
161 Threads::possibly_parallel_oops_do(roots, roots_from_clds_p ,code_roots);
162 } else {
163 Threads::oops_do(roots, roots_from_clds_p, code_roots);
164 }
165 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
166 ObjectSynchronizer::oops_do(roots);
167 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
168 FlatProfiler::oops_do(roots);
169 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
170 Management::oops_do(roots);
171 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
172 JvmtiExport::oops_do(roots);
173
174 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
175 if (so & SO_AllClasses) {
176 SystemDictionary::oops_do(roots);
177 } else if (so & SO_SystemClasses) {
178 SystemDictionary::always_strong_oops_do(roots);
179 } else {
180 fatal("We should always have selected either SO_AllClasses or SO_SystemClasses");
181 }
182 }
183
184 if (!_process_strong_tasks->is_task_claimed(SH_PS_ClassLoaderDataGraph_oops_do)) {
185 if (so & SO_AllClasses) {
186 ClassLoaderDataGraph::oops_do(roots, klass_closure, !is_scavenging);
187 } else if (so & SO_SystemClasses) {
188 ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, !is_scavenging);
189 }
190 }
191
192 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
193 if (so & SO_Strings) {
194 StringTable::oops_do(roots);
195 }
196 }
197
198 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
199 if (so & SO_CodeCache) {
200 assert(code_roots != NULL, "must supply closure for code cache");
201
202 if (is_scavenging) {
203 // We only visit parts of the CodeCache when scavenging.
204 CodeCache::scavenge_root_nmethods_do(code_roots);
205 } else {
206 // CMSCollector uses this to do intermediate-strength collections.
207 // We scan the entire code cache, since CodeCache::do_unloading is not called.
208 CodeCache::blobs_do(code_roots);
|