Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1MarkSweep.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
author | tamao |
---|---|
date | Tue, 05 Mar 2013 15:36:56 -0800 |
parents | b735136e0d82 |
children | a08c80e9e1e5 |
rev | line source |
---|---|
342 | 1 /* |
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4072
diff
changeset
|
2 * Copyright (c) 2001, 2012, 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" | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
4872
diff
changeset
|
32 #include "gc_implementation/g1/g1Log.hpp" |
1972 | 33 #include "gc_implementation/g1/g1MarkSweep.hpp" |
34 #include "memory/gcLocker.hpp" | |
35 #include "memory/genCollectedHeap.hpp" | |
36 #include "memory/modRefBarrierSet.hpp" | |
37 #include "memory/referencePolicy.hpp" | |
38 #include "memory/space.hpp" | |
39 #include "oops/instanceRefKlass.hpp" | |
40 #include "oops/oop.inline.hpp" | |
41 #include "prims/jvmtiExport.hpp" | |
42 #include "runtime/aprofiler.hpp" | |
43 #include "runtime/biasedLocking.hpp" | |
44 #include "runtime/fprofiler.hpp" | |
45 #include "runtime/synchronizer.hpp" | |
46 #include "runtime/thread.hpp" | |
47 #include "runtime/vmThread.hpp" | |
48 #include "utilities/copy.hpp" | |
49 #include "utilities/events.hpp" | |
342 | 50 |
51 class HeapRegion; | |
52 | |
53 void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, | |
54 bool clear_all_softrefs) { | |
55 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); | |
56 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
57 SharedHeap* sh = SharedHeap::heap(); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
58 #ifdef ASSERT |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
59 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
|
60 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
|
61 } |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
62 #endif |
342 | 63 // hook up weak ref data so it can be used during Mark-Sweep |
64 assert(GenMarkSweep::ref_processor() == NULL, "no stomping"); | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
65 assert(rp != NULL, "should be non-NULL"); |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
66 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
67 |
342 | 68 GenMarkSweep::_ref_processor = rp; |
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
69 rp->setup_policy(clear_all_softrefs); |
342 | 70 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
71 // When collecting the permanent generation Method*s may be moving, |
342 | 72 // so we either have to flush all bcp data or convert it into bci. |
73 CodeCache::gc_prologue(); | |
74 Threads::gc_prologue(); | |
75 | |
76 bool marked_for_unloading = false; | |
77 | |
78 allocate_stacks(); | |
79 | |
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
80 // 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
|
81 // 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
|
82 BiasedLocking::preserve_marks(); |
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
83 |
342 | 84 mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); |
85 | |
86 mark_sweep_phase2(); | |
87 | |
88 // Don't add any more derived pointers during phase3 | |
89 COMPILER2_PRESENT(DerivedPointerTable::set_active(false)); | |
90 | |
91 mark_sweep_phase3(); | |
92 | |
93 mark_sweep_phase4(); | |
94 | |
95 GenMarkSweep::restore_marks(); | |
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
96 BiasedLocking::restore_marks(); |
342 | 97 GenMarkSweep::deallocate_stacks(); |
98 | |
99 // "free at last gc" is calculated from these. | |
100 // CHF: cheating for now!!! | |
101 // Universe::set_heap_capacity_at_last_gc(Universe::heap()->capacity()); | |
102 // Universe::set_heap_used_at_last_gc(Universe::heap()->used()); | |
103 | |
104 Threads::gc_epilogue(); | |
105 CodeCache::gc_epilogue(); | |
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
106 JvmtiExport::gc_epilogue(); |
342 | 107 |
108 // refs processing: clean slate | |
109 GenMarkSweep::_ref_processor = NULL; | |
110 } | |
111 | |
112 | |
113 void G1MarkSweep::allocate_stacks() { | |
114 GenMarkSweep::_preserved_count_max = 0; | |
115 GenMarkSweep::_preserved_marks = NULL; | |
116 GenMarkSweep::_preserved_count = 0; | |
117 } | |
118 | |
119 void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading, | |
120 bool clear_all_softrefs) { | |
121 // Recursively traverse all live objects and mark them | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
4872
diff
changeset
|
122 TraceTime tm("phase 1", G1Log::fine() && Verbose, true, gclog_or_tty); |
342 | 123 GenMarkSweep::trace(" 1"); |
124 | |
125 SharedHeap* sh = SharedHeap::heap(); | |
126 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
127 // Need cleared claim bits for the strong roots processing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
128 ClassLoaderDataGraph::clear_claimed_marks(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
129 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
130 sh->process_strong_roots(true, // activate StrongRootsScope |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
131 false, // not scavenging. |
342 | 132 SharedHeap::SO_SystemClasses, |
133 &GenMarkSweep::follow_root_closure, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
134 &GenMarkSweep::follow_code_root_closure, |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
135 &GenMarkSweep::follow_klass_closure); |
342 | 136 |
137 // Process reference objects found during marking | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
138 ReferenceProcessor* rp = GenMarkSweep::ref_processor(); |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
139 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
140 |
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
141 rp->setup_policy(clear_all_softrefs); |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
142 rp->process_discovered_references(&GenMarkSweep::is_alive, |
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
143 &GenMarkSweep::keep_alive, |
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
144 &GenMarkSweep::follow_stack_closure, |
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
145 NULL); |
342 | 146 |
147 // Follow system dictionary roots and unload classes | |
148 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
|
149 assert(GenMarkSweep::_marking_stack.is_empty(), |
342 | 150 "stack should be empty by now"); |
151 | |
152 // Follow code cache roots (has to be done after system dictionary, | |
153 // assumes all live klasses are marked) | |
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
154 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class); |
941 | 155 GenMarkSweep::follow_stack(); |
342 | 156 |
157 // Update subklass/sibling/implementor links of live klasses | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
158 Klass::clean_weak_klass_links(&GenMarkSweep::is_alive); |
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
159 assert(GenMarkSweep::_marking_stack.is_empty(), |
342 | 160 "stack should be empty by now"); |
161 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
162 // Visit interned string tables and delete unmarked oops |
342 | 163 StringTable::unlink(&GenMarkSweep::is_alive); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
164 // Clean up unreferenced symbols in symbol table. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2153
diff
changeset
|
165 SymbolTable::unlink(); |
342 | 166 |
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
167 assert(GenMarkSweep::_marking_stack.is_empty(), |
342 | 168 "stack should be empty by now"); |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
169 |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
170 if (VerifyDuringGC) { |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
171 HandleMark hm; // handle scope |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
172 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
173 gclog_or_tty->print(" VerifyDuringGC:(full)[Verifying "); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
174 Universe::heap()->prepare_for_verify(); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
175 // 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
|
176 // marked, the previous value of the mark word (including |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
177 // identity hash values, ages, etc) is preserved, and the mark |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
178 // word is set to markOop::marked_value - effectively removing |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
179 // 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
|
180 // used when verifying the dictionaries and so removing them |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
181 // from the mark word can make verification of the dictionaries |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
182 // 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
|
183 // (including hash values) are restored to the appropriate |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
184 // objects. |
6008 | 185 Universe::heap()->verify(/* silent */ false, |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
186 /* option */ VerifyOption_G1UseMarkWord); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
187 |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
188 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
189 gclog_or_tty->print_cr("]"); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
190 } |
342 | 191 } |
192 | |
193 class G1PrepareCompactClosure: public HeapRegionClosure { | |
2152 | 194 G1CollectedHeap* _g1h; |
342 | 195 ModRefBarrierSet* _mrbs; |
196 CompactPoint _cp; | |
2152 | 197 HumongousRegionSet _humongous_proxy_set; |
342 | 198 |
199 void free_humongous_region(HeapRegion* hr) { | |
200 HeapWord* end = hr->end(); | |
2361 | 201 size_t dummy_pre_used; |
202 FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep"); | |
203 | |
342 | 204 assert(hr->startsHumongous(), |
205 "Only the start of a humongous region should be freed."); | |
2361 | 206 _g1h->free_humongous_region(hr, &dummy_pre_used, &dummy_free_list, |
2152 | 207 &_humongous_proxy_set, false /* par */); |
342 | 208 hr->prepare_for_compaction(&_cp); |
209 // Also clear the part of the card table that will be unused after | |
210 // compaction. | |
2152 | 211 _mrbs->clear(MemRegion(hr->compaction_top(), end)); |
2361 | 212 dummy_free_list.remove_all(); |
342 | 213 } |
214 | |
215 public: | |
2152 | 216 G1PrepareCompactClosure(CompactibleSpace* cs) |
217 : _g1h(G1CollectedHeap::heap()), | |
218 _mrbs(G1CollectedHeap::heap()->mr_bs()), | |
342 | 219 _cp(NULL, cs, cs->initialize_threshold()), |
2152 | 220 _humongous_proxy_set("G1MarkSweep Humongous Proxy Set") { } |
221 | |
222 void update_sets() { | |
223 // We'll recalculate total used bytes and recreate the free list | |
224 // at the end of the GC, so no point in updating those values here. | |
225 _g1h->update_sets_after_freeing_regions(0, /* pre_used */ | |
226 NULL, /* free_list */ | |
4072 | 227 NULL, /* old_proxy_set */ |
2152 | 228 &_humongous_proxy_set, |
229 false /* par */); | |
230 } | |
231 | |
342 | 232 bool doHeapRegion(HeapRegion* hr) { |
233 if (hr->isHumongous()) { | |
234 if (hr->startsHumongous()) { | |
235 oop obj = oop(hr->bottom()); | |
236 if (obj->is_gc_marked()) { | |
237 obj->forward_to(obj); | |
238 } else { | |
239 free_humongous_region(hr); | |
240 } | |
241 } else { | |
242 assert(hr->continuesHumongous(), "Invalid humongous."); | |
243 } | |
244 } else { | |
245 hr->prepare_for_compaction(&_cp); | |
246 // Also clear the part of the card table that will be unused after | |
247 // compaction. | |
248 _mrbs->clear(MemRegion(hr->compaction_top(), hr->end())); | |
249 } | |
250 return false; | |
251 } | |
252 }; | |
677 | 253 |
342 | 254 void G1MarkSweep::mark_sweep_phase2() { |
255 // Now all live objects are marked, compute the new object addresses. | |
256 | |
257 // It is not required that we traverse spaces in the same order in | |
258 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
259 // tracking expects us to do so. See comment under phase4. | |
260 | |
261 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
262 | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
4872
diff
changeset
|
263 TraceTime tm("phase 2", G1Log::fine() && Verbose, true, gclog_or_tty); |
342 | 264 GenMarkSweep::trace("2"); |
265 | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
266 // find the first region |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
267 HeapRegion* r = g1h->region_at(0); |
342 | 268 CompactibleSpace* sp = r; |
269 if (r->isHumongous() && oop(r->bottom())->is_gc_marked()) { | |
270 sp = r->next_compaction_space(); | |
271 } | |
272 | |
677 | 273 G1PrepareCompactClosure blk(sp); |
342 | 274 g1h->heap_region_iterate(&blk); |
2152 | 275 blk.update_sets(); |
342 | 276 } |
277 | |
278 class G1AdjustPointersClosure: public HeapRegionClosure { | |
279 public: | |
280 bool doHeapRegion(HeapRegion* r) { | |
281 if (r->isHumongous()) { | |
282 if (r->startsHumongous()) { | |
283 // We must adjust the pointers on the single H object. | |
284 oop obj = oop(r->bottom()); | |
285 // point all the oops to the new location | |
286 obj->adjust_pointers(); | |
287 } | |
288 } else { | |
289 // This really ought to be "as_CompactibleSpace"... | |
290 r->adjust_pointers(); | |
291 } | |
292 return false; | |
293 } | |
294 }; | |
295 | |
296 void G1MarkSweep::mark_sweep_phase3() { | |
297 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
298 | |
299 // Adjust the pointers to reflect the new locations | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
4872
diff
changeset
|
300 TraceTime tm("phase 3", G1Log::fine() && Verbose, true, gclog_or_tty); |
342 | 301 GenMarkSweep::trace("3"); |
302 | |
303 SharedHeap* sh = SharedHeap::heap(); | |
304 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
305 // Need cleared claim bits for the strong roots processing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
306 ClassLoaderDataGraph::clear_claimed_marks(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
307 |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
308 sh->process_strong_roots(true, // activate StrongRootsScope |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
309 false, // not scavenging. |
342 | 310 SharedHeap::SO_AllClasses, |
311 &GenMarkSweep::adjust_root_pointer_closure, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
312 NULL, // do not touch code cache here |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
313 &GenMarkSweep::adjust_klass_closure); |
342 | 314 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
315 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
316 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure); |
342 | 317 |
318 // Now adjust pointers in remaining weak roots. (All of which should | |
319 // have been cleared if they pointed to non-surviving objects.) | |
320 g1h->g1_process_weak_roots(&GenMarkSweep::adjust_root_pointer_closure, | |
321 &GenMarkSweep::adjust_pointer_closure); | |
322 | |
323 GenMarkSweep::adjust_marks(); | |
324 | |
325 G1AdjustPointersClosure blk; | |
326 g1h->heap_region_iterate(&blk); | |
327 } | |
328 | |
329 class G1SpaceCompactClosure: public HeapRegionClosure { | |
330 public: | |
331 G1SpaceCompactClosure() {} | |
332 | |
333 bool doHeapRegion(HeapRegion* hr) { | |
334 if (hr->isHumongous()) { | |
335 if (hr->startsHumongous()) { | |
336 oop obj = oop(hr->bottom()); | |
337 if (obj->is_gc_marked()) { | |
338 obj->init_mark(); | |
339 } else { | |
340 assert(hr->is_empty(), "Should have been cleared in phase 2."); | |
341 } | |
342 hr->reset_during_compaction(); | |
343 } | |
344 } else { | |
345 hr->compact(); | |
346 } | |
347 return false; | |
348 } | |
349 }; | |
350 | |
351 void G1MarkSweep::mark_sweep_phase4() { | |
352 // All pointers are now adjusted, move objects accordingly | |
353 | |
354 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
355 // in the same order in phase2, phase3 and phase4. We don't quite do that | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
356 // here (code and comment not fixed for perm removal), so we tell the validate code |
342 | 357 // to use a higher index (saved from phase2) when verifying perm_gen. |
358 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
359 | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
4872
diff
changeset
|
360 TraceTime tm("phase 4", G1Log::fine() && Verbose, true, gclog_or_tty); |
342 | 361 GenMarkSweep::trace("4"); |
362 | |
363 G1SpaceCompactClosure blk; | |
364 g1h->heap_region_iterate(&blk); | |
365 | |
366 } |