Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1MarkSweep.cpp @ 3772:6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps.
Reviewed-by: tonyp, ysr
| author | johnc |
|---|---|
| date | Tue, 14 Jun 2011 11:01:10 -0700 |
| parents | 1216415d8e35 |
| children | 4dfb2df418f2 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 2152 | 2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
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:
1387
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 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/g1MarkSweep.hpp" | |
| 33 #include "memory/gcLocker.hpp" | |
| 34 #include "memory/genCollectedHeap.hpp" | |
| 35 #include "memory/modRefBarrierSet.hpp" | |
| 36 #include "memory/referencePolicy.hpp" | |
| 37 #include "memory/space.hpp" | |
| 38 #include "oops/instanceRefKlass.hpp" | |
| 39 #include "oops/oop.inline.hpp" | |
| 40 #include "prims/jvmtiExport.hpp" | |
| 41 #include "runtime/aprofiler.hpp" | |
| 42 #include "runtime/biasedLocking.hpp" | |
| 43 #include "runtime/fprofiler.hpp" | |
| 44 #include "runtime/synchronizer.hpp" | |
| 45 #include "runtime/thread.hpp" | |
| 46 #include "runtime/vmThread.hpp" | |
| 47 #include "utilities/copy.hpp" | |
| 48 #include "utilities/events.hpp" | |
| 342 | 49 |
| 50 class HeapRegion; | |
| 51 | |
| 52 void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, | |
| 53 bool clear_all_softrefs) { | |
| 54 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); | |
| 55 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
56 SharedHeap* sh = SharedHeap::heap(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
57 #ifdef ASSERT |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
58 if (sh->collector_policy()->should_clear_all_soft_refs()) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
59 assert(clear_all_softrefs, "Policy should have been checked earler"); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
60 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
61 #endif |
| 342 | 62 // hook up weak ref data so it can be used during Mark-Sweep |
| 63 assert(GenMarkSweep::ref_processor() == NULL, "no stomping"); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
64 assert(rp != NULL, "should be non-NULL"); |
| 342 | 65 GenMarkSweep::_ref_processor = rp; |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
66 rp->setup_policy(clear_all_softrefs); |
| 342 | 67 |
| 68 // When collecting the permanent generation methodOops may be moving, | |
| 69 // so we either have to flush all bcp data or convert it into bci. | |
| 70 CodeCache::gc_prologue(); | |
| 71 Threads::gc_prologue(); | |
| 72 | |
| 73 // Increment the invocation count for the permanent generation, since it is | |
| 74 // implicitly collected whenever we do a full mark sweep collection. | |
| 75 sh->perm_gen()->stat_record()->invocations++; | |
| 76 | |
| 77 bool marked_for_unloading = false; | |
| 78 | |
| 79 allocate_stacks(); | |
| 80 | |
|
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
81 // We should save the marks of the currently locked biased monitors. |
|
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
82 // The marking doesn't preserve the marks of biased objects. |
|
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
83 BiasedLocking::preserve_marks(); |
|
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
84 |
| 342 | 85 mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); |
| 86 | |
| 87 mark_sweep_phase2(); | |
| 88 | |
| 89 // Don't add any more derived pointers during phase3 | |
| 90 COMPILER2_PRESENT(DerivedPointerTable::set_active(false)); | |
| 91 | |
| 92 mark_sweep_phase3(); | |
| 93 | |
| 94 mark_sweep_phase4(); | |
| 95 | |
| 96 GenMarkSweep::restore_marks(); | |
|
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
97 BiasedLocking::restore_marks(); |
| 342 | 98 GenMarkSweep::deallocate_stacks(); |
| 99 | |
| 100 // We must invalidate the perm-gen rs, so that it gets rebuilt. | |
| 101 GenRemSet* rs = sh->rem_set(); | |
| 102 rs->invalidate(sh->perm_gen()->used_region(), true /*whole_heap*/); | |
| 103 | |
| 104 // "free at last gc" is calculated from these. | |
| 105 // CHF: cheating for now!!! | |
| 106 // Universe::set_heap_capacity_at_last_gc(Universe::heap()->capacity()); | |
| 107 // Universe::set_heap_used_at_last_gc(Universe::heap()->used()); | |
| 108 | |
| 109 Threads::gc_epilogue(); | |
| 110 CodeCache::gc_epilogue(); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
111 JvmtiExport::gc_epilogue(); |
| 342 | 112 |
| 113 // refs processing: clean slate | |
| 114 GenMarkSweep::_ref_processor = NULL; | |
| 115 } | |
| 116 | |
| 117 | |
| 118 void G1MarkSweep::allocate_stacks() { | |
| 119 GenMarkSweep::_preserved_count_max = 0; | |
| 120 GenMarkSweep::_preserved_marks = NULL; | |
| 121 GenMarkSweep::_preserved_count = 0; | |
| 122 } | |
| 123 | |
| 124 void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading, | |
| 125 bool clear_all_softrefs) { | |
| 126 // Recursively traverse all live objects and mark them | |
| 127 EventMark m("1 mark object"); | |
| 128 TraceTime tm("phase 1", PrintGC && Verbose, true, gclog_or_tty); | |
| 129 GenMarkSweep::trace(" 1"); | |
| 130 | |
| 131 SharedHeap* sh = SharedHeap::heap(); | |
| 132 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
133 sh->process_strong_roots(true, // activeate StrongRootsScope |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
134 true, // Collecting permanent generation. |
| 342 | 135 SharedHeap::SO_SystemClasses, |
| 136 &GenMarkSweep::follow_root_closure, | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
137 &GenMarkSweep::follow_code_root_closure, |
| 342 | 138 &GenMarkSweep::follow_root_closure); |
| 139 | |
| 140 // Process reference objects found during marking | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
141 ReferenceProcessor* rp = GenMarkSweep::ref_processor(); |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
142 rp->setup_policy(clear_all_softrefs); |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
143 rp->process_discovered_references(&GenMarkSweep::is_alive, |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
144 &GenMarkSweep::keep_alive, |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
145 &GenMarkSweep::follow_stack_closure, |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
146 NULL); |
| 342 | 147 |
| 148 // Follow system dictionary roots and unload classes | |
| 149 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
150 assert(GenMarkSweep::_marking_stack.is_empty(), |
| 342 | 151 "stack should be empty by now"); |
| 152 | |
| 153 // Follow code cache roots (has to be done after system dictionary, | |
| 154 // assumes all live klasses are marked) | |
| 155 CodeCache::do_unloading(&GenMarkSweep::is_alive, | |
| 156 &GenMarkSweep::keep_alive, | |
| 157 purged_class); | |
| 941 | 158 GenMarkSweep::follow_stack(); |
| 342 | 159 |
| 160 // Update subklass/sibling/implementor links of live klasses | |
| 161 GenMarkSweep::follow_weak_klass_links(); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
162 assert(GenMarkSweep::_marking_stack.is_empty(), |
| 342 | 163 "stack should be empty by now"); |
| 164 | |
| 941 | 165 // Visit memoized MDO's and clear any unmarked weak refs |
| 166 GenMarkSweep::follow_mdo_weak_refs(); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
167 assert(GenMarkSweep::_marking_stack.is_empty(), "just drained"); |
| 941 | 168 |
| 169 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
170 // Visit interned string tables and delete unmarked oops |
| 342 | 171 StringTable::unlink(&GenMarkSweep::is_alive); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
172 // Clean up unreferenced symbols in symbol table. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
173 SymbolTable::unlink(); |
| 342 | 174 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
175 assert(GenMarkSweep::_marking_stack.is_empty(), |
| 342 | 176 "stack should be empty by now"); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
177 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
178 if (VerifyDuringGC) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
179 HandleMark hm; // handle scope |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
180 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
181 gclog_or_tty->print(" VerifyDuringGC:(full)[Verifying "); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
182 Universe::heap()->prepare_for_verify(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
183 // Note: we can verify only the heap here. When an object is |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
184 // marked, the previous value of the mark word (including |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
185 // identity hash values, ages, etc) is preserved, and the mark |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
186 // word is set to markOop::marked_value - effectively removing |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
187 // any hash values from the mark word. These hash values are |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
188 // used when verifying the dictionaries and so removing them |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
189 // from the mark word can make verification of the dictionaries |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
190 // fail. At the end of the GC, the orginal mark word values |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
191 // (including hash values) are restored to the appropriate |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
192 // objects. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
193 Universe::heap()->verify(/* allow dirty */ true, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
194 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
195 /* option */ VerifyOption_G1UseMarkWord); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
196 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
197 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
198 gclog_or_tty->print_cr("]"); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
199 } |
| 342 | 200 } |
| 201 | |
| 202 class G1PrepareCompactClosure: public HeapRegionClosure { | |
| 2152 | 203 G1CollectedHeap* _g1h; |
| 342 | 204 ModRefBarrierSet* _mrbs; |
| 205 CompactPoint _cp; | |
| 2152 | 206 HumongousRegionSet _humongous_proxy_set; |
| 342 | 207 |
| 208 void free_humongous_region(HeapRegion* hr) { | |
| 209 HeapWord* end = hr->end(); | |
| 2361 | 210 size_t dummy_pre_used; |
| 211 FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep"); | |
| 212 | |
| 342 | 213 assert(hr->startsHumongous(), |
| 214 "Only the start of a humongous region should be freed."); | |
| 2361 | 215 _g1h->free_humongous_region(hr, &dummy_pre_used, &dummy_free_list, |
| 2152 | 216 &_humongous_proxy_set, false /* par */); |
| 342 | 217 hr->prepare_for_compaction(&_cp); |
| 218 // Also clear the part of the card table that will be unused after | |
| 219 // compaction. | |
| 2152 | 220 _mrbs->clear(MemRegion(hr->compaction_top(), end)); |
| 2361 | 221 dummy_free_list.remove_all(); |
| 342 | 222 } |
| 223 | |
| 224 public: | |
| 2152 | 225 G1PrepareCompactClosure(CompactibleSpace* cs) |
| 226 : _g1h(G1CollectedHeap::heap()), | |
| 227 _mrbs(G1CollectedHeap::heap()->mr_bs()), | |
| 342 | 228 _cp(NULL, cs, cs->initialize_threshold()), |
| 2152 | 229 _humongous_proxy_set("G1MarkSweep Humongous Proxy Set") { } |
| 230 | |
| 231 void update_sets() { | |
| 232 // We'll recalculate total used bytes and recreate the free list | |
| 233 // at the end of the GC, so no point in updating those values here. | |
| 234 _g1h->update_sets_after_freeing_regions(0, /* pre_used */ | |
| 235 NULL, /* free_list */ | |
| 236 &_humongous_proxy_set, | |
| 237 false /* par */); | |
| 238 } | |
| 239 | |
| 342 | 240 bool doHeapRegion(HeapRegion* hr) { |
| 241 if (hr->isHumongous()) { | |
| 242 if (hr->startsHumongous()) { | |
| 243 oop obj = oop(hr->bottom()); | |
| 244 if (obj->is_gc_marked()) { | |
| 245 obj->forward_to(obj); | |
| 246 } else { | |
| 247 free_humongous_region(hr); | |
| 248 } | |
| 249 } else { | |
| 250 assert(hr->continuesHumongous(), "Invalid humongous."); | |
| 251 } | |
| 252 } else { | |
| 253 hr->prepare_for_compaction(&_cp); | |
| 254 // Also clear the part of the card table that will be unused after | |
| 255 // compaction. | |
| 256 _mrbs->clear(MemRegion(hr->compaction_top(), hr->end())); | |
| 257 } | |
| 258 return false; | |
| 259 } | |
| 260 }; | |
| 677 | 261 |
| 262 // Finds the first HeapRegion. | |
| 342 | 263 class FindFirstRegionClosure: public HeapRegionClosure { |
| 264 HeapRegion* _a_region; | |
| 265 public: | |
| 677 | 266 FindFirstRegionClosure() : _a_region(NULL) {} |
| 342 | 267 bool doHeapRegion(HeapRegion* r) { |
| 677 | 268 _a_region = r; |
| 269 return true; | |
| 342 | 270 } |
| 271 HeapRegion* result() { return _a_region; } | |
| 272 }; | |
| 273 | |
| 274 void G1MarkSweep::mark_sweep_phase2() { | |
| 275 // Now all live objects are marked, compute the new object addresses. | |
| 276 | |
| 277 // It is imperative that we traverse perm_gen LAST. If dead space is | |
| 278 // allowed a range of dead object may get overwritten by a dead int | |
| 279 // array. If perm_gen is not traversed last a klassOop may get | |
| 280 // overwritten. This is fine since it is dead, but if the class has dead | |
| 281 // instances we have to skip them, and in order to find their size we | |
| 282 // need the klassOop! | |
| 283 // | |
| 284 // It is not required that we traverse spaces in the same order in | |
| 285 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
| 286 // tracking expects us to do so. See comment under phase4. | |
| 287 | |
| 288 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 289 Generation* pg = g1h->perm_gen(); | |
| 290 | |
| 291 EventMark m("2 compute new addresses"); | |
| 292 TraceTime tm("phase 2", PrintGC && Verbose, true, gclog_or_tty); | |
| 293 GenMarkSweep::trace("2"); | |
| 294 | |
| 677 | 295 FindFirstRegionClosure cl; |
| 342 | 296 g1h->heap_region_iterate(&cl); |
| 297 HeapRegion *r = cl.result(); | |
| 298 CompactibleSpace* sp = r; | |
| 299 if (r->isHumongous() && oop(r->bottom())->is_gc_marked()) { | |
| 300 sp = r->next_compaction_space(); | |
| 301 } | |
| 302 | |
| 677 | 303 G1PrepareCompactClosure blk(sp); |
| 342 | 304 g1h->heap_region_iterate(&blk); |
| 2152 | 305 blk.update_sets(); |
| 342 | 306 |
| 307 CompactPoint perm_cp(pg, NULL, NULL); | |
| 308 pg->prepare_for_compaction(&perm_cp); | |
| 309 } | |
| 310 | |
| 311 class G1AdjustPointersClosure: public HeapRegionClosure { | |
| 312 public: | |
| 313 bool doHeapRegion(HeapRegion* r) { | |
| 314 if (r->isHumongous()) { | |
| 315 if (r->startsHumongous()) { | |
| 316 // We must adjust the pointers on the single H object. | |
| 317 oop obj = oop(r->bottom()); | |
| 318 debug_only(GenMarkSweep::track_interior_pointers(obj)); | |
| 319 // point all the oops to the new location | |
| 320 obj->adjust_pointers(); | |
| 321 debug_only(GenMarkSweep::check_interior_pointers()); | |
| 322 } | |
| 323 } else { | |
| 324 // This really ought to be "as_CompactibleSpace"... | |
| 325 r->adjust_pointers(); | |
| 326 } | |
| 327 return false; | |
| 328 } | |
| 329 }; | |
| 330 | |
| 331 void G1MarkSweep::mark_sweep_phase3() { | |
| 332 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 333 Generation* pg = g1h->perm_gen(); | |
| 334 | |
| 335 // Adjust the pointers to reflect the new locations | |
| 336 EventMark m("3 adjust pointers"); | |
| 337 TraceTime tm("phase 3", PrintGC && Verbose, true, gclog_or_tty); | |
| 338 GenMarkSweep::trace("3"); | |
| 339 | |
| 340 SharedHeap* sh = SharedHeap::heap(); | |
| 341 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
342 sh->process_strong_roots(true, // activate StrongRootsScope |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
343 true, // Collecting permanent generation. |
| 342 | 344 SharedHeap::SO_AllClasses, |
| 345 &GenMarkSweep::adjust_root_pointer_closure, | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
346 NULL, // do not touch code cache here |
| 342 | 347 &GenMarkSweep::adjust_pointer_closure); |
| 348 | |
| 349 g1h->ref_processor()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure); | |
| 350 | |
| 351 // Now adjust pointers in remaining weak roots. (All of which should | |
| 352 // have been cleared if they pointed to non-surviving objects.) | |
| 353 g1h->g1_process_weak_roots(&GenMarkSweep::adjust_root_pointer_closure, | |
| 354 &GenMarkSweep::adjust_pointer_closure); | |
| 355 | |
| 356 GenMarkSweep::adjust_marks(); | |
| 357 | |
| 358 G1AdjustPointersClosure blk; | |
| 359 g1h->heap_region_iterate(&blk); | |
| 360 pg->adjust_pointers(); | |
| 361 } | |
| 362 | |
| 363 class G1SpaceCompactClosure: public HeapRegionClosure { | |
| 364 public: | |
| 365 G1SpaceCompactClosure() {} | |
| 366 | |
| 367 bool doHeapRegion(HeapRegion* hr) { | |
| 368 if (hr->isHumongous()) { | |
| 369 if (hr->startsHumongous()) { | |
| 370 oop obj = oop(hr->bottom()); | |
| 371 if (obj->is_gc_marked()) { | |
| 372 obj->init_mark(); | |
| 373 } else { | |
| 374 assert(hr->is_empty(), "Should have been cleared in phase 2."); | |
| 375 } | |
| 376 hr->reset_during_compaction(); | |
| 377 } | |
| 378 } else { | |
| 379 hr->compact(); | |
| 380 } | |
| 381 return false; | |
| 382 } | |
| 383 }; | |
| 384 | |
| 385 void G1MarkSweep::mark_sweep_phase4() { | |
| 386 // All pointers are now adjusted, move objects accordingly | |
| 387 | |
| 388 // It is imperative that we traverse perm_gen first in phase4. All | |
| 389 // classes must be allocated earlier than their instances, and traversing | |
| 390 // perm_gen first makes sure that all klassOops have moved to their new | |
| 391 // location before any instance does a dispatch through it's klass! | |
| 392 | |
| 393 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
| 394 // in the same order in phase2, phase3 and phase4. We don't quite do that | |
| 395 // here (perm_gen first rather than last), so we tell the validate code | |
| 396 // to use a higher index (saved from phase2) when verifying perm_gen. | |
| 397 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 398 Generation* pg = g1h->perm_gen(); | |
| 399 | |
| 400 EventMark m("4 compact heap"); | |
| 401 TraceTime tm("phase 4", PrintGC && Verbose, true, gclog_or_tty); | |
| 402 GenMarkSweep::trace("4"); | |
| 403 | |
| 404 pg->compact(); | |
| 405 | |
| 406 G1SpaceCompactClosure blk; | |
| 407 g1h->heap_region_iterate(&blk); | |
| 408 | |
| 409 } | |
| 410 | |
| 411 // Local Variables: *** | |
| 412 // c-indentation-style: gnu *** | |
| 413 // End: *** |