Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1MarkSweep.cpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
author | tschatzl |
---|---|
date | Fri, 04 Apr 2014 10:43:56 +0200 |
parents | 595c0f60d50d |
children | 52b4284cb496 0982ec23da03 |
rev | line source |
---|---|
342 | 1 /* |
17764 | 2 * Copyright (c) 2001, 2014, 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" |
17764 | 34 #include "gc_implementation/g1/g1StringDedup.hpp" |
10405 | 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" | |
1972 | 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/biasedLocking.hpp" | |
48 #include "runtime/fprofiler.hpp" | |
49 #include "runtime/synchronizer.hpp" | |
50 #include "runtime/thread.hpp" | |
51 #include "runtime/vmThread.hpp" | |
52 #include "utilities/copy.hpp" | |
53 #include "utilities/events.hpp" | |
342 | 54 |
55 class HeapRegion; | |
56 | |
57 void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, | |
58 bool clear_all_softrefs) { | |
59 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); | |
60 | |
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
61 SharedHeap* sh = SharedHeap::heap(); |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
62 #ifdef ASSERT |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
63 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
|
64 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
|
65 } |
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
66 #endif |
342 | 67 // hook up weak ref data so it can be used during Mark-Sweep |
68 assert(GenMarkSweep::ref_processor() == NULL, "no stomping"); | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
69 assert(rp != NULL, "should be non-NULL"); |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
70 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
71 |
342 | 72 GenMarkSweep::_ref_processor = rp; |
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
73 rp->setup_policy(clear_all_softrefs); |
342 | 74 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
75 // When collecting the permanent generation Method*s may be moving, |
342 | 76 // so we either have to flush all bcp data or convert it into bci. |
77 CodeCache::gc_prologue(); | |
78 Threads::gc_prologue(); | |
79 | |
80 bool marked_for_unloading = false; | |
81 | |
82 allocate_stacks(); | |
83 | |
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
84 // 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
|
85 // 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
|
86 BiasedLocking::preserve_marks(); |
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
87 |
342 | 88 mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); |
89 | |
90 mark_sweep_phase2(); | |
91 | |
92 // Don't add any more derived pointers during phase3 | |
93 COMPILER2_PRESENT(DerivedPointerTable::set_active(false)); | |
94 | |
95 mark_sweep_phase3(); | |
96 | |
97 mark_sweep_phase4(); | |
98 | |
99 GenMarkSweep::restore_marks(); | |
358
8651a65ac4b4
6735416: G1: runThese javasoft.sqe.tests.lang.thrd011.thrd01101.thrd01101 fails
iveresov
parents:
342
diff
changeset
|
100 BiasedLocking::restore_marks(); |
342 | 101 GenMarkSweep::deallocate_stacks(); |
102 | |
103 // "free at last gc" is calculated from these. | |
104 // CHF: cheating for now!!! | |
105 // Universe::set_heap_capacity_at_last_gc(Universe::heap()->capacity()); | |
106 // Universe::set_heap_used_at_last_gc(Universe::heap()->used()); | |
107 | |
108 Threads::gc_epilogue(); | |
109 CodeCache::gc_epilogue(); | |
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
110 JvmtiExport::gc_epilogue(); |
342 | 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 | |
10405 | 126 GCTraceTime tm("phase 1", G1Log::fine() && Verbose, true, gc_timer()); |
342 | 127 GenMarkSweep::trace(" 1"); |
128 | |
129 SharedHeap* sh = SharedHeap::heap(); | |
130 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
131 // 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
|
132 ClassLoaderDataGraph::clear_claimed_marks(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
133 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
134 sh->process_strong_roots(true, // activate StrongRootsScope |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
135 false, // not scavenging. |
342 | 136 SharedHeap::SO_SystemClasses, |
137 &GenMarkSweep::follow_root_closure, | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
138 &GenMarkSweep::follow_code_root_closure, |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
139 &GenMarkSweep::follow_klass_closure); |
342 | 140 |
141 // Process reference objects found during marking | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
358
diff
changeset
|
142 ReferenceProcessor* rp = GenMarkSweep::ref_processor(); |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
143 assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
144 |
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
145 rp->setup_policy(clear_all_softrefs); |
10405 | 146 const ReferenceProcessorStats& stats = |
147 rp->process_discovered_references(&GenMarkSweep::is_alive, | |
148 &GenMarkSweep::keep_alive, | |
149 &GenMarkSweep::follow_stack_closure, | |
150 NULL, | |
151 gc_timer()); | |
152 gc_tracer()->report_gc_reference_stats(stats); | |
342 | 153 |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
154 |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
155 // This is the point where the entire marking should have completed. |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
156 assert(GenMarkSweep::_marking_stack.is_empty(), "Marking should have completed"); |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
157 |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
158 // Unload classes and purge the SystemDictionary. |
342 | 159 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive); |
160 | |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
161 // Unload nmethods. |
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
162 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class); |
342 | 163 |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
164 // Prune dead klasses from subklass/sibling/implementor lists. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
165 Klass::clean_weak_klass_links(&GenMarkSweep::is_alive); |
342 | 166 |
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
12343
diff
changeset
|
167 // Delete entries for dead interned string and clean up unreferenced symbols in symbol table. |
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
12343
diff
changeset
|
168 G1CollectedHeap::heap()->unlink_string_and_symbol_table(&GenMarkSweep::is_alive); |
342 | 169 |
3772
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 Universe::heap()->prepare_for_verify(); |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
174 // 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
|
175 // marked, the previous value of the mark word (including |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
176 // identity hash values, ages, etc) is preserved, and the mark |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
177 // word is set to markOop::marked_value - effectively removing |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
178 // 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
|
179 // used when verifying the dictionaries and so removing them |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
180 // from the mark word can make verification of the dictionaries |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
181 // 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
|
182 // (including hash values) are restored to the appropriate |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
183 // objects. |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
184 if (!VerifySilently) { |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
185 gclog_or_tty->print(" VerifyDuringGC:(full)[Verifying "); |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
186 } |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
187 Universe::heap()->verify(VerifySilently, VerifyOption_G1UseMarkWord); |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
188 if (!VerifySilently) { |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
189 gclog_or_tty->print_cr("]"); |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
190 } |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
191 } |
10405 | 192 |
193 gc_tracer()->report_object_count_after_gc(&GenMarkSweep::is_alive); | |
342 | 194 } |
195 | |
196 class G1PrepareCompactClosure: public HeapRegionClosure { | |
2152 | 197 G1CollectedHeap* _g1h; |
342 | 198 ModRefBarrierSet* _mrbs; |
199 CompactPoint _cp; | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
200 HeapRegionSetCount _humongous_regions_removed; |
342 | 201 |
202 void free_humongous_region(HeapRegion* hr) { | |
203 HeapWord* end = hr->end(); | |
2361 | 204 FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep"); |
205 | |
342 | 206 assert(hr->startsHumongous(), |
207 "Only the start of a humongous region should be freed."); | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
208 |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
209 hr->set_containing_set(NULL); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
210 _humongous_regions_removed.increment(1u, hr->capacity()); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
211 |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
212 _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */); |
342 | 213 hr->prepare_for_compaction(&_cp); |
214 // Also clear the part of the card table that will be unused after | |
215 // compaction. | |
2152 | 216 _mrbs->clear(MemRegion(hr->compaction_top(), end)); |
2361 | 217 dummy_free_list.remove_all(); |
342 | 218 } |
219 | |
220 public: | |
2152 | 221 G1PrepareCompactClosure(CompactibleSpace* cs) |
222 : _g1h(G1CollectedHeap::heap()), | |
12343 | 223 _mrbs(_g1h->g1_barrier_set()), |
342 | 224 _cp(NULL, cs, cs->initialize_threshold()), |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
225 _humongous_regions_removed() { } |
2152 | 226 |
227 void update_sets() { | |
228 // We'll recalculate total used bytes and recreate the free list | |
229 // at the end of the GC, so no point in updating those values here. | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
230 HeapRegionSetCount empty_set; |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
231 _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed); |
2152 | 232 } |
233 | |
342 | 234 bool doHeapRegion(HeapRegion* hr) { |
235 if (hr->isHumongous()) { | |
236 if (hr->startsHumongous()) { | |
237 oop obj = oop(hr->bottom()); | |
238 if (obj->is_gc_marked()) { | |
239 obj->forward_to(obj); | |
240 } else { | |
241 free_humongous_region(hr); | |
242 } | |
243 } else { | |
244 assert(hr->continuesHumongous(), "Invalid humongous."); | |
245 } | |
246 } else { | |
247 hr->prepare_for_compaction(&_cp); | |
248 // Also clear the part of the card table that will be unused after | |
249 // compaction. | |
250 _mrbs->clear(MemRegion(hr->compaction_top(), hr->end())); | |
251 } | |
252 return false; | |
253 } | |
254 }; | |
677 | 255 |
342 | 256 void G1MarkSweep::mark_sweep_phase2() { |
257 // Now all live objects are marked, compute the new object addresses. | |
258 | |
259 // It is not required that we traverse spaces in the same order in | |
260 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
261 // tracking expects us to do so. See comment under phase4. | |
262 | |
263 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
264 | |
10405 | 265 GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer()); |
342 | 266 GenMarkSweep::trace("2"); |
267 | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
268 // find the first region |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
269 HeapRegion* r = g1h->region_at(0); |
342 | 270 CompactibleSpace* sp = r; |
271 if (r->isHumongous() && oop(r->bottom())->is_gc_marked()) { | |
272 sp = r->next_compaction_space(); | |
273 } | |
274 | |
677 | 275 G1PrepareCompactClosure blk(sp); |
342 | 276 g1h->heap_region_iterate(&blk); |
2152 | 277 blk.update_sets(); |
342 | 278 } |
279 | |
280 class G1AdjustPointersClosure: public HeapRegionClosure { | |
281 public: | |
282 bool doHeapRegion(HeapRegion* r) { | |
283 if (r->isHumongous()) { | |
284 if (r->startsHumongous()) { | |
285 // We must adjust the pointers on the single H object. | |
286 oop obj = oop(r->bottom()); | |
287 // point all the oops to the new location | |
288 obj->adjust_pointers(); | |
289 } | |
290 } else { | |
291 // This really ought to be "as_CompactibleSpace"... | |
292 r->adjust_pointers(); | |
293 } | |
294 return false; | |
295 } | |
296 }; | |
297 | |
298 void G1MarkSweep::mark_sweep_phase3() { | |
299 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
300 | |
301 // Adjust the pointers to reflect the new locations | |
10405 | 302 GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer()); |
342 | 303 GenMarkSweep::trace("3"); |
304 | |
305 SharedHeap* sh = SharedHeap::heap(); | |
306 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
307 // 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
|
308 ClassLoaderDataGraph::clear_claimed_marks(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
309 |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
310 sh->process_strong_roots(true, // activate StrongRootsScope |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
311 false, // not scavenging. |
342 | 312 SharedHeap::SO_AllClasses, |
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
313 &GenMarkSweep::adjust_pointer_closure, |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
314 NULL, // do not touch code cache here |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
315 &GenMarkSweep::adjust_klass_closure); |
342 | 316 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
317 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); |
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
318 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure); |
342 | 319 |
320 // Now adjust pointers in remaining weak roots. (All of which should | |
321 // have been cleared if they pointed to non-surviving objects.) | |
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
322 g1h->g1_process_weak_roots(&GenMarkSweep::adjust_pointer_closure); |
342 | 323 |
17764 | 324 if (G1StringDedup::is_enabled()) { |
325 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure); | |
326 } | |
327 | |
342 | 328 GenMarkSweep::adjust_marks(); |
329 | |
330 G1AdjustPointersClosure blk; | |
331 g1h->heap_region_iterate(&blk); | |
332 } | |
333 | |
334 class G1SpaceCompactClosure: public HeapRegionClosure { | |
335 public: | |
336 G1SpaceCompactClosure() {} | |
337 | |
338 bool doHeapRegion(HeapRegion* hr) { | |
339 if (hr->isHumongous()) { | |
340 if (hr->startsHumongous()) { | |
341 oop obj = oop(hr->bottom()); | |
342 if (obj->is_gc_marked()) { | |
343 obj->init_mark(); | |
344 } else { | |
345 assert(hr->is_empty(), "Should have been cleared in phase 2."); | |
346 } | |
347 hr->reset_during_compaction(); | |
348 } | |
349 } else { | |
350 hr->compact(); | |
351 } | |
352 return false; | |
353 } | |
354 }; | |
355 | |
356 void G1MarkSweep::mark_sweep_phase4() { | |
357 // All pointers are now adjusted, move objects accordingly | |
358 | |
359 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
360 // 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
|
361 // here (code and comment not fixed for perm removal), so we tell the validate code |
342 | 362 // to use a higher index (saved from phase2) when verifying perm_gen. |
363 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
364 | |
10405 | 365 GCTraceTime tm("phase 4", G1Log::fine() && Verbose, true, gc_timer()); |
342 | 366 GenMarkSweep::trace("4"); |
367 | |
368 G1SpaceCompactClosure blk; | |
369 g1h->heap_region_iterate(&blk); | |
370 | |
371 } |