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 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "code/codeCache.hpp"
31 #include "code/icBuffer.hpp"
32 #include "gc_implementation/g1/g1Log.hpp"
33 #include "gc_implementation/g1/g1MarkSweep.hpp"
34 #include "gc_implementation/g1/g1StringDedup.hpp"
35 #include "gc_implementation/shared/gcHeapSummary.hpp"
36 #include "gc_implementation/shared/gcTimer.hpp"
37 #include "gc_implementation/shared/gcTrace.hpp"
38 #include "gc_implementation/shared/gcTraceTime.hpp"
39 #include "memory/gcLocker.hpp"
40 #include "memory/genCollectedHeap.hpp"
41 #include "memory/modRefBarrierSet.hpp"
42 #include "memory/referencePolicy.hpp"
43 #include "memory/space.hpp"
44 #include "oops/instanceRefKlass.hpp"
45 #include "oops/oop.inline.hpp"
46 #include "prims/jvmtiExport.hpp"
47 #include "runtime/atomic.inline.hpp"
48 #include "runtime/biasedLocking.hpp"
49 #include "runtime/fprofiler.hpp"
50 #include "runtime/synchronizer.hpp"
51 #include "runtime/thread.hpp"
52 #include "runtime/vmThread.hpp"
53 #include "utilities/copy.hpp"
108 CodeCache::gc_epilogue();
109 JvmtiExport::gc_epilogue();
110
111 // refs processing: clean slate
112 GenMarkSweep::_ref_processor = NULL;
113 }
114
115
116 void G1MarkSweep::allocate_stacks() {
117 GenMarkSweep::_preserved_count_max = 0;
118 GenMarkSweep::_preserved_marks = NULL;
119 GenMarkSweep::_preserved_count = 0;
120 }
121
122 void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
123 bool clear_all_softrefs) {
124 // Recursively traverse all live objects and mark them
125 GCTraceTime tm("phase 1", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
126 GenMarkSweep::trace(" 1");
127
128 SharedHeap* sh = SharedHeap::heap();
129
130 // Need cleared claim bits for the roots processing
131 ClassLoaderDataGraph::clear_claimed_marks();
132
133 MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations);
134 sh->process_strong_roots(true, // activate StrongRootsScope
135 SharedHeap::SO_None,
136 &GenMarkSweep::follow_root_closure,
137 &GenMarkSweep::follow_cld_closure,
138 &follow_code_closure);
139
140 // Process reference objects found during marking
141 ReferenceProcessor* rp = GenMarkSweep::ref_processor();
142 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Sanity");
143
144 rp->setup_policy(clear_all_softrefs);
145 const ReferenceProcessorStats& stats =
146 rp->process_discovered_references(&GenMarkSweep::is_alive,
147 &GenMarkSweep::keep_alive,
148 &GenMarkSweep::follow_stack_closure,
149 NULL,
150 gc_timer(),
151 gc_tracer()->gc_id());
152 gc_tracer()->report_gc_reference_stats(stats);
153
154
155 // This is the point where the entire marking should have completed.
156 assert(GenMarkSweep::_marking_stack.is_empty(), "Marking should have completed");
157
158 // Unload classes and purge the SystemDictionary.
159 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive);
160
161 // Unload nmethods.
162 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class);
208 }
209
210 class G1AdjustPointersClosure: public HeapRegionClosure {
211 public:
212 bool doHeapRegion(HeapRegion* r) {
213 if (r->is_humongous()) {
214 if (r->is_starts_humongous()) {
215 // We must adjust the pointers on the single H object.
216 oop obj = oop(r->bottom());
217 // point all the oops to the new location
218 obj->adjust_pointers();
219 }
220 } else {
221 // This really ought to be "as_CompactibleSpace"...
222 r->adjust_pointers();
223 }
224 return false;
225 }
226 };
227
228 void G1MarkSweep::mark_sweep_phase3() {
229 G1CollectedHeap* g1h = G1CollectedHeap::heap();
230
231 // Adjust the pointers to reflect the new locations
232 GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
233 GenMarkSweep::trace("3");
234
235 SharedHeap* sh = SharedHeap::heap();
236
237 // Need cleared claim bits for the roots processing
238 ClassLoaderDataGraph::clear_claimed_marks();
239
240 CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations);
241 sh->process_all_roots(true, // activate StrongRootsScope
242 SharedHeap::SO_AllCodeCache,
243 &GenMarkSweep::adjust_pointer_closure,
244 &GenMarkSweep::adjust_cld_closure,
245 &adjust_code_closure);
246
247 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
248 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure);
249
250 // Now adjust pointers in remaining weak roots. (All of which should
251 // have been cleared if they pointed to non-surviving objects.)
252 sh->process_weak_roots(&GenMarkSweep::adjust_pointer_closure);
253
254 if (G1StringDedup::is_enabled()) {
255 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure);
256 }
257
258 GenMarkSweep::adjust_marks();
259
260 G1AdjustPointersClosure blk;
261 g1h->heap_region_iterate(&blk);
262 }
263
264 class G1SpaceCompactClosure: public HeapRegionClosure {
265 public:
266 G1SpaceCompactClosure() {}
267
268 bool doHeapRegion(HeapRegion* hr) {
269 if (hr->is_humongous()) {
270 if (hr->is_starts_humongous()) {
271 oop obj = oop(hr->bottom());
272 if (obj->is_gc_marked()) {
|
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 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "code/codeCache.hpp"
31 #include "code/icBuffer.hpp"
32 #include "gc_implementation/g1/g1Log.hpp"
33 #include "gc_implementation/g1/g1MarkSweep.hpp"
34 #include "gc_implementation/g1/g1RootProcessor.hpp"
35 #include "gc_implementation/g1/g1StringDedup.hpp"
36 #include "gc_implementation/shared/gcHeapSummary.hpp"
37 #include "gc_implementation/shared/gcTimer.hpp"
38 #include "gc_implementation/shared/gcTrace.hpp"
39 #include "gc_implementation/shared/gcTraceTime.hpp"
40 #include "memory/gcLocker.hpp"
41 #include "memory/genCollectedHeap.hpp"
42 #include "memory/modRefBarrierSet.hpp"
43 #include "memory/referencePolicy.hpp"
44 #include "memory/space.hpp"
45 #include "oops/instanceRefKlass.hpp"
46 #include "oops/oop.inline.hpp"
47 #include "prims/jvmtiExport.hpp"
48 #include "runtime/atomic.inline.hpp"
49 #include "runtime/biasedLocking.hpp"
50 #include "runtime/fprofiler.hpp"
51 #include "runtime/synchronizer.hpp"
52 #include "runtime/thread.hpp"
53 #include "runtime/vmThread.hpp"
54 #include "utilities/copy.hpp"
109 CodeCache::gc_epilogue();
110 JvmtiExport::gc_epilogue();
111
112 // refs processing: clean slate
113 GenMarkSweep::_ref_processor = NULL;
114 }
115
116
117 void G1MarkSweep::allocate_stacks() {
118 GenMarkSweep::_preserved_count_max = 0;
119 GenMarkSweep::_preserved_marks = NULL;
120 GenMarkSweep::_preserved_count = 0;
121 }
122
123 void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
124 bool clear_all_softrefs) {
125 // Recursively traverse all live objects and mark them
126 GCTraceTime tm("phase 1", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
127 GenMarkSweep::trace(" 1");
128
129 G1CollectedHeap* g1h = G1CollectedHeap::heap();
130
131 // Need cleared claim bits for the roots processing
132 ClassLoaderDataGraph::clear_claimed_marks();
133
134 MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations);
135 {
136 G1RootProcessor root_processor(g1h);
137 root_processor.process_strong_roots(&GenMarkSweep::follow_root_closure,
138 &GenMarkSweep::follow_cld_closure,
139 &follow_code_closure);
140 }
141
142 // Process reference objects found during marking
143 ReferenceProcessor* rp = GenMarkSweep::ref_processor();
144 assert(rp == g1h->ref_processor_stw(), "Sanity");
145
146 rp->setup_policy(clear_all_softrefs);
147 const ReferenceProcessorStats& stats =
148 rp->process_discovered_references(&GenMarkSweep::is_alive,
149 &GenMarkSweep::keep_alive,
150 &GenMarkSweep::follow_stack_closure,
151 NULL,
152 gc_timer(),
153 gc_tracer()->gc_id());
154 gc_tracer()->report_gc_reference_stats(stats);
155
156
157 // This is the point where the entire marking should have completed.
158 assert(GenMarkSweep::_marking_stack.is_empty(), "Marking should have completed");
159
160 // Unload classes and purge the SystemDictionary.
161 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive);
162
163 // Unload nmethods.
164 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class);
210 }
211
212 class G1AdjustPointersClosure: public HeapRegionClosure {
213 public:
214 bool doHeapRegion(HeapRegion* r) {
215 if (r->is_humongous()) {
216 if (r->is_starts_humongous()) {
217 // We must adjust the pointers on the single H object.
218 oop obj = oop(r->bottom());
219 // point all the oops to the new location
220 obj->adjust_pointers();
221 }
222 } else {
223 // This really ought to be "as_CompactibleSpace"...
224 r->adjust_pointers();
225 }
226 return false;
227 }
228 };
229
230 class G1AlwaysTrueClosure: public BoolObjectClosure {
231 public:
232 bool do_object_b(oop p) { return true; }
233 };
234 static G1AlwaysTrueClosure always_true;
235
236 void G1MarkSweep::mark_sweep_phase3() {
237 G1CollectedHeap* g1h = G1CollectedHeap::heap();
238
239 // Adjust the pointers to reflect the new locations
240 GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
241 GenMarkSweep::trace("3");
242
243 // Need cleared claim bits for the roots processing
244 ClassLoaderDataGraph::clear_claimed_marks();
245
246 CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations);
247 {
248 G1RootProcessor root_processor(g1h);
249 root_processor.process_all_roots(&GenMarkSweep::adjust_pointer_closure,
250 &GenMarkSweep::adjust_cld_closure,
251 &adjust_code_closure);
252 }
253
254 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
255 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure);
256
257 // Now adjust pointers in remaining weak roots. (All of which should
258 // have been cleared if they pointed to non-surviving objects.)
259 JNIHandles::weak_oops_do(&always_true, &GenMarkSweep::adjust_pointer_closure);
260
261 if (G1StringDedup::is_enabled()) {
262 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure);
263 }
264
265 GenMarkSweep::adjust_marks();
266
267 G1AdjustPointersClosure blk;
268 g1h->heap_region_iterate(&blk);
269 }
270
271 class G1SpaceCompactClosure: public HeapRegionClosure {
272 public:
273 G1SpaceCompactClosure() {}
274
275 bool doHeapRegion(HeapRegion* hr) {
276 if (hr->is_humongous()) {
277 if (hr->is_starts_humongous()) {
278 oop obj = oop(hr->bottom());
279 if (obj->is_gc_marked()) {
|