Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/genMarkSweep.cpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | bd902affe102 |
| children | 870aedf4ba4f 0982ec23da03 |
| 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 |
| 10405 | 72 GCTraceTime t1(GCCauseString("Full GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL); |
| 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 | |
| 10405 | 196 GCTraceTime tm("phase 1", PrintGC && Verbose, true, _gc_timer); |
| 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 |
| 0 | 210 gch->gen_process_strong_roots(level, |
| 211 false, // Younger gens are not roots. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
212 true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
213 false, // not scavenging |
| 0 | 214 SharedHeap::SO_SystemClasses, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
215 &follow_root_closure, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
216 true, // walk code active on stacks |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
217 &follow_root_closure, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
218 &follow_klass_closure); |
| 0 | 219 |
| 220 // Process reference objects found during marking | |
| 221 { | |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
222 ref_processor()->setup_policy(clear_all_softrefs); |
| 10405 | 223 const ReferenceProcessorStats& stats = |
| 224 ref_processor()->process_discovered_references( | |
| 225 &is_alive, &keep_alive, &follow_stack_closure, NULL, _gc_timer); | |
| 226 gc_tracer()->report_gc_reference_stats(stats); | |
| 0 | 227 } |
| 228 | |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
229 // 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
|
230 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
|
231 |
|
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
232 // Unload classes and purge the SystemDictionary. |
| 0 | 233 bool purged_class = SystemDictionary::do_unloading(&is_alive); |
| 234 | |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
235 // Unload nmethods. |
|
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
236 CodeCache::do_unloading(&is_alive, purged_class); |
| 0 | 237 |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
238 // 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
|
239 Klass::clean_weak_klass_links(&is_alive); |
| 941 | 240 |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
241 // Delete entries for dead interned strings. |
| 0 | 242 StringTable::unlink(&is_alive); |
|
10188
2f50bc369470
8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents:
10179
diff
changeset
|
243 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
244 // Clean up unreferenced symbols in symbol table. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
245 SymbolTable::unlink(); |
| 10405 | 246 |
| 247 gc_tracer()->report_object_count_after_gc(&is_alive); | |
| 0 | 248 } |
| 249 | |
| 250 | |
| 251 void GenMarkSweep::mark_sweep_phase2() { | |
| 252 // Now all live objects are marked, compute the new object addresses. | |
| 253 | |
| 254 // It is imperative that we traverse perm_gen LAST. If dead space is | |
| 255 // 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
|
256 // array. If perm_gen is not traversed last a Klass* may get |
| 0 | 257 // overwritten. This is fine since it is dead, but if the class has dead |
| 258 // 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
|
259 // need the Klass*! |
| 0 | 260 // |
| 261 // It is not required that we traverse spaces in the same order in | |
| 262 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
| 263 // tracking expects us to do so. See comment under phase4. | |
| 264 | |
| 265 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 266 | |
| 10405 | 267 GCTraceTime tm("phase 2", PrintGC && Verbose, true, _gc_timer); |
| 0 | 268 trace("2"); |
| 269 | |
| 270 gch->prepare_for_compaction(); | |
| 271 } | |
| 272 | |
| 273 class GenAdjustPointersClosure: public GenCollectedHeap::GenClosure { | |
| 274 public: | |
| 275 void do_generation(Generation* gen) { | |
| 276 gen->adjust_pointers(); | |
| 277 } | |
| 278 }; | |
| 279 | |
| 280 void GenMarkSweep::mark_sweep_phase3(int level) { | |
| 281 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 282 | |
| 283 // Adjust the pointers to reflect the new locations | |
| 10405 | 284 GCTraceTime tm("phase 3", PrintGC && Verbose, true, _gc_timer); |
| 0 | 285 trace("3"); |
| 286 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
287 // 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
|
288 ClassLoaderDataGraph::clear_claimed_marks(); |
| 0 | 289 |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
290 // Because the closure below is created statically, we cannot |
| 0 | 291 // use OopsInGenClosure constructor which takes a generation, |
| 292 // as the Universe has not been created when the static constructors | |
| 293 // are run. | |
| 294 adjust_pointer_closure.set_orig_generation(gch->get_gen(level)); | |
| 295 | |
| 296 gch->gen_process_strong_roots(level, | |
| 297 false, // Younger gens are not roots. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
298 true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
299 false, // not scavenging |
| 0 | 300 SharedHeap::SO_AllClasses, |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
301 &adjust_pointer_closure, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
302 false, // do not walk code |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
303 &adjust_pointer_closure, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
304 &adjust_klass_closure); |
| 0 | 305 |
| 306 // Now adjust pointers in remaining weak roots. (All of which should | |
| 307 // have been cleared if they pointed to non-surviving objects.) | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
308 CodeBlobToOopClosure adjust_code_pointer_closure(&adjust_pointer_closure, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
457
diff
changeset
|
309 /*do_marking=*/ false); |
|
10179
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
310 gch->gen_process_weak_roots(&adjust_pointer_closure, |
|
a08c80e9e1e5
8012687: Remove unused is_root checks and closures
stefank
parents:
7448
diff
changeset
|
311 &adjust_code_pointer_closure); |
| 0 | 312 |
| 313 adjust_marks(); | |
| 314 GenAdjustPointersClosure blk; | |
| 315 gch->generation_iterate(&blk, true); | |
| 316 } | |
| 317 | |
| 318 class GenCompactClosure: public GenCollectedHeap::GenClosure { | |
| 319 public: | |
| 320 void do_generation(Generation* gen) { | |
| 321 gen->compact(); | |
| 322 } | |
| 323 }; | |
| 324 | |
| 325 void GenMarkSweep::mark_sweep_phase4() { | |
| 326 // All pointers are now adjusted, move objects accordingly | |
| 327 | |
| 328 // It is imperative that we traverse perm_gen first in phase4. All | |
| 329 // 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
|
330 // perm_gen first makes sure that all Klass*s have moved to their new |
| 0 | 331 // location before any instance does a dispatch through it's klass! |
| 332 | |
| 333 // The ValidateMarkSweep live oops tracking expects us to traverse spaces | |
| 334 // in the same order in phase2, phase3 and phase4. We don't quite do that | |
| 335 // here (perm_gen first rather than last), so we tell the validate code | |
| 336 // to use a higher index (saved from phase2) when verifying perm_gen. | |
| 337 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 338 | |
| 10405 | 339 GCTraceTime tm("phase 4", PrintGC && Verbose, true, _gc_timer); |
| 0 | 340 trace("4"); |
| 341 | |
| 342 GenCompactClosure blk; | |
| 343 gch->generation_iterate(&blk, true); | |
| 344 } |