52 #include "runtime/thread.hpp" 53 #include "runtime/vmThread.hpp" 54 #include "utilities/copy.hpp" 55 #include "utilities/events.hpp" 56 57 class HeapRegion; 58 59 bool G1MarkSweep::_archive_check_enabled = false; 60 G1ArchiveRegionMap G1MarkSweep::_archive_region_map; 61 62 void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, 63 bool clear_all_softrefs) { 64 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); 65 66 #ifdef ASSERT 67 if (G1CollectedHeap::heap()->collector_policy()->should_clear_all_soft_refs()) { 68 assert(clear_all_softrefs, "Policy should have been checked earler"); 69 } 70 #endif 71 // hook up weak ref data so it can be used during Mark-Sweep 72 assert(GenMarkSweep::ref_processor() == NULL, "no stomping"); 73 assert(rp != NULL, "should be non-NULL"); 74 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition"); 75 76 GenMarkSweep::set_ref_processor(rp); 77 rp->setup_policy(clear_all_softrefs); 78 79 // When collecting the permanent generation Method*s may be moving, 80 // so we either have to flush all bcp data or convert it into bci. 81 CodeCache::gc_prologue(); 82 83 bool marked_for_unloading = false; 84 85 allocate_stacks(); 86 87 // We should save the marks of the currently locked biased monitors. 88 // The marking doesn't preserve the marks of biased objects. 89 BiasedLocking::preserve_marks(); 90 91 mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); 92 93 mark_sweep_phase2(); 94 95 #if defined(COMPILER2) || INCLUDE_JVMCI 96 // Don't add any more derived pointers during phase3 97 DerivedPointerTable::set_active(false); 98 #endif 99 100 mark_sweep_phase3(); 101 102 mark_sweep_phase4(); 103 104 GenMarkSweep::restore_marks(); 105 BiasedLocking::restore_marks(); 106 GenMarkSweep::deallocate_stacks(); 107 108 CodeCache::gc_epilogue(); 109 JvmtiExport::gc_epilogue(); 110 111 // refs processing: clean slate 112 GenMarkSweep::set_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(Info, gc, phases) tm("Phase 1: Mark live objects", gc_timer()); 126 127 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 128 129 // Need cleared claim bits for the roots processing 130 ClassLoaderDataGraph::clear_claimed_marks(); 131 132 MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations); 133 { 134 G1RootProcessor root_processor(g1h, 1); 135 if (ClassUnloading) { 136 root_processor.process_strong_roots(&GenMarkSweep::follow_root_closure, 137 &GenMarkSweep::follow_cld_closure, 138 &follow_code_closure); 139 } else { 140 root_processor.process_all_roots_no_string_table( 141 &GenMarkSweep::follow_root_closure, 142 &GenMarkSweep::follow_cld_closure, 143 &follow_code_closure); 144 } 145 } 146 147 { 148 GCTraceTime(Debug, gc, phases) trace("Reference Processing", gc_timer()); 149 150 // Process reference objects found during marking 151 ReferenceProcessor* rp = GenMarkSweep::ref_processor(); 152 assert(rp == g1h->ref_processor_stw(), "Sanity"); 153 154 rp->setup_policy(clear_all_softrefs); 155 const ReferenceProcessorStats& stats = 156 rp->process_discovered_references(&GenMarkSweep::is_alive, 157 &GenMarkSweep::keep_alive, 158 &GenMarkSweep::follow_stack_closure, 159 NULL, 160 gc_timer()); 161 gc_tracer()->report_gc_reference_stats(stats); 162 } 163 164 // This is the point where the entire marking should have completed. 165 assert(GenMarkSweep::_marking_stack.is_empty(), "Marking should have completed"); 166 167 if (ClassUnloading) { 168 GCTraceTime(Debug, gc, phases) trace("Class Unloading", gc_timer()); 169 170 // Unload classes and purge the SystemDictionary. 171 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive); 172 173 // Unload nmethods. 174 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class); 175 176 // Prune dead klasses from subklass/sibling/implementor lists. 177 Klass::clean_weak_klass_links(&GenMarkSweep::is_alive); 178 } 179 180 { 181 GCTraceTime(Debug, gc, phases) trace("Scrub String and Symbol Tables", gc_timer()); 182 // Delete entries for dead interned string and clean up unreferenced symbols in symbol table. 183 g1h->unlink_string_and_symbol_table(&GenMarkSweep::is_alive); 184 } 185 186 if (G1StringDedup::is_enabled()) { 187 GCTraceTime(Debug, gc, phases) trace("String Deduplication Unlink", gc_timer()); 188 G1StringDedup::unlink(&GenMarkSweep::is_alive); 189 } 190 191 if (VerifyDuringGC) { 192 HandleMark hm; // handle scope 193 #if defined(COMPILER2) || INCLUDE_JVMCI 194 DerivedPointerTableDeactivate dpt_deact; 195 #endif 196 g1h->prepare_for_verify(); 197 // Note: we can verify only the heap here. When an object is 198 // marked, the previous value of the mark word (including 199 // identity hash values, ages, etc) is preserved, and the mark 200 // word is set to markOop::marked_value - effectively removing 201 // any hash values from the mark word. These hash values are 202 // used when verifying the dictionaries and so removing them 203 // from the mark word can make verification of the dictionaries 204 // fail. At the end of the GC, the original mark word values 205 // (including hash values) are restored to the appropriate 206 // objects. 207 GCTraceTime(Info, gc, verify)("During GC (full)"); 208 g1h->verify(VerifyOption_G1UseMarkWord); 209 } 210 211 gc_tracer()->report_object_count_after_gc(&GenMarkSweep::is_alive); 212 } 213 214 215 void G1MarkSweep::mark_sweep_phase2() { 216 // Now all live objects are marked, compute the new object addresses. 217 218 // It is not required that we traverse spaces in the same order in 219 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops 220 // tracking expects us to do so. See comment under phase4. 221 222 GCTraceTime(Info, gc, phases) tm("Phase 2: Compute new object addresses", gc_timer()); 223 224 prepare_compaction(); 225 } 226 227 class G1AdjustPointersClosure: public HeapRegionClosure { 228 public: 229 bool doHeapRegion(HeapRegion* r) { 230 if (r->is_humongous()) { 231 if (r->is_starts_humongous()) { 232 // We must adjust the pointers on the single H object. 233 oop obj = oop(r->bottom()); 234 // point all the oops to the new location 235 MarkSweep::adjust_pointers(obj); 236 } 237 } else if (!r->is_pinned()) { 238 // This really ought to be "as_CompactibleSpace"... 239 r->adjust_pointers(); 240 } 241 return false; 242 } 243 }; 244 245 void G1MarkSweep::mark_sweep_phase3() { 246 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 247 248 // Adjust the pointers to reflect the new locations 249 GCTraceTime(Info, gc, phases) tm("Phase 3: Adjust pointers", gc_timer()); 250 251 // Need cleared claim bits for the roots processing 252 ClassLoaderDataGraph::clear_claimed_marks(); 253 254 CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations); 255 { 256 G1RootProcessor root_processor(g1h, 1); 257 root_processor.process_all_roots(&GenMarkSweep::adjust_pointer_closure, 258 &GenMarkSweep::adjust_cld_closure, 259 &adjust_code_closure); 260 } 261 262 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); 263 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure); 264 265 // Now adjust pointers in remaining weak roots. (All of which should 266 // have been cleared if they pointed to non-surviving objects.) 267 JNIHandles::weak_oops_do(&GenMarkSweep::adjust_pointer_closure); 268 269 if (G1StringDedup::is_enabled()) { 270 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure); 271 } 272 273 GenMarkSweep::adjust_marks(); 274 275 G1AdjustPointersClosure blk; 276 g1h->heap_region_iterate(&blk); 277 } 278 279 class G1SpaceCompactClosure: public HeapRegionClosure { 280 public: 281 G1SpaceCompactClosure() {} 282 283 bool doHeapRegion(HeapRegion* hr) { 284 if (hr->is_humongous()) { 285 if (hr->is_starts_humongous()) { 286 oop obj = oop(hr->bottom()); 287 if (obj->is_gc_marked()) { 288 obj->init_mark(); 289 } else { 290 assert(hr->is_empty(), "Should have been cleared in phase 2."); 291 } 292 } 293 hr->reset_during_compaction(); 294 } else if (!hr->is_pinned()) { 295 hr->compact(); 296 } 297 return false; 298 } 299 }; 300 301 void G1MarkSweep::mark_sweep_phase4() { 302 // All pointers are now adjusted, move objects accordingly 303 304 // The ValidateMarkSweep live oops tracking expects us to traverse spaces 305 // in the same order in phase2, phase3 and phase4. We don't quite do that 306 // here (code and comment not fixed for perm removal), so we tell the validate code 307 // to use a higher index (saved from phase2) when verifying perm_gen. 308 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 309 310 GCTraceTime(Info, gc, phases) tm("Phase 4: Move objects", gc_timer()); 311 312 G1SpaceCompactClosure blk; 313 g1h->heap_region_iterate(&blk); 314 315 } 316 317 void G1MarkSweep::enable_archive_object_check() { 318 assert(!_archive_check_enabled, "archive range check already enabled"); 319 _archive_check_enabled = true; 320 size_t length = Universe::heap()->max_capacity(); 321 _archive_region_map.initialize((HeapWord*)Universe::heap()->base(), | 52 #include "runtime/thread.hpp" 53 #include "runtime/vmThread.hpp" 54 #include "utilities/copy.hpp" 55 #include "utilities/events.hpp" 56 57 class HeapRegion; 58 59 bool G1MarkSweep::_archive_check_enabled = false; 60 G1ArchiveRegionMap G1MarkSweep::_archive_region_map; 61 62 void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, 63 bool clear_all_softrefs) { 64 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); 65 66 #ifdef ASSERT 67 if (G1CollectedHeap::heap()->collector_policy()->should_clear_all_soft_refs()) { 68 assert(clear_all_softrefs, "Policy should have been checked earler"); 69 } 70 #endif 71 // hook up weak ref data so it can be used during Mark-Sweep 72 assert(rp != NULL, "should be non-NULL"); 73 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition"); 74 75 GenMarkSweep gms; 76 gms.set_ref_processor(rp); 77 rp->setup_policy(clear_all_softrefs); 78 79 // When collecting the permanent generation Method*s may be moving, 80 // so we either have to flush all bcp data or convert it into bci. 81 CodeCache::gc_prologue(); 82 83 bool marked_for_unloading = false; 84 85 allocate_stacks(&gms); 86 87 // We should save the marks of the currently locked biased monitors. 88 // The marking doesn't preserve the marks of biased objects. 89 BiasedLocking::preserve_marks(); 90 91 mark_sweep_phase1(&gms, marked_for_unloading, clear_all_softrefs); 92 93 mark_sweep_phase2(&gms); 94 95 #if defined(COMPILER2) || INCLUDE_JVMCI 96 // Don't add any more derived pointers during phase3 97 DerivedPointerTable::set_active(false); 98 #endif 99 100 mark_sweep_phase3(&gms); 101 102 mark_sweep_phase4(&gms); 103 104 gms.restore_marks(); 105 BiasedLocking::restore_marks(); 106 gms.deallocate_stacks(); 107 108 CodeCache::gc_epilogue(); 109 JvmtiExport::gc_epilogue(); 110 111 // refs processing: clean slate 112 gms.set_ref_processor(NULL); 113 } 114 115 116 void G1MarkSweep::allocate_stacks(GenMarkSweep* gms) { 117 gms->_preserved_count_max = 0; 118 gms->_preserved_marks = NULL; 119 gms->_preserved_count = 0; 120 } 121 122 void G1MarkSweep::mark_sweep_phase1(GenMarkSweep* gms, bool& marked_for_unloading, 123 bool clear_all_softrefs) { 124 // Recursively traverse all live objects and mark them 125 GCTraceTime(Info, gc, phases) tm("Phase 1: Mark live objects", gc_timer()); 126 127 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 128 129 // Need cleared claim bits for the roots processing 130 ClassLoaderDataGraph::clear_claimed_marks(); 131 132 MarkingCodeBlobClosure follow_code_closure(&gms->follow_root_closure, !CodeBlobToOopClosure::FixRelocations); 133 { 134 G1RootProcessor root_processor(g1h, 1); 135 if (ClassUnloading) { 136 root_processor.process_strong_roots(&gms->follow_root_closure, 137 &gms->follow_cld_closure, 138 &follow_code_closure); 139 } else { 140 root_processor.process_all_roots_no_string_table( 141 &gms->follow_root_closure, 142 &gms->follow_cld_closure, 143 &follow_code_closure); 144 } 145 } 146 147 { 148 GCTraceTime(Debug, gc, phases) trace("Reference Processing", gc_timer()); 149 150 // Process reference objects found during marking 151 ReferenceProcessor* rp = gms->ref_processor(); 152 assert(rp == g1h->ref_processor_stw(), "Sanity"); 153 154 rp->setup_policy(clear_all_softrefs); 155 const ReferenceProcessorStats& stats = 156 rp->process_discovered_references(&gms->is_alive, 157 &gms->keep_alive, 158 &gms->follow_stack_closure, 159 NULL, 160 gc_timer()); 161 gc_tracer()->report_gc_reference_stats(stats); 162 } 163 164 // This is the point where the entire marking should have completed. 165 assert(gms->_marking_stack.is_empty(), "Marking should have completed"); 166 167 if (ClassUnloading) { 168 GCTraceTime(Debug, gc, phases) trace("Class Unloading", gc_timer()); 169 170 // Unload classes and purge the SystemDictionary. 171 bool purged_class = SystemDictionary::do_unloading(&gms->is_alive); 172 173 // Unload nmethods. 174 CodeCache::do_unloading(&gms->is_alive, purged_class); 175 176 // Prune dead klasses from subklass/sibling/implementor lists. 177 Klass::clean_weak_klass_links(&gms->is_alive); 178 } 179 180 { 181 GCTraceTime(Debug, gc, phases) trace("Scrub String and Symbol Tables", gc_timer()); 182 // Delete entries for dead interned string and clean up unreferenced symbols in symbol table. 183 g1h->unlink_string_and_symbol_table(&gms->is_alive); 184 } 185 186 if (G1StringDedup::is_enabled()) { 187 GCTraceTime(Debug, gc, phases) trace("String Deduplication Unlink", gc_timer()); 188 G1StringDedup::unlink(&gms->is_alive); 189 } 190 191 if (VerifyDuringGC) { 192 HandleMark hm; // handle scope 193 #if defined(COMPILER2) || INCLUDE_JVMCI 194 DerivedPointerTableDeactivate dpt_deact; 195 #endif 196 g1h->prepare_for_verify(); 197 // Note: we can verify only the heap here. When an object is 198 // marked, the previous value of the mark word (including 199 // identity hash values, ages, etc) is preserved, and the mark 200 // word is set to markOop::marked_value - effectively removing 201 // any hash values from the mark word. These hash values are 202 // used when verifying the dictionaries and so removing them 203 // from the mark word can make verification of the dictionaries 204 // fail. At the end of the GC, the original mark word values 205 // (including hash values) are restored to the appropriate 206 // objects. 207 GCTraceTime(Info, gc, verify)("During GC (full)"); 208 g1h->verify(VerifyOption_G1UseMarkWord); 209 } 210 211 gc_tracer()->report_object_count_after_gc(&gms->is_alive); 212 } 213 214 215 void G1MarkSweep::mark_sweep_phase2(GenMarkSweep* /* gms */) { 216 // Now all live objects are marked, compute the new object addresses. 217 218 // It is not required that we traverse spaces in the same order in 219 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops 220 // tracking expects us to do so. See comment under phase4. 221 222 GCTraceTime(Info, gc, phases) tm("Phase 2: Compute new object addresses", gc_timer()); 223 224 prepare_compaction(); 225 } 226 227 class G1AdjustPointersClosure: public HeapRegionClosure { 228 MarkSweep* _ms; 229 public: 230 G1AdjustPointersClosure(MarkSweep* ms) : _ms(ms) {} 231 bool doHeapRegion(HeapRegion* r) { 232 if (r->is_humongous()) { 233 if (r->is_starts_humongous()) { 234 // We must adjust the pointers on the single H object. 235 oop obj = oop(r->bottom()); 236 // point all the oops to the new location 237 _ms->adjust_pointers(obj); 238 } 239 } else if (!r->is_pinned()) { 240 // This really ought to be "as_CompactibleSpace"... 241 r->adjust_pointers(_ms); 242 } 243 return false; 244 } 245 }; 246 247 void G1MarkSweep::mark_sweep_phase3(GenMarkSweep* gms) { 248 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 249 250 // Adjust the pointers to reflect the new locations 251 GCTraceTime(Info, gc, phases) tm("Phase 3: Adjust pointers", gc_timer()); 252 253 // Need cleared claim bits for the roots processing 254 ClassLoaderDataGraph::clear_claimed_marks(); 255 256 CodeBlobToOopClosure adjust_code_closure(&gms->adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations); 257 { 258 G1RootProcessor root_processor(g1h, 1); 259 root_processor.process_all_roots(&gms->adjust_pointer_closure, 260 &gms->adjust_cld_closure, 261 &adjust_code_closure); 262 } 263 264 assert(gms->ref_processor() == g1h->ref_processor_stw(), "Sanity"); 265 g1h->ref_processor_stw()->weak_oops_do(&gms->adjust_pointer_closure); 266 267 // Now adjust pointers in remaining weak roots. (All of which should 268 // have been cleared if they pointed to non-surviving objects.) 269 JNIHandles::weak_oops_do(&gms->adjust_pointer_closure); 270 271 if (G1StringDedup::is_enabled()) { 272 G1StringDedup::oops_do(&gms->adjust_pointer_closure); 273 } 274 275 gms->adjust_marks(); 276 277 G1AdjustPointersClosure blk(gms); 278 g1h->heap_region_iterate(&blk); 279 } 280 281 class G1SpaceCompactClosure: public HeapRegionClosure { 282 public: 283 G1SpaceCompactClosure() {} 284 285 bool doHeapRegion(HeapRegion* hr) { 286 if (hr->is_humongous()) { 287 if (hr->is_starts_humongous()) { 288 oop obj = oop(hr->bottom()); 289 if (obj->is_gc_marked()) { 290 obj->init_mark(); 291 } else { 292 assert(hr->is_empty(), "Should have been cleared in phase 2."); 293 } 294 } 295 hr->reset_during_compaction(); 296 } else if (!hr->is_pinned()) { 297 hr->compact(); 298 } 299 return false; 300 } 301 }; 302 303 void G1MarkSweep::mark_sweep_phase4(GenMarkSweep* /* gms */) { 304 // All pointers are now adjusted, move objects accordingly 305 306 // The ValidateMarkSweep live oops tracking expects us to traverse spaces 307 // in the same order in phase2, phase3 and phase4. We don't quite do that 308 // here (code and comment not fixed for perm removal), so we tell the validate code 309 // to use a higher index (saved from phase2) when verifying perm_gen. 310 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 311 312 GCTraceTime(Info, gc, phases) tm("Phase 4: Move objects", gc_timer()); 313 314 G1SpaceCompactClosure blk; 315 g1h->heap_region_iterate(&blk); 316 317 } 318 319 void G1MarkSweep::enable_archive_object_check() { 320 assert(!_archive_check_enabled, "archive range check already enabled"); 321 _archive_check_enabled = true; 322 size_t length = Universe::heap()->max_capacity(); 323 _archive_region_map.initialize((HeapWord*)Universe::heap()->base(), |