Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1MarkSweep.cpp @ 20211:82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
Summary: The test incorrectly assumed that it had been started with no other previous compilation activity. Fix this by allowing multiple code root free chunk lists, and use one separate from the global one to perform the test.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Wed, 16 Apr 2014 10:14:50 +0200 |
| parents | 0982ec23da03 |
| children | 9fec19bb0659 |
| 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 | |
|
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, | |
|
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 |
| 203 void free_humongous_region(HeapRegion* hr) { | |
| 204 HeapWord* end = hr->end(); | |
| 2361 | 205 FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep"); |
| 206 | |
| 342 | 207 assert(hr->startsHumongous(), |
| 208 "Only the start of a humongous region should be freed."); | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
209 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
210 hr->set_containing_set(NULL); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
211 _humongous_regions_removed.increment(1u, hr->capacity()); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
212 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
213 _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */); |
| 342 | 214 hr->prepare_for_compaction(&_cp); |
| 215 // Also clear the part of the card table that will be unused after | |
| 216 // compaction. | |
| 2152 | 217 _mrbs->clear(MemRegion(hr->compaction_top(), end)); |
| 2361 | 218 dummy_free_list.remove_all(); |
| 342 | 219 } |
| 220 | |
| 221 public: | |
| 2152 | 222 G1PrepareCompactClosure(CompactibleSpace* cs) |
| 223 : _g1h(G1CollectedHeap::heap()), | |
| 12343 | 224 _mrbs(_g1h->g1_barrier_set()), |
| 342 | 225 _cp(NULL, cs, cs->initialize_threshold()), |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
226 _humongous_regions_removed() { } |
| 2152 | 227 |
| 228 void update_sets() { | |
| 229 // We'll recalculate total used bytes and recreate the free list | |
| 230 // 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
|
231 HeapRegionSetCount empty_set; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17634
diff
changeset
|
232 _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed); |
| 2152 | 233 } |
| 234 | |
| 342 | 235 bool doHeapRegion(HeapRegion* hr) { |
| 236 if (hr->isHumongous()) { | |
| 237 if (hr->startsHumongous()) { | |
| 238 oop obj = oop(hr->bottom()); | |
| 239 if (obj->is_gc_marked()) { | |
| 240 obj->forward_to(obj); | |
| 241 } else { | |
| 242 free_humongous_region(hr); | |
| 243 } | |
| 244 } else { | |
| 245 assert(hr->continuesHumongous(), "Invalid humongous."); | |
| 246 } | |
| 247 } else { | |
| 248 hr->prepare_for_compaction(&_cp); | |
| 249 // Also clear the part of the card table that will be unused after | |
| 250 // compaction. | |
| 251 _mrbs->clear(MemRegion(hr->compaction_top(), hr->end())); | |
| 252 } | |
| 253 return false; | |
| 254 } | |
| 255 }; | |
| 677 | 256 |
| 342 | 257 void G1MarkSweep::mark_sweep_phase2() { |
| 258 // Now all live objects are marked, compute the new object addresses. | |
| 259 | |
| 260 // It is not required that we traverse spaces in the same order in | |
| 261 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
| 262 // tracking expects us to do so. See comment under phase4. | |
| 263 | |
| 264 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 265 | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
266 GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
| 342 | 267 GenMarkSweep::trace("2"); |
| 268 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
269 // find the first region |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6008
diff
changeset
|
270 HeapRegion* r = g1h->region_at(0); |
| 342 | 271 CompactibleSpace* sp = r; |
| 272 if (r->isHumongous() && oop(r->bottom())->is_gc_marked()) { | |
| 273 sp = r->next_compaction_space(); | |
| 274 } | |
| 275 | |
| 677 | 276 G1PrepareCompactClosure blk(sp); |
| 342 | 277 g1h->heap_region_iterate(&blk); |
| 2152 | 278 blk.update_sets(); |
| 342 | 279 } |
| 280 | |
| 281 class G1AdjustPointersClosure: public HeapRegionClosure { | |
| 282 public: | |
| 283 bool doHeapRegion(HeapRegion* r) { | |
| 284 if (r->isHumongous()) { | |
| 285 if (r->startsHumongous()) { | |
| 286 // We must adjust the pointers on the single H object. | |
| 287 oop obj = oop(r->bottom()); | |
| 288 // point all the oops to the new location | |
| 289 obj->adjust_pointers(); | |
| 290 } | |
| 291 } else { | |
| 292 // This really ought to be "as_CompactibleSpace"... | |
| 293 r->adjust_pointers(); | |
| 294 } | |
| 295 return false; | |
| 296 } | |
| 297 }; | |
| 298 | |
| 299 void G1MarkSweep::mark_sweep_phase3() { | |
| 300 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 301 | |
| 302 // 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
|
303 GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
| 342 | 304 GenMarkSweep::trace("3"); |
| 305 | |
| 306 SharedHeap* sh = SharedHeap::heap(); | |
| 307 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
308 // 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
|
309 ClassLoaderDataGraph::clear_claimed_marks(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
310 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
311 sh->process_strong_roots(true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
312 false, // not scavenging. |
| 342 | 313 SharedHeap::SO_AllClasses, |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
314 &GenMarkSweep::adjust_pointer_closure, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
315 NULL, // do not touch code cache here |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
316 &GenMarkSweep::adjust_klass_closure); |
| 342 | 317 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3772
diff
changeset
|
318 assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
319 g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure); |
| 342 | 320 |
| 321 // Now adjust pointers in remaining weak roots. (All of which should | |
| 322 // 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
|
323 g1h->g1_process_weak_roots(&GenMarkSweep::adjust_pointer_closure); |
| 342 | 324 |
| 17764 | 325 if (G1StringDedup::is_enabled()) { |
| 326 G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure); | |
| 327 } | |
| 328 | |
| 342 | 329 GenMarkSweep::adjust_marks(); |
| 330 | |
| 331 G1AdjustPointersClosure blk; | |
| 332 g1h->heap_region_iterate(&blk); | |
| 333 } | |
| 334 | |
| 335 class G1SpaceCompactClosure: public HeapRegionClosure { | |
| 336 public: | |
| 337 G1SpaceCompactClosure() {} | |
| 338 | |
| 339 bool doHeapRegion(HeapRegion* hr) { | |
| 340 if (hr->isHumongous()) { | |
| 341 if (hr->startsHumongous()) { | |
| 342 oop obj = oop(hr->bottom()); | |
| 343 if (obj->is_gc_marked()) { | |
| 344 obj->init_mark(); | |
| 345 } else { | |
| 346 assert(hr->is_empty(), "Should have been cleared in phase 2."); | |
| 347 } | |
| 348 hr->reset_during_compaction(); | |
| 349 } | |
| 350 } else { | |
| 351 hr->compact(); | |
| 352 } | |
| 353 return false; | |
| 354 } | |
| 355 }; | |
| 356 | |
| 357 void G1MarkSweep::mark_sweep_phase4() { | |
| 358 // All pointers are now adjusted, move objects accordingly | |
| 359 | |
| 360 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
| 361 // 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
|
362 // here (code and comment not fixed for perm removal), so we tell the validate code |
| 342 | 363 // to use a higher index (saved from phase2) when verifying perm_gen. |
| 364 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 365 | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17764
diff
changeset
|
366 GCTraceTime tm("phase 4", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id()); |
| 342 | 367 GenMarkSweep::trace("4"); |
| 368 | |
| 369 G1SpaceCompactClosure blk; | |
| 370 g1h->heap_region_iterate(&blk); | |
| 371 | |
| 372 } |