Mercurial > hg > truffle
annotate src/share/vm/memory/genMarkSweep.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 2c6ef90f030a |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 10405 | 2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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. |
| 0 | 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" | |
| 10405 | 32 #include "gc_implementation/shared/gcHeapSummary.hpp" |
| 33 #include "gc_implementation/shared/gcTimer.hpp" | |
| 34 #include "gc_implementation/shared/gcTrace.hpp" | |
| 35 #include "gc_implementation/shared/gcTraceTime.hpp" | |
| 1972 | 36 #include "gc_interface/collectedHeap.inline.hpp" |
| 37 #include "memory/genCollectedHeap.hpp" | |
| 38 #include "memory/genMarkSweep.hpp" | |
| 39 #include "memory/genOopClosures.inline.hpp" | |
| 40 #include "memory/generation.inline.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/fprofiler.hpp" | |
| 48 #include "runtime/handles.inline.hpp" | |
| 49 #include "runtime/synchronizer.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6787
diff
changeset
|
50 #include "runtime/thread.inline.hpp" |
| 1972 | 51 #include "runtime/vmThread.hpp" |
| 52 #include "utilities/copy.hpp" | |
| 53 #include "utilities/events.hpp" | |
| 0 | 54 |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
10405
diff
changeset
|
55 void GenMarkSweep::invoke_at_safepoint(int level, ReferenceProcessor* rp, bool clear_all_softrefs) { |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
10405
diff
changeset
|
56 guarantee(level == 1, "We always collect both old and young."); |
| 0 | 57 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); |
| 58 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
59 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
60 #ifdef ASSERT |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
61 if (gch->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
|
62 assert(clear_all_softrefs, "Policy should have been checked earlier"); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
63 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
64 #endif |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
65 |
| 0 | 66 // hook up weak ref data so it can be used during Mark-Sweep |
| 67 assert(ref_processor() == NULL, "no stomping"); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
68 assert(rp != NULL, "should be non-NULL"); |
| 0 | 69 _ref_processor = rp; |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
70 rp->setup_policy(clear_all_softrefs); |
| 0 | 71 |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
72 GCTraceTime t1(GCCauseString("Full GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL, _gc_tracer->gc_id()); |
| 10405 | 73 |
| 74 gch->trace_heap_before_gc(_gc_tracer); | |
| 0 | 75 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
76 // When collecting the permanent generation Method*s may be moving, |
| 0 | 77 // so we either have to flush all bcp data or convert it into bci. |
| 78 CodeCache::gc_prologue(); | |
| 79 Threads::gc_prologue(); | |
| 80 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
81 // Increment the invocation count |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
82 _total_invocations++; |
| 0 | 83 |
| 84 // Capture heap size before collection for printing. | |
| 85 size_t gch_prev_used = gch->used(); | |
| 86 | |
| 87 // Capture used regions for each generation that will be | |
| 88 // subject to collection, so that card table adjustments can | |
| 89 // be made intelligently (see clear / invalidate further below). | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
90 gch->save_used_regions(level); |
| 0 | 91 |
| 92 allocate_stacks(); | |
| 93 | |
| 94 mark_sweep_phase1(level, clear_all_softrefs); | |
| 95 | |
| 96 mark_sweep_phase2(); | |
| 97 | |
| 98 // Don't add any more derived pointers during phase3 | |
| 99 COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity")); | |
| 100 COMPILER2_PRESENT(DerivedPointerTable::set_active(false)); | |
| 101 | |
| 102 mark_sweep_phase3(level); | |
| 103 | |
| 104 mark_sweep_phase4(); | |
| 105 | |
| 106 restore_marks(); | |
| 107 | |
| 108 // Set saved marks for allocation profiler (and other things? -- dld) | |
| 109 // (Should this be in general part?) | |
| 110 gch->save_marks(); | |
| 111 | |
| 112 deallocate_stacks(); | |
| 113 | |
| 114 // If compaction completely evacuated all generations younger than this | |
| 115 // one, then we can clear the card table. Otherwise, we must invalidate | |
| 116 // it (consider all cards dirty). In the future, we might consider doing | |
| 117 // compaction within generations only, and doing card-table sliding. | |
| 118 bool all_empty = true; | |
| 119 for (int i = 0; all_empty && i < level; i++) { | |
| 120 Generation* g = gch->get_gen(i); | |
| 121 all_empty = all_empty && gch->get_gen(i)->used() == 0; | |
| 122 } | |
| 123 GenRemSet* rs = gch->rem_set(); | |
|
12033
bd902affe102
8023021: Unnecessary clearing of the card table introduced by the fix for JDK-8023013
brutisso
parents:
12030
diff
changeset
|
124 Generation* old_gen = gch->get_gen(level); |
| 0 | 125 // Clear/invalidate below make use of the "prev_used_regions" saved earlier. |
| 126 if (all_empty) { | |
| 127 // We've evacuated all generations below us. | |
|
12033
bd902affe102
8023021: Unnecessary clearing of the card table introduced by the fix for JDK-8023013
brutisso
parents:
12030
diff
changeset
|
128 rs->clear_into_younger(old_gen); |
| 0 | 129 } else { |
| 130 // Invalidate the cards corresponding to the currently used | |
|
12033
bd902affe102
8023021: Unnecessary clearing of the card table introduced by the fix for JDK-8023013
brutisso
parents:
12030
diff
changeset
|
131 // region and clear those corresponding to the evacuated region. |
|
bd902affe102
8023021: Unnecessary clearing of the card table introduced by the fix for JDK-8023013
brutisso
parents:
12030
diff
changeset
|
132 rs->invalidate_or_clear(old_gen); |
| 0 | 133 } |
| 134 | |
| 135 Threads::gc_epilogue(); | |
| 136 CodeCache::gc_epilogue(); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
137 JvmtiExport::gc_epilogue(); |
| 0 | 138 |
| 139 if (PrintGC && !PrintGCDetails) { | |
| 140 gch->print_heap_change(gch_prev_used); | |
| 141 } | |
| 142 | |
| 143 // refs processing: clean slate | |
| 144 _ref_processor = NULL; | |
| 145 | |
| 146 // Update heap occupancy information which is used as | |
| 147 // input to soft ref clearing policy at the next gc. | |
| 148 Universe::update_heap_info_at_gc(); | |
| 149 | |
| 150 // Update time of last gc for all generations we collected | |
| 151 // (which curently is all the generations in the heap). | |
| 4911 | 152 // We need to use a monotonically non-deccreasing time in ms |
| 153 // or we will see time-warp warnings and os::javaTimeMillis() | |
| 154 // does not guarantee monotonicity. | |
| 155 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; | |
| 156 gch->update_time_of_last_gc(now); | |
| 10405 | 157 |
| 158 gch->trace_heap_after_gc(_gc_tracer); | |
| 0 | 159 } |
| 160 | |
| 161 void GenMarkSweep::allocate_stacks() { | |
| 162 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 163 // Scratch request on behalf of oldest generation; will do no | |
| 164 // allocation. | |
| 165 ScratchBlock* scratch = gch->gather_scratch(gch->_gens[gch->_n_gens-1], 0); | |
| 166 | |
| 167 // $$$ To cut a corner, we'll only use the first scratch block, and then | |
| 168 // revert to malloc. | |
| 169 if (scratch != NULL) { | |
| 170 _preserved_count_max = | |
| 171 scratch->num_words * HeapWordSize / sizeof(PreservedMark); | |
| 172 } else { | |
| 173 _preserved_count_max = 0; | |
| 174 } | |
| 175 | |
| 176 _preserved_marks = (PreservedMark*)scratch; | |
| 177 _preserved_count = 0; | |
| 178 } | |
| 179 | |
| 180 | |
| 181 void GenMarkSweep::deallocate_stacks() { | |
| 356 | 182 if (!UseG1GC) { |
| 183 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 184 gch->release_scratch(); | |
| 185 } | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
186 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
187 _preserved_mark_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
188 _preserved_oop_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
189 _marking_stack.clear(); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
190 _objarray_stack.clear(true); |
| 0 | 191 } |
| 192 | |
| 193 void GenMarkSweep::mark_sweep_phase1(int level, | |
| 194 bool clear_all_softrefs) { | |
| 195 // Recursively traverse all live objects and mark them | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
196 GCTraceTime tm("phase 1", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id()); |
| 0 | 197 trace(" 1"); |
| 198 | |
| 199 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 200 | |
| 201 // Because follow_root_closure is created statically, cannot | |
| 202 // use OopsInGenClosure constructor which takes a generation, | |
| 203 // as the Universe has not been created when the static constructors | |
| 204 // are run. | |
| 205 follow_root_closure.set_orig_generation(gch->get_gen(level)); | |
| 206 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
207 // Need new claim bits before marking starts. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
208 ClassLoaderDataGraph::clear_claimed_marks(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
209 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
210 gch->gen_process_roots(level, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
211 false, // Younger gens are not roots. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
212 true, // activate StrongRootsScope |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
213 SharedHeap::SO_None, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
214 GenCollectedHeap::StrongRootsOnly, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
215 &follow_root_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
216 &follow_root_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
217 &follow_cld_closure); |
| 0 | 218 |
| 219 // Process reference objects found during marking | |
| 220 { | |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
221 ref_processor()->setup_policy(clear_all_softrefs); |
| 10405 | 222 const ReferenceProcessorStats& stats = |
| 223 ref_processor()->process_discovered_references( | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
224 &is_alive, &keep_alive, &follow_stack_closure, NULL, _gc_timer, _gc_tracer->gc_id()); |
| 10405 | 225 gc_tracer()->report_gc_reference_stats(stats); |
| 0 | 226 } |
| 227 | |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
228 // 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:
10179
diff
changeset
|
229 assert(_marking_stack.is_empty(), "Marking should have completed"); |
|
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
230 |
|
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
231 // Unload classes and purge the SystemDictionary. |
| 0 | 232 bool purged_class = SystemDictionary::do_unloading(&is_alive); |
| 233 | |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
234 // Unload nmethods. |
|
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
235 CodeCache::do_unloading(&is_alive, purged_class); |
| 0 | 236 |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
237 // Prune dead klasses from subklass/sibling/implementor lists. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
238 Klass::clean_weak_klass_links(&is_alive); |
| 941 | 239 |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
240 // Delete entries for dead interned strings. |
| 0 | 241 StringTable::unlink(&is_alive); |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
242 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
243 // Clean up unreferenced symbols in symbol table. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
244 SymbolTable::unlink(); |
| 10405 | 245 |
| 246 gc_tracer()->report_object_count_after_gc(&is_alive); | |
| 0 | 247 } |
| 248 | |
| 249 | |
| 250 void GenMarkSweep::mark_sweep_phase2() { | |
| 251 // Now all live objects are marked, compute the new object addresses. | |
| 252 | |
| 253 // It is imperative that we traverse perm_gen LAST. If dead space is | |
| 254 // allowed a range of dead object may get overwritten by a dead int | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
255 // array. If perm_gen is not traversed last a Klass* may get |
| 0 | 256 // overwritten. This is fine since it is dead, but if the class has dead |
| 257 // instances we have to skip them, and in order to find their size we | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
258 // need the Klass*! |
| 0 | 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 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 265 | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
266 GCTraceTime tm("phase 2", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id()); |
| 0 | 267 trace("2"); |
| 268 | |
| 269 gch->prepare_for_compaction(); | |
| 270 } | |
| 271 | |
| 272 class GenAdjustPointersClosure: public GenCollectedHeap::GenClosure { | |
| 273 public: | |
| 274 void do_generation(Generation* gen) { | |
| 275 gen->adjust_pointers(); | |
| 276 } | |
| 277 }; | |
| 278 | |
| 279 void GenMarkSweep::mark_sweep_phase3(int level) { | |
| 280 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 281 | |
| 282 // Adjust the pointers to reflect the new locations | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
283 GCTraceTime tm("phase 3", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id()); |
| 0 | 284 trace("3"); |
| 285 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
286 // Need new claim bits for the pointer adjustment tracing. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
287 ClassLoaderDataGraph::clear_claimed_marks(); |
| 0 | 288 |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
289 // Because the closure below is created statically, we cannot |
| 0 | 290 // use OopsInGenClosure constructor which takes a generation, |
| 291 // as the Universe has not been created when the static constructors | |
| 292 // are run. | |
| 293 adjust_pointer_closure.set_orig_generation(gch->get_gen(level)); | |
| 294 | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
295 gch->gen_process_roots(level, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
296 false, // Younger gens are not roots. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
297 true, // activate StrongRootsScope |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
298 SharedHeap::SO_AllCodeCache, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
299 GenCollectedHeap::StrongAndWeakRoots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
300 &adjust_pointer_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
301 &adjust_pointer_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20258
diff
changeset
|
302 &adjust_cld_closure); |
| 0 | 303 |
|
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
304 gch->gen_process_weak_roots(&adjust_pointer_closure); |
| 0 | 305 |
| 306 adjust_marks(); | |
| 307 GenAdjustPointersClosure blk; | |
| 308 gch->generation_iterate(&blk, true); | |
| 309 } | |
| 310 | |
| 311 class GenCompactClosure: public GenCollectedHeap::GenClosure { | |
| 312 public: | |
| 313 void do_generation(Generation* gen) { | |
| 314 gen->compact(); | |
| 315 } | |
| 316 }; | |
| 317 | |
| 318 void GenMarkSweep::mark_sweep_phase4() { | |
| 319 // All pointers are now adjusted, move objects accordingly | |
| 320 | |
| 321 // It is imperative that we traverse perm_gen first in phase4. All | |
| 322 // classes must be allocated earlier than their instances, and traversing | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
323 // perm_gen first makes sure that all Klass*s have moved to their new |
| 0 | 324 // location before any instance does a dispatch through it's klass! |
| 325 | |
| 326 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
| 327 // in the same order in phase2, phase3 and phase4. We don't quite do that | |
| 328 // here (perm_gen first rather than last), so we tell the validate code | |
| 329 // to use a higher index (saved from phase2) when verifying perm_gen. | |
| 330 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 331 | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
12033
diff
changeset
|
332 GCTraceTime tm("phase 4", PrintGC && Verbose, true, _gc_timer, _gc_tracer->gc_id()); |
| 0 | 333 trace("4"); |
| 334 | |
| 335 GenCompactClosure blk; | |
| 336 gch->generation_iterate(&blk, true); | |
| 337 } |