Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp @ 3772:6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps.
Reviewed-by: tonyp, ysr
| author | johnc |
|---|---|
| date | Tue, 14 Jun 2011 11:01:10 -0700 |
| parents | 78542e2b5e35 |
| children | c2bf0120ee5d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2177
diff
changeset
|
2 * Copyright (c) 2001, 2011, 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/symbolTable.hpp" | |
| 27 #include "classfile/systemDictionary.hpp" | |
| 28 #include "code/codeCache.hpp" | |
| 29 #include "gc_implementation/parallelScavenge/generationSizer.hpp" | |
| 30 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
| 31 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp" | |
| 32 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp" | |
| 33 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp" | |
| 34 #include "gc_implementation/parallelScavenge/psOldGen.hpp" | |
| 35 #include "gc_implementation/parallelScavenge/psPermGen.hpp" | |
| 36 #include "gc_implementation/parallelScavenge/psScavenge.hpp" | |
| 37 #include "gc_implementation/parallelScavenge/psYoungGen.hpp" | |
| 38 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 39 #include "gc_implementation/shared/spaceDecorator.hpp" | |
| 40 #include "gc_interface/gcCause.hpp" | |
| 41 #include "memory/gcLocker.inline.hpp" | |
| 42 #include "memory/referencePolicy.hpp" | |
| 43 #include "memory/referenceProcessor.hpp" | |
| 44 #include "oops/oop.inline.hpp" | |
| 45 #include "runtime/biasedLocking.hpp" | |
| 46 #include "runtime/fprofiler.hpp" | |
| 47 #include "runtime/safepoint.hpp" | |
| 48 #include "runtime/vmThread.hpp" | |
| 49 #include "services/management.hpp" | |
| 50 #include "services/memoryService.hpp" | |
| 51 #include "utilities/events.hpp" | |
| 52 #include "utilities/stack.inline.hpp" | |
| 0 | 53 |
| 54 elapsedTimer PSMarkSweep::_accumulated_time; | |
| 55 unsigned int PSMarkSweep::_total_invocations = 0; | |
| 56 jlong PSMarkSweep::_time_of_last_gc = 0; | |
| 57 CollectorCounters* PSMarkSweep::_counters = NULL; | |
| 58 | |
| 59 void PSMarkSweep::initialize() { | |
| 60 MemRegion mr = Universe::heap()->reserved_region(); | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2177
diff
changeset
|
61 _ref_processor = new ReferenceProcessor(mr); // a vanilla ref proc |
|
374
a4b729f5b611
6716466: par compact - remove VerifyParallelOldWithMarkSweep code
jcoomes
parents:
263
diff
changeset
|
62 _counters = new CollectorCounters("PSMarkSweep", 1); |
| 0 | 63 } |
| 64 | |
| 65 // This method contains all heap specific policy for invoking mark sweep. | |
| 66 // PSMarkSweep::invoke_no_policy() will only attempt to mark-sweep-compact | |
| 67 // the heap. It will do nothing further. If we need to bail out for policy | |
| 68 // reasons, scavenge before full gc, or any other specialized behavior, it | |
| 69 // needs to be added here. | |
| 70 // | |
| 71 // Note that this method should only be called from the vm_thread while | |
| 72 // at a safepoint! | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
73 // |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
74 // Note that the all_soft_refs_clear flag in the collector policy |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
75 // may be true because this method can be called without intervening |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
76 // activity. For example when the heap space is tight and full measure |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
77 // are being taken to free space. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
78 |
| 0 | 79 void PSMarkSweep::invoke(bool maximum_heap_compaction) { |
| 80 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); | |
| 81 assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); | |
| 82 assert(!Universe::heap()->is_gc_active(), "not reentrant"); | |
| 83 | |
| 84 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 85 GCCause::Cause gc_cause = heap->gc_cause(); | |
| 86 PSAdaptiveSizePolicy* policy = heap->size_policy(); | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
87 IsGCActiveMark mark; |
| 0 | 88 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
89 if (ScavengeBeforeFullGC) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
90 PSScavenge::invoke_no_policy(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
91 } |
| 0 | 92 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
93 const bool clear_all_soft_refs = |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
94 heap->collector_policy()->should_clear_all_soft_refs(); |
| 0 | 95 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
96 int count = (maximum_heap_compaction)?1:MarkSweepAlwaysCompactCount; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
97 IntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
98 PSMarkSweep::invoke_no_policy(clear_all_soft_refs || maximum_heap_compaction); |
| 0 | 99 } |
| 100 | |
| 101 // This method contains no policy. You should probably | |
| 102 // be calling invoke() instead. | |
| 103 void PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) { | |
| 104 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); | |
| 105 assert(ref_processor() != NULL, "Sanity"); | |
| 106 | |
| 107 if (GC_locker::check_active_before_gc()) { | |
| 108 return; | |
| 109 } | |
| 110 | |
| 111 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 112 GCCause::Cause gc_cause = heap->gc_cause(); | |
| 113 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 114 PSAdaptiveSizePolicy* size_policy = heap->size_policy(); | |
| 115 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
116 // The scope of casr should end after code that can change |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
117 // CollectorPolicy::_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
|
118 ClearedAllSoftRefs casr(clear_all_softrefs, heap->collector_policy()); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
119 |
| 0 | 120 PSYoungGen* young_gen = heap->young_gen(); |
| 121 PSOldGen* old_gen = heap->old_gen(); | |
| 122 PSPermGen* perm_gen = heap->perm_gen(); | |
| 123 | |
| 124 // Increment the invocation count | |
| 125 heap->increment_total_collections(true /* full */); | |
| 126 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
127 // Save information needed to minimize mangling |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
128 heap->record_gen_tops_before_GC(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
129 |
| 0 | 130 // We need to track unique mark sweep invocations as well. |
| 131 _total_invocations++; | |
| 132 | |
| 133 AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); | |
| 134 | |
| 135 if (PrintHeapAtGC) { | |
| 136 Universe::print_heap_before_gc(); | |
| 137 } | |
| 138 | |
| 139 // Fill in TLABs | |
| 140 heap->accumulate_statistics_all_tlabs(); | |
| 141 heap->ensure_parsability(true); // retire TLABs | |
| 142 | |
| 143 if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { | |
| 144 HandleMark hm; // Discard invalid handles created during verification | |
| 145 gclog_or_tty->print(" VerifyBeforeGC:"); | |
| 146 Universe::verify(true); | |
| 147 } | |
| 148 | |
| 149 // Verify object start arrays | |
| 150 if (VerifyObjectStartArray && | |
| 151 VerifyBeforeGC) { | |
| 152 old_gen->verify_object_start_array(); | |
| 153 perm_gen->verify_object_start_array(); | |
| 154 } | |
| 155 | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
156 heap->pre_full_gc_dump(); |
|
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
157 |
| 0 | 158 // Filled in below to track the state of the young gen after the collection. |
| 159 bool eden_empty; | |
| 160 bool survivors_empty; | |
| 161 bool young_gen_empty; | |
| 162 | |
| 163 { | |
| 164 HandleMark hm; | |
| 165 const bool is_system_gc = gc_cause == GCCause::_java_lang_system_gc; | |
| 166 // This is useful for debugging but don't change the output the | |
| 167 // the customer sees. | |
| 168 const char* gc_cause_str = "Full GC"; | |
| 169 if (is_system_gc && PrintGCDetails) { | |
| 170 gc_cause_str = "Full GC (System)"; | |
| 171 } | |
| 172 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); | |
| 173 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 174 TraceTime t1(gc_cause_str, PrintGC, !PrintGCDetails, gclog_or_tty); | |
| 175 TraceCollectorStats tcs(counters()); | |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2369
diff
changeset
|
176 TraceMemoryManagerStats tms(true /* Full GC */,gc_cause); |
| 0 | 177 |
| 178 if (TraceGen1Time) accumulated_time()->start(); | |
| 179 | |
| 180 // Let the size policy know we're starting | |
| 181 size_policy->major_collection_begin(); | |
| 182 | |
| 183 // When collecting the permanent generation methodOops may be moving, | |
| 184 // so we either have to flush all bcp data or convert it into bci. | |
| 185 CodeCache::gc_prologue(); | |
| 186 Threads::gc_prologue(); | |
| 187 BiasedLocking::preserve_marks(); | |
| 188 | |
| 189 // Capture heap size before collection for printing. | |
| 190 size_t prev_used = heap->used(); | |
| 191 | |
| 192 // Capture perm gen size before collection for sizing. | |
| 193 size_t perm_gen_prev_used = perm_gen->used_in_bytes(); | |
| 194 | |
| 195 // For PrintGCDetails | |
| 196 size_t old_gen_prev_used = old_gen->used_in_bytes(); | |
| 197 size_t young_gen_prev_used = young_gen->used_in_bytes(); | |
| 198 | |
| 199 allocate_stacks(); | |
| 200 | |
| 201 NOT_PRODUCT(ref_processor()->verify_no_references_recorded()); | |
| 202 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
| 203 | |
| 204 ref_processor()->enable_discovery(); | |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
205 ref_processor()->setup_policy(clear_all_softrefs); |
| 0 | 206 |
| 207 mark_sweep_phase1(clear_all_softrefs); | |
| 208 | |
| 209 mark_sweep_phase2(); | |
| 210 | |
| 211 // Don't add any more derived pointers during phase3 | |
| 212 COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity")); | |
| 213 COMPILER2_PRESENT(DerivedPointerTable::set_active(false)); | |
| 214 | |
| 215 mark_sweep_phase3(); | |
| 216 | |
| 217 mark_sweep_phase4(); | |
| 218 | |
| 219 restore_marks(); | |
| 220 | |
| 221 deallocate_stacks(); | |
| 222 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
223 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
224 // Do a complete mangle (top to end) because the usage for |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
225 // scratch does not maintain a top pointer. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
226 young_gen->to_space()->mangle_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
227 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
228 |
| 0 | 229 eden_empty = young_gen->eden_space()->is_empty(); |
| 230 if (!eden_empty) { | |
| 231 eden_empty = absorb_live_data_from_eden(size_policy, young_gen, old_gen); | |
| 232 } | |
| 233 | |
| 234 // Update heap occupancy information which is used as | |
| 235 // input to soft ref clearing policy at the next gc. | |
| 236 Universe::update_heap_info_at_gc(); | |
| 237 | |
| 238 survivors_empty = young_gen->from_space()->is_empty() && | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
239 young_gen->to_space()->is_empty(); |
| 0 | 240 young_gen_empty = eden_empty && survivors_empty; |
| 241 | |
| 242 BarrierSet* bs = heap->barrier_set(); | |
| 243 if (bs->is_a(BarrierSet::ModRef)) { | |
| 244 ModRefBarrierSet* modBS = (ModRefBarrierSet*)bs; | |
| 245 MemRegion old_mr = heap->old_gen()->reserved(); | |
| 246 MemRegion perm_mr = heap->perm_gen()->reserved(); | |
| 247 assert(perm_mr.end() <= old_mr.start(), "Generations out of order"); | |
| 248 | |
| 249 if (young_gen_empty) { | |
| 250 modBS->clear(MemRegion(perm_mr.start(), old_mr.end())); | |
| 251 } else { | |
| 252 modBS->invalidate(MemRegion(perm_mr.start(), old_mr.end())); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 BiasedLocking::restore_marks(); | |
| 257 Threads::gc_epilogue(); | |
| 258 CodeCache::gc_epilogue(); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
259 JvmtiExport::gc_epilogue(); |
| 0 | 260 |
| 261 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
| 262 | |
| 263 ref_processor()->enqueue_discovered_references(NULL); | |
| 264 | |
| 265 // Update time of last GC | |
| 266 reset_millis_since_last_gc(); | |
| 267 | |
| 268 // Let the size policy know we're done | |
| 269 size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause); | |
| 270 | |
| 271 if (UseAdaptiveSizePolicy) { | |
| 272 | |
| 273 if (PrintAdaptiveSizePolicy) { | |
| 274 gclog_or_tty->print("AdaptiveSizeStart: "); | |
| 275 gclog_or_tty->stamp(); | |
| 276 gclog_or_tty->print_cr(" collection: %d ", | |
| 277 heap->total_collections()); | |
| 278 if (Verbose) { | |
| 279 gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d" | |
| 280 " perm_gen_capacity: %d ", | |
| 281 old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(), | |
| 282 perm_gen->capacity_in_bytes()); | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 // Don't check if the size_policy is ready here. Let | |
| 287 // the size_policy check that internally. | |
| 288 if (UseAdaptiveGenerationSizePolicyAtMajorCollection && | |
| 289 ((gc_cause != GCCause::_java_lang_system_gc) || | |
| 290 UseAdaptiveSizePolicyWithSystemGC)) { | |
| 291 // Calculate optimal free space amounts | |
| 292 assert(young_gen->max_size() > | |
| 293 young_gen->from_space()->capacity_in_bytes() + | |
| 294 young_gen->to_space()->capacity_in_bytes(), | |
| 295 "Sizes of space in young gen are out-of-bounds"); | |
| 296 size_t max_eden_size = young_gen->max_size() - | |
| 297 young_gen->from_space()->capacity_in_bytes() - | |
| 298 young_gen->to_space()->capacity_in_bytes(); | |
| 299 size_policy->compute_generation_free_space(young_gen->used_in_bytes(), | |
| 300 young_gen->eden_space()->used_in_bytes(), | |
| 301 old_gen->used_in_bytes(), | |
| 302 perm_gen->used_in_bytes(), | |
| 303 young_gen->eden_space()->capacity_in_bytes(), | |
| 304 old_gen->max_gen_size(), | |
| 305 max_eden_size, | |
| 306 true /* full gc*/, | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
307 gc_cause, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1311
diff
changeset
|
308 heap->collector_policy()); |
| 0 | 309 |
| 310 heap->resize_old_gen(size_policy->calculated_old_free_size_in_bytes()); | |
| 311 | |
| 312 // Don't resize the young generation at an major collection. A | |
| 313 // desired young generation size may have been calculated but | |
| 314 // resizing the young generation complicates the code because the | |
| 315 // resizing of the old generation may have moved the boundary | |
| 316 // between the young generation and the old generation. Let the | |
| 317 // young generation resizing happen at the minor collections. | |
| 318 } | |
| 319 if (PrintAdaptiveSizePolicy) { | |
| 320 gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", | |
| 321 heap->total_collections()); | |
| 322 } | |
| 323 } | |
| 324 | |
| 325 if (UsePerfData) { | |
| 326 heap->gc_policy_counters()->update_counters(); | |
| 327 heap->gc_policy_counters()->update_old_capacity( | |
| 328 old_gen->capacity_in_bytes()); | |
| 329 heap->gc_policy_counters()->update_young_capacity( | |
| 330 young_gen->capacity_in_bytes()); | |
| 331 } | |
| 332 | |
| 333 heap->resize_all_tlabs(); | |
| 334 | |
| 335 // We collected the perm gen, so we'll resize it here. | |
| 336 perm_gen->compute_new_size(perm_gen_prev_used); | |
| 337 | |
| 338 if (TraceGen1Time) accumulated_time()->stop(); | |
| 339 | |
| 340 if (PrintGC) { | |
| 341 if (PrintGCDetails) { | |
| 342 // Don't print a GC timestamp here. This is after the GC so | |
| 343 // would be confusing. | |
| 344 young_gen->print_used_change(young_gen_prev_used); | |
| 345 old_gen->print_used_change(old_gen_prev_used); | |
| 346 } | |
| 347 heap->print_heap_change(prev_used); | |
| 348 // Do perm gen after heap becase prev_used does | |
| 349 // not include the perm gen (done this way in the other | |
| 350 // collectors). | |
| 351 if (PrintGCDetails) { | |
| 352 perm_gen->print_used_change(perm_gen_prev_used); | |
| 353 } | |
| 354 } | |
| 355 | |
| 356 // Track memory usage and detect low memory | |
| 357 MemoryService::track_memory_usage(); | |
| 358 heap->update_counters(); | |
| 359 } | |
| 360 | |
| 361 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { | |
| 362 HandleMark hm; // Discard invalid handles created during verification | |
| 363 gclog_or_tty->print(" VerifyAfterGC:"); | |
| 364 Universe::verify(false); | |
| 365 } | |
| 366 | |
| 367 // Re-verify object start arrays | |
| 368 if (VerifyObjectStartArray && | |
| 369 VerifyAfterGC) { | |
| 370 old_gen->verify_object_start_array(); | |
| 371 perm_gen->verify_object_start_array(); | |
| 372 } | |
| 373 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
374 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
375 old_gen->object_space()->check_mangled_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
376 perm_gen->object_space()->check_mangled_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
377 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
0
diff
changeset
|
378 |
| 0 | 379 NOT_PRODUCT(ref_processor()->verify_no_references_recorded()); |
| 380 | |
| 381 if (PrintHeapAtGC) { | |
| 382 Universe::print_heap_after_gc(); | |
| 383 } | |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
481
diff
changeset
|
384 |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
385 heap->post_full_gc_dump(); |
|
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
546
diff
changeset
|
386 |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
481
diff
changeset
|
387 #ifdef TRACESPINNING |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
481
diff
changeset
|
388 ParallelTaskTerminator::print_termination_counts(); |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
481
diff
changeset
|
389 #endif |
| 0 | 390 } |
| 391 | |
| 392 bool PSMarkSweep::absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy, | |
| 393 PSYoungGen* young_gen, | |
| 394 PSOldGen* old_gen) { | |
| 395 MutableSpace* const eden_space = young_gen->eden_space(); | |
| 396 assert(!eden_space->is_empty(), "eden must be non-empty"); | |
| 397 assert(young_gen->virtual_space()->alignment() == | |
| 398 old_gen->virtual_space()->alignment(), "alignments do not match"); | |
| 399 | |
| 400 if (!(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary)) { | |
| 401 return false; | |
| 402 } | |
| 403 | |
| 404 // Both generations must be completely committed. | |
| 405 if (young_gen->virtual_space()->uncommitted_size() != 0) { | |
| 406 return false; | |
| 407 } | |
| 408 if (old_gen->virtual_space()->uncommitted_size() != 0) { | |
| 409 return false; | |
| 410 } | |
| 411 | |
| 412 // Figure out how much to take from eden. Include the average amount promoted | |
| 413 // in the total; otherwise the next young gen GC will simply bail out to a | |
| 414 // full GC. | |
| 415 const size_t alignment = old_gen->virtual_space()->alignment(); | |
| 416 const size_t eden_used = eden_space->used_in_bytes(); | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
417 const size_t promoted = (size_t)size_policy->avg_promoted()->padded_average(); |
| 0 | 418 const size_t absorb_size = align_size_up(eden_used + promoted, alignment); |
| 419 const size_t eden_capacity = eden_space->capacity_in_bytes(); | |
| 420 | |
| 421 if (absorb_size >= eden_capacity) { | |
| 422 return false; // Must leave some space in eden. | |
| 423 } | |
| 424 | |
| 425 const size_t new_young_size = young_gen->capacity_in_bytes() - absorb_size; | |
| 426 if (new_young_size < young_gen->min_gen_size()) { | |
| 427 return false; // Respect young gen minimum size. | |
| 428 } | |
| 429 | |
| 430 if (TraceAdaptiveGCBoundary && Verbose) { | |
| 431 gclog_or_tty->print(" absorbing " SIZE_FORMAT "K: " | |
| 432 "eden " SIZE_FORMAT "K->" SIZE_FORMAT "K " | |
| 433 "from " SIZE_FORMAT "K, to " SIZE_FORMAT "K " | |
| 434 "young_gen " SIZE_FORMAT "K->" SIZE_FORMAT "K ", | |
| 435 absorb_size / K, | |
| 436 eden_capacity / K, (eden_capacity - absorb_size) / K, | |
| 437 young_gen->from_space()->used_in_bytes() / K, | |
| 438 young_gen->to_space()->used_in_bytes() / K, | |
| 439 young_gen->capacity_in_bytes() / K, new_young_size / K); | |
| 440 } | |
| 441 | |
| 442 // Fill the unused part of the old gen. | |
| 443 MutableSpace* const old_space = old_gen->object_space(); | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
444 HeapWord* const unused_start = old_space->top(); |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
445 size_t const unused_words = pointer_delta(old_space->end(), unused_start); |
| 0 | 446 |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
447 if (unused_words > 0) { |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
448 if (unused_words < CollectedHeap::min_fill_size()) { |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
449 return false; // If the old gen cannot be filled, must give up. |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
450 } |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
451 CollectedHeap::fill_with_objects(unused_start, unused_words); |
| 0 | 452 } |
| 453 | |
| 454 // Take the live data from eden and set both top and end in the old gen to | |
| 455 // eden top. (Need to set end because reset_after_change() mangles the region | |
| 456 // from end to virtual_space->high() in debug builds). | |
| 457 HeapWord* const new_top = eden_space->top(); | |
| 458 old_gen->virtual_space()->expand_into(young_gen->virtual_space(), | |
| 459 absorb_size); | |
| 460 young_gen->reset_after_change(); | |
| 461 old_space->set_top(new_top); | |
| 462 old_space->set_end(new_top); | |
| 463 old_gen->reset_after_change(); | |
| 464 | |
| 465 // Update the object start array for the filler object and the data from eden. | |
| 466 ObjectStartArray* const start_array = old_gen->start_array(); | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
467 for (HeapWord* p = unused_start; p < new_top; p += oop(p)->size()) { |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
468 start_array->allocate_block(p); |
| 0 | 469 } |
| 470 | |
| 471 // Could update the promoted average here, but it is not typically updated at | |
| 472 // full GCs and the value to use is unclear. Something like | |
| 473 // | |
| 474 // cur_promoted_avg + absorb_size / number_of_scavenges_since_last_full_gc. | |
| 475 | |
| 476 size_policy->set_bytes_absorbed_from_eden(absorb_size); | |
| 477 return true; | |
| 478 } | |
| 479 | |
| 480 void PSMarkSweep::allocate_stacks() { | |
| 481 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 482 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 483 | |
| 484 PSYoungGen* young_gen = heap->young_gen(); | |
| 485 | |
| 486 MutableSpace* to_space = young_gen->to_space(); | |
| 487 _preserved_marks = (PreservedMark*)to_space->top(); | |
| 488 _preserved_count = 0; | |
| 489 | |
| 490 // We want to calculate the size in bytes first. | |
| 491 _preserved_count_max = pointer_delta(to_space->end(), to_space->top(), sizeof(jbyte)); | |
| 492 // Now divide by the size of a PreservedMark | |
| 493 _preserved_count_max /= sizeof(PreservedMark); | |
| 494 } | |
| 495 | |
| 496 | |
| 497 void PSMarkSweep::deallocate_stacks() { | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
498 _preserved_mark_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
499 _preserved_oop_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
500 _marking_stack.clear(); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
501 _objarray_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
502 _revisit_klass_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
503 _revisit_mdo_stack.clear(true); |
| 0 | 504 } |
| 505 | |
| 506 void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) { | |
| 507 // Recursively traverse all live objects and mark them | |
| 508 EventMark m("1 mark object"); | |
| 509 TraceTime tm("phase 1", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 510 trace(" 1"); | |
| 511 | |
| 512 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 513 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 514 | |
| 515 // General strong roots. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
516 { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
517 ParallelScavengeHeap::ParStrongRootsScope psrs; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
518 Universe::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
519 ReferenceProcessor::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
520 JNIHandles::oops_do(mark_and_push_closure()); // Global (strong) JNI handles |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
521 CodeBlobToOopClosure each_active_code_blob(mark_and_push_closure(), /*do_marking=*/ true); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
522 Threads::oops_do(mark_and_push_closure(), &each_active_code_blob); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
523 ObjectSynchronizer::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
524 FlatProfiler::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
525 Management::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
526 JvmtiExport::oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
527 SystemDictionary::always_strong_oops_do(mark_and_push_closure()); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
528 // Do not treat nmethods as strong roots for mark/sweep, since we can unload them. |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
529 //CodeCache::scavenge_root_nmethods_do(CodeBlobToOopClosure(mark_and_push_closure())); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
530 } |
| 0 | 531 |
| 532 // Flush marking stack. | |
| 533 follow_stack(); | |
| 534 | |
| 535 // Process reference objects found during marking | |
| 536 { | |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
537 ref_processor()->setup_policy(clear_all_softrefs); |
| 0 | 538 ref_processor()->process_discovered_references( |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
380
diff
changeset
|
539 is_alive_closure(), mark_and_push_closure(), follow_stack_closure(), NULL); |
| 0 | 540 } |
| 541 | |
| 542 // Follow system dictionary roots and unload classes | |
| 543 bool purged_class = SystemDictionary::do_unloading(is_alive_closure()); | |
| 544 | |
| 545 // Follow code cache roots | |
| 546 CodeCache::do_unloading(is_alive_closure(), mark_and_push_closure(), | |
| 547 purged_class); | |
| 548 follow_stack(); // Flush marking stack | |
| 549 | |
| 550 // Update subklass/sibling/implementor links of live klasses | |
| 551 follow_weak_klass_links(); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
552 assert(_marking_stack.is_empty(), "just drained"); |
| 0 | 553 |
| 941 | 554 // Visit memoized mdo's and clear unmarked weak refs |
| 555 follow_mdo_weak_refs(); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
556 assert(_marking_stack.is_empty(), "just drained"); |
| 941 | 557 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
558 // Visit interned string tables and delete unmarked oops |
| 0 | 559 StringTable::unlink(is_alive_closure()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
560 // Clean up unreferenced symbols in symbol table. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
561 SymbolTable::unlink(); |
| 0 | 562 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1552
diff
changeset
|
563 assert(_marking_stack.is_empty(), "stack should be empty by now"); |
| 0 | 564 } |
| 565 | |
| 566 | |
| 567 void PSMarkSweep::mark_sweep_phase2() { | |
| 568 EventMark m("2 compute new addresses"); | |
| 569 TraceTime tm("phase 2", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 570 trace("2"); | |
| 571 | |
| 572 // Now all live objects are marked, compute the new object addresses. | |
| 573 | |
| 574 // It is imperative that we traverse perm_gen LAST. If dead space is | |
| 575 // allowed a range of dead object may get overwritten by a dead int | |
| 576 // array. If perm_gen is not traversed last a klassOop may get | |
| 577 // overwritten. This is fine since it is dead, but if the class has dead | |
| 578 // instances we have to skip them, and in order to find their size we | |
| 579 // need the klassOop! | |
| 580 // | |
| 581 // It is not required that we traverse spaces in the same order in | |
| 582 // phase2, phase3 and phase4, but the ValidateMarkSweep live oops | |
| 583 // tracking expects us to do so. See comment under phase4. | |
| 584 | |
| 585 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 586 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 587 | |
| 588 PSOldGen* old_gen = heap->old_gen(); | |
| 589 PSPermGen* perm_gen = heap->perm_gen(); | |
| 590 | |
| 591 // Begin compacting into the old gen | |
| 592 PSMarkSweepDecorator::set_destination_decorator_tenured(); | |
| 593 | |
| 594 // This will also compact the young gen spaces. | |
| 595 old_gen->precompact(); | |
| 596 | |
| 597 // Compact the perm gen into the perm gen | |
| 598 PSMarkSweepDecorator::set_destination_decorator_perm_gen(); | |
| 599 | |
| 600 perm_gen->precompact(); | |
| 601 } | |
| 602 | |
| 603 // This should be moved to the shared markSweep code! | |
| 604 class PSAlwaysTrueClosure: public BoolObjectClosure { | |
| 605 public: | |
| 606 void do_object(oop p) { ShouldNotReachHere(); } | |
| 607 bool do_object_b(oop p) { return true; } | |
| 608 }; | |
| 609 static PSAlwaysTrueClosure always_true; | |
| 610 | |
| 611 void PSMarkSweep::mark_sweep_phase3() { | |
| 612 // Adjust the pointers to reflect the new locations | |
| 613 EventMark m("3 adjust pointers"); | |
| 614 TraceTime tm("phase 3", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 615 trace("3"); | |
| 616 | |
| 617 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 618 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 619 | |
| 620 PSYoungGen* young_gen = heap->young_gen(); | |
| 621 PSOldGen* old_gen = heap->old_gen(); | |
| 622 PSPermGen* perm_gen = heap->perm_gen(); | |
| 623 | |
| 624 // General strong roots. | |
| 625 Universe::oops_do(adjust_root_pointer_closure()); | |
| 626 ReferenceProcessor::oops_do(adjust_root_pointer_closure()); | |
| 627 JNIHandles::oops_do(adjust_root_pointer_closure()); // Global (strong) JNI handles | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
628 Threads::oops_do(adjust_root_pointer_closure(), NULL); |
| 0 | 629 ObjectSynchronizer::oops_do(adjust_root_pointer_closure()); |
| 630 FlatProfiler::oops_do(adjust_root_pointer_closure()); | |
| 631 Management::oops_do(adjust_root_pointer_closure()); | |
| 632 JvmtiExport::oops_do(adjust_root_pointer_closure()); | |
| 633 // SO_AllClasses | |
| 634 SystemDictionary::oops_do(adjust_root_pointer_closure()); | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
628
diff
changeset
|
635 //CodeCache::scavenge_root_nmethods_oops_do(adjust_root_pointer_closure()); |
| 0 | 636 |
| 637 // Now adjust pointers in remaining weak roots. (All of which should | |
| 638 // have been cleared if they pointed to non-surviving objects.) | |
| 639 // Global (weak) JNI handles | |
| 640 JNIHandles::weak_oops_do(&always_true, adjust_root_pointer_closure()); | |
| 641 | |
| 642 CodeCache::oops_do(adjust_pointer_closure()); | |
| 643 StringTable::oops_do(adjust_root_pointer_closure()); | |
| 644 ref_processor()->weak_oops_do(adjust_root_pointer_closure()); | |
| 645 PSScavenge::reference_processor()->weak_oops_do(adjust_root_pointer_closure()); | |
| 646 | |
| 647 adjust_marks(); | |
| 648 | |
| 649 young_gen->adjust_pointers(); | |
| 650 old_gen->adjust_pointers(); | |
| 651 perm_gen->adjust_pointers(); | |
| 652 } | |
| 653 | |
| 654 void PSMarkSweep::mark_sweep_phase4() { | |
| 655 EventMark m("4 compact heap"); | |
| 656 TraceTime tm("phase 4", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 657 trace("4"); | |
| 658 | |
| 659 // All pointers are now adjusted, move objects accordingly | |
| 660 | |
| 661 // It is imperative that we traverse perm_gen first in phase4. All | |
| 662 // classes must be allocated earlier than their instances, and traversing | |
| 663 // perm_gen first makes sure that all klassOops have moved to their new | |
| 664 // location before any instance does a dispatch through it's klass! | |
| 665 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 666 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 667 | |
| 668 PSYoungGen* young_gen = heap->young_gen(); | |
| 669 PSOldGen* old_gen = heap->old_gen(); | |
| 670 PSPermGen* perm_gen = heap->perm_gen(); | |
| 671 | |
| 672 perm_gen->compact(); | |
| 673 old_gen->compact(); | |
| 674 young_gen->compact(); | |
| 675 } | |
| 676 | |
| 677 jlong PSMarkSweep::millis_since_last_gc() { | |
| 678 jlong ret_val = os::javaTimeMillis() - _time_of_last_gc; | |
| 679 // XXX See note in genCollectedHeap::millis_since_last_gc(). | |
| 680 if (ret_val < 0) { | |
| 681 NOT_PRODUCT(warning("time warp: %d", ret_val);) | |
| 682 return 0; | |
| 683 } | |
| 684 return ret_val; | |
| 685 } | |
| 686 | |
| 687 void PSMarkSweep::reset_millis_since_last_gc() { | |
| 688 _time_of_last_gc = os::javaTimeMillis(); | |
| 689 } |