Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1MarkSweep.cpp @ 20295:3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
author | tschatzl |
---|---|
date | Mon, 21 Jul 2014 10:00:31 +0200 |
parents | 2c6ef90f030a |
children | d35872270666 |
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 | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
126 GCTraceTime tm("phase 1", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
342 | 127 GenMarkSweep::trace(" 1"); |
128 | |
129 SharedHeap* sh = SharedHeap::heap(); | |
130 | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
131 // Need cleared claim bits for the roots processing |
6725
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 |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
134 MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
135 sh->process_strong_roots(true, // activate StrongRootsScope |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
136 SharedHeap::SO_None, |
342 | 137 &GenMarkSweep::follow_root_closure, |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
138 &GenMarkSweep::follow_cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
139 &follow_code_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, | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
151 gc_timer(), |
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
152 gc_tracer()->gc_id()); |
10405 | 153 gc_tracer()->report_gc_reference_stats(stats); |
342 | 154 |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
155 |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
156 // 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
|
157 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
|
158 |
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
159 // Unload classes and purge the SystemDictionary. |
342 | 160 bool purged_class = SystemDictionary::do_unloading(&GenMarkSweep::is_alive); |
161 | |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
162 // Unload nmethods. |
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
163 CodeCache::do_unloading(&GenMarkSweep::is_alive, purged_class); |
342 | 164 |
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10186
diff
changeset
|
165 // 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
|
166 Klass::clean_weak_klass_links(&GenMarkSweep::is_alive); |
342 | 167 |
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
12343
diff
changeset
|
168 // 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
|
169 G1CollectedHeap::heap()->unlink_string_and_symbol_table(&GenMarkSweep::is_alive); |
342 | 170 |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
171 if (VerifyDuringGC) { |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
172 HandleMark hm; // handle scope |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
173 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact); |
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. |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
185 if (!VerifySilently) { |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
186 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
|
187 } |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
188 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
|
189 if (!VerifySilently) { |
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
10179
diff
changeset
|
190 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
|
191 } |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2361
diff
changeset
|
192 } |
10405 | 193 |
194 gc_tracer()->report_object_count_after_gc(&GenMarkSweep::is_alive); | |
342 | 195 } |
196 | |
197 class G1PrepareCompactClosure: public HeapRegionClosure { | |
2152 | 198 G1CollectedHeap* _g1h; |
342 | 199 ModRefBarrierSet* _mrbs; |
200 CompactPoint _cp; | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
201 HeapRegionSetCount _humongous_regions_removed; |
342 | 202 |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
203 bool is_cp_initialized() const { |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
204 return _cp.space != NULL; |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
205 } |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
206 |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
207 void prepare_for_compaction(HeapRegion* hr, HeapWord* end) { |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
208 // If this is the first live region that we came across which we can compact, |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
209 // initialize the CompactPoint. |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
210 if (!is_cp_initialized()) { |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
211 _cp.space = hr; |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
212 _cp.threshold = hr->initialize_threshold(); |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
213 } |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
214 hr->prepare_for_compaction(&_cp); |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
215 // Also clear the part of the card table that will be unused after |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
216 // compaction. |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
217 _mrbs->clear(MemRegion(hr->compaction_top(), end)); |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
218 } |
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
219 |
342 | 220 void free_humongous_region(HeapRegion* hr) { |
221 HeapWord* end = hr->end(); | |
2361 | 222 FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep"); |
223 | |
342 | 224 assert(hr->startsHumongous(), |
225 "Only the start of a humongous region should be freed."); | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
226 |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
227 hr->set_containing_set(NULL); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
228 _humongous_regions_removed.increment(1u, hr->capacity()); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
229 |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
230 _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */); |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
231 prepare_for_compaction(hr, end); |
2361 | 232 dummy_free_list.remove_all(); |
342 | 233 } |
234 | |
235 public: | |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
236 G1PrepareCompactClosure() |
2152 | 237 : _g1h(G1CollectedHeap::heap()), |
12343 | 238 _mrbs(_g1h->g1_barrier_set()), |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
239 _cp(NULL), |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
240 _humongous_regions_removed() { } |
2152 | 241 |
242 void update_sets() { | |
243 // We'll recalculate total used bytes and recreate the free list | |
244 // 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
|
245 HeapRegionSetCount empty_set; |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
246 _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed); |
2152 | 247 } |
248 | |
342 | 249 bool doHeapRegion(HeapRegion* hr) { |
250 if (hr->isHumongous()) { | |
251 if (hr->startsHumongous()) { | |
252 oop obj = oop(hr->bottom()); | |
253 if (obj->is_gc_marked()) { | |
254 obj->forward_to(obj); | |
255 } else { | |
256 free_humongous_region(hr); | |
257 } | |
258 } else { | |
259 assert(hr->continuesHumongous(), "Invalid humongous."); | |
260 } | |
261 } else { | |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
262 prepare_for_compaction(hr, hr->end()); |
342 | 263 } |
264 return false; | |
265 } | |
266 }; | |
677 | 267 |
342 | 268 void G1MarkSweep::mark_sweep_phase2() { |
269 // Now all live objects are marked, compute the new object addresses. | |
270 | |
271 // It is not required that we traverse spaces in the same order in | |
272 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
273 // tracking expects us to do so. See comment under phase4. | |
274 | |
275 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
276 | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
277 GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
342 | 278 GenMarkSweep::trace("2"); |
279 | |
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20278
diff
changeset
|
280 G1PrepareCompactClosure blk; |
342 | 281 g1h->heap_region_iterate(&blk); |
2152 | 282 blk.update_sets(); |
342 | 283 } |
284 | |
285 class G1AdjustPointersClosure: public HeapRegionClosure { | |
286 public: | |
287 bool doHeapRegion(HeapRegion* r) { | |
288 if (r->isHumongous()) { | |
289 if (r->startsHumongous()) { | |
290 // We must adjust the pointers on the single H object. | |
291 oop obj = oop(r->bottom()); | |
292 // point all the oops to the new location | |
293 obj->adjust_pointers(); | |
294 } | |
295 } else { | |
296 // This really ought to be "as_CompactibleSpace"... | |
297 r->adjust_pointers(); | |
298 } | |
299 return false; | |
300 } | |
301 }; | |
302 | |
303 void G1MarkSweep::mark_sweep_phase3() { | |
304 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
305 | |
306 // Adjust the pointers to reflect the new locations | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
307 GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
342 | 308 GenMarkSweep::trace("3"); |
309 | |
310 SharedHeap* sh = SharedHeap::heap(); | |
311 | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
312 // Need cleared claim bits for the roots processing |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
313 ClassLoaderDataGraph::clear_claimed_marks(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
314 |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
315 CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
316 sh->process_all_roots(true, // activate StrongRootsScope |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
317 SharedHeap::SO_AllCodeCache, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
318 &GenMarkSweep::adjust_pointer_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
319 &GenMarkSweep::adjust_cld_closure, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
320 &adjust_code_closure); |
342 | 321 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
322 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); |
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
323 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure); |
342 | 324 |
325 // Now adjust pointers in remaining weak roots. (All of which should | |
326 // have been cleared if they pointed to non-surviving objects.) | |
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
327 sh->process_weak_roots(&GenMarkSweep::adjust_pointer_closure); |
342 | 328 |
17764 | 329 if (G1StringDedup::is_enabled()) { |
330 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure); | |
331 } | |
332 | |
342 | 333 GenMarkSweep::adjust_marks(); |
334 | |
335 G1AdjustPointersClosure blk; | |
336 g1h->heap_region_iterate(&blk); | |
337 } | |
338 | |
339 class G1SpaceCompactClosure: public HeapRegionClosure { | |
340 public: | |
341 G1SpaceCompactClosure() {} | |
342 | |
343 bool doHeapRegion(HeapRegion* hr) { | |
344 if (hr->isHumongous()) { | |
345 if (hr->startsHumongous()) { | |
346 oop obj = oop(hr->bottom()); | |
347 if (obj->is_gc_marked()) { | |
348 obj->init_mark(); | |
349 } else { | |
350 assert(hr->is_empty(), "Should have been cleared in phase 2."); | |
351 } | |
352 hr->reset_during_compaction(); | |
353 } | |
354 } else { | |
355 hr->compact(); | |
356 } | |
357 return false; | |
358 } | |
359 }; | |
360 | |
361 void G1MarkSweep::mark_sweep_phase4() { | |
362 // All pointers are now adjusted, move objects accordingly | |
363 | |
364 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
365 // 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
|
366 // here (code and comment not fixed for perm removal), so we tell the validate code |
342 | 367 // to use a higher index (saved from phase2) when verifying perm_gen. |
368 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
369 | |
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
370 GCTraceTime tm("phase 4", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
342 | 371 GenMarkSweep::trace("4"); |
372 | |
373 G1SpaceCompactClosure blk; | |
374 g1h->heap_region_iterate(&blk); | |
375 | |
376 } |