Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 453:c96030fff130
6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 16:56:09 -0800 |
| parents | 00b023ae2d78 |
| children | 27a80744a83b |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2001-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_concurrentMarkSweepGeneration.cpp.incl" | |
| 27 | |
| 28 // statics | |
| 29 CMSCollector* ConcurrentMarkSweepGeneration::_collector = NULL; | |
| 30 bool CMSCollector::_full_gc_requested = false; | |
| 31 | |
| 32 ////////////////////////////////////////////////////////////////// | |
| 33 // In support of CMS/VM thread synchronization | |
| 34 ////////////////////////////////////////////////////////////////// | |
| 35 // We split use of the CGC_lock into 2 "levels". | |
| 36 // The low-level locking is of the usual CGC_lock monitor. We introduce | |
| 37 // a higher level "token" (hereafter "CMS token") built on top of the | |
| 38 // low level monitor (hereafter "CGC lock"). | |
| 39 // The token-passing protocol gives priority to the VM thread. The | |
| 40 // CMS-lock doesn't provide any fairness guarantees, but clients | |
| 41 // should ensure that it is only held for very short, bounded | |
| 42 // durations. | |
| 43 // | |
| 44 // When either of the CMS thread or the VM thread is involved in | |
| 45 // collection operations during which it does not want the other | |
| 46 // thread to interfere, it obtains the CMS token. | |
| 47 // | |
| 48 // If either thread tries to get the token while the other has | |
| 49 // it, that thread waits. However, if the VM thread and CMS thread | |
| 50 // both want the token, then the VM thread gets priority while the | |
| 51 // CMS thread waits. This ensures, for instance, that the "concurrent" | |
| 52 // phases of the CMS thread's work do not block out the VM thread | |
| 53 // for long periods of time as the CMS thread continues to hog | |
| 54 // the token. (See bug 4616232). | |
| 55 // | |
| 56 // The baton-passing functions are, however, controlled by the | |
| 57 // flags _foregroundGCShouldWait and _foregroundGCIsActive, | |
| 58 // and here the low-level CMS lock, not the high level token, | |
| 59 // ensures mutual exclusion. | |
| 60 // | |
| 61 // Two important conditions that we have to satisfy: | |
| 62 // 1. if a thread does a low-level wait on the CMS lock, then it | |
| 63 // relinquishes the CMS token if it were holding that token | |
| 64 // when it acquired the low-level CMS lock. | |
| 65 // 2. any low-level notifications on the low-level lock | |
| 66 // should only be sent when a thread has relinquished the token. | |
| 67 // | |
| 68 // In the absence of either property, we'd have potential deadlock. | |
| 69 // | |
| 70 // We protect each of the CMS (concurrent and sequential) phases | |
| 71 // with the CMS _token_, not the CMS _lock_. | |
| 72 // | |
| 73 // The only code protected by CMS lock is the token acquisition code | |
| 74 // itself, see ConcurrentMarkSweepThread::[de]synchronize(), and the | |
| 75 // baton-passing code. | |
| 76 // | |
| 77 // Unfortunately, i couldn't come up with a good abstraction to factor and | |
| 78 // hide the naked CGC_lock manipulation in the baton-passing code | |
| 79 // further below. That's something we should try to do. Also, the proof | |
| 80 // of correctness of this 2-level locking scheme is far from obvious, | |
| 81 // and potentially quite slippery. We have an uneasy supsicion, for instance, | |
| 82 // that there may be a theoretical possibility of delay/starvation in the | |
| 83 // low-level lock/wait/notify scheme used for the baton-passing because of | |
| 84 // potential intereference with the priority scheme embodied in the | |
| 85 // CMS-token-passing protocol. See related comments at a CGC_lock->wait() | |
| 86 // invocation further below and marked with "XXX 20011219YSR". | |
| 87 // Indeed, as we note elsewhere, this may become yet more slippery | |
| 88 // in the presence of multiple CMS and/or multiple VM threads. XXX | |
| 89 | |
| 90 class CMSTokenSync: public StackObj { | |
| 91 private: | |
| 92 bool _is_cms_thread; | |
| 93 public: | |
| 94 CMSTokenSync(bool is_cms_thread): | |
| 95 _is_cms_thread(is_cms_thread) { | |
| 96 assert(is_cms_thread == Thread::current()->is_ConcurrentGC_thread(), | |
| 97 "Incorrect argument to constructor"); | |
| 98 ConcurrentMarkSweepThread::synchronize(_is_cms_thread); | |
| 99 } | |
| 100 | |
| 101 ~CMSTokenSync() { | |
| 102 assert(_is_cms_thread ? | |
| 103 ConcurrentMarkSweepThread::cms_thread_has_cms_token() : | |
| 104 ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 105 "Incorrect state"); | |
| 106 ConcurrentMarkSweepThread::desynchronize(_is_cms_thread); | |
| 107 } | |
| 108 }; | |
| 109 | |
| 110 // Convenience class that does a CMSTokenSync, and then acquires | |
| 111 // upto three locks. | |
| 112 class CMSTokenSyncWithLocks: public CMSTokenSync { | |
| 113 private: | |
| 114 // Note: locks are acquired in textual declaration order | |
| 115 // and released in the opposite order | |
| 116 MutexLockerEx _locker1, _locker2, _locker3; | |
| 117 public: | |
| 118 CMSTokenSyncWithLocks(bool is_cms_thread, Mutex* mutex1, | |
| 119 Mutex* mutex2 = NULL, Mutex* mutex3 = NULL): | |
| 120 CMSTokenSync(is_cms_thread), | |
| 121 _locker1(mutex1, Mutex::_no_safepoint_check_flag), | |
| 122 _locker2(mutex2, Mutex::_no_safepoint_check_flag), | |
| 123 _locker3(mutex3, Mutex::_no_safepoint_check_flag) | |
| 124 { } | |
| 125 }; | |
| 126 | |
| 127 | |
| 128 // Wrapper class to temporarily disable icms during a foreground cms collection. | |
| 129 class ICMSDisabler: public StackObj { | |
| 130 public: | |
| 131 // The ctor disables icms and wakes up the thread so it notices the change; | |
| 132 // the dtor re-enables icms. Note that the CMSCollector methods will check | |
| 133 // CMSIncrementalMode. | |
| 134 ICMSDisabler() { CMSCollector::disable_icms(); CMSCollector::start_icms(); } | |
| 135 ~ICMSDisabler() { CMSCollector::enable_icms(); } | |
| 136 }; | |
| 137 | |
| 138 ////////////////////////////////////////////////////////////////// | |
| 139 // Concurrent Mark-Sweep Generation ///////////////////////////// | |
| 140 ////////////////////////////////////////////////////////////////// | |
| 141 | |
| 142 NOT_PRODUCT(CompactibleFreeListSpace* debug_cms_space;) | |
| 143 | |
| 144 // This struct contains per-thread things necessary to support parallel | |
| 145 // young-gen collection. | |
| 146 class CMSParGCThreadState: public CHeapObj { | |
| 147 public: | |
| 148 CFLS_LAB lab; | |
| 149 PromotionInfo promo; | |
| 150 | |
| 151 // Constructor. | |
| 152 CMSParGCThreadState(CompactibleFreeListSpace* cfls) : lab(cfls) { | |
| 153 promo.setSpace(cfls); | |
| 154 } | |
| 155 }; | |
| 156 | |
| 157 ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration( | |
| 158 ReservedSpace rs, size_t initial_byte_size, int level, | |
| 159 CardTableRS* ct, bool use_adaptive_freelists, | |
| 160 FreeBlockDictionary::DictionaryChoice dictionaryChoice) : | |
| 161 CardGeneration(rs, initial_byte_size, level, ct), | |
| 162 _dilatation_factor(((double)MinChunkSize)/((double)(oopDesc::header_size()))), | |
| 163 _debug_collection_type(Concurrent_collection_type) | |
| 164 { | |
| 165 HeapWord* bottom = (HeapWord*) _virtual_space.low(); | |
| 166 HeapWord* end = (HeapWord*) _virtual_space.high(); | |
| 167 | |
| 168 _direct_allocated_words = 0; | |
| 169 NOT_PRODUCT( | |
| 170 _numObjectsPromoted = 0; | |
| 171 _numWordsPromoted = 0; | |
| 172 _numObjectsAllocated = 0; | |
| 173 _numWordsAllocated = 0; | |
| 174 ) | |
| 175 | |
| 176 _cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end), | |
| 177 use_adaptive_freelists, | |
| 178 dictionaryChoice); | |
| 179 NOT_PRODUCT(debug_cms_space = _cmsSpace;) | |
| 180 if (_cmsSpace == NULL) { | |
| 181 vm_exit_during_initialization( | |
| 182 "CompactibleFreeListSpace allocation failure"); | |
| 183 } | |
| 184 _cmsSpace->_gen = this; | |
| 185 | |
| 186 _gc_stats = new CMSGCStats(); | |
| 187 | |
| 188 // Verify the assumption that FreeChunk::_prev and OopDesc::_klass | |
| 189 // offsets match. The ability to tell free chunks from objects | |
| 190 // depends on this property. | |
| 191 debug_only( | |
| 192 FreeChunk* junk = NULL; | |
| 187 | 193 assert(UseCompressedOops || |
| 194 junk->prev_addr() == (void*)(oop(junk)->klass_addr()), | |
| 0 | 195 "Offset of FreeChunk::_prev within FreeChunk must match" |
| 196 " that of OopDesc::_klass within OopDesc"); | |
| 197 ) | |
| 198 if (ParallelGCThreads > 0) { | |
| 199 typedef CMSParGCThreadState* CMSParGCThreadStatePtr; | |
| 200 _par_gc_thread_states = | |
| 201 NEW_C_HEAP_ARRAY(CMSParGCThreadStatePtr, ParallelGCThreads); | |
| 202 if (_par_gc_thread_states == NULL) { | |
| 203 vm_exit_during_initialization("Could not allocate par gc structs"); | |
| 204 } | |
| 205 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 206 _par_gc_thread_states[i] = new CMSParGCThreadState(cmsSpace()); | |
| 207 if (_par_gc_thread_states[i] == NULL) { | |
| 208 vm_exit_during_initialization("Could not allocate par gc structs"); | |
| 209 } | |
| 210 } | |
| 211 } else { | |
| 212 _par_gc_thread_states = NULL; | |
| 213 } | |
| 214 _incremental_collection_failed = false; | |
| 215 // The "dilatation_factor" is the expansion that can occur on | |
| 216 // account of the fact that the minimum object size in the CMS | |
| 217 // generation may be larger than that in, say, a contiguous young | |
| 218 // generation. | |
| 219 // Ideally, in the calculation below, we'd compute the dilatation | |
| 220 // factor as: MinChunkSize/(promoting_gen's min object size) | |
| 221 // Since we do not have such a general query interface for the | |
| 222 // promoting generation, we'll instead just use the mimimum | |
| 223 // object size (which today is a header's worth of space); | |
| 224 // note that all arithmetic is in units of HeapWords. | |
| 225 assert(MinChunkSize >= oopDesc::header_size(), "just checking"); | |
| 226 assert(_dilatation_factor >= 1.0, "from previous assert"); | |
| 227 } | |
| 228 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
229 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
230 // The field "_initiating_occupancy" represents the occupancy percentage |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
231 // at which we trigger a new collection cycle. Unless explicitly specified |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
232 // via CMSInitiating[Perm]OccupancyFraction (argument "io" below), it |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
233 // is calculated by: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
234 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
235 // Let "f" be MinHeapFreeRatio in |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
236 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
237 // _intiating_occupancy = 100-f + |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
238 // f * (CMSTrigger[Perm]Ratio/100) |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
239 // where CMSTrigger[Perm]Ratio is the argument "tr" below. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
240 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
241 // That is, if we assume the heap is at its desired maximum occupancy at the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
242 // end of a collection, we let CMSTrigger[Perm]Ratio of the (purported) free |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
243 // space be allocated before initiating a new collection cycle. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
244 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
245 void ConcurrentMarkSweepGeneration::init_initiating_occupancy(intx io, intx tr) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
246 assert(io <= 100 && tr >= 0 && tr <= 100, "Check the arguments"); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
247 if (io >= 0) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
248 _initiating_occupancy = (double)io / 100.0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
249 } else { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
250 _initiating_occupancy = ((100 - MinHeapFreeRatio) + |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
251 (double)(tr * MinHeapFreeRatio) / 100.0) |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
252 / 100.0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
253 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
254 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
255 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
256 |
| 0 | 257 void ConcurrentMarkSweepGeneration::ref_processor_init() { |
| 258 assert(collector() != NULL, "no collector"); | |
| 259 collector()->ref_processor_init(); | |
| 260 } | |
| 261 | |
| 262 void CMSCollector::ref_processor_init() { | |
| 263 if (_ref_processor == NULL) { | |
| 264 // Allocate and initialize a reference processor | |
| 265 _ref_processor = ReferenceProcessor::create_ref_processor( | |
| 266 _span, // span | |
| 267 _cmsGen->refs_discovery_is_atomic(), // atomic_discovery | |
| 268 _cmsGen->refs_discovery_is_mt(), // mt_discovery | |
| 269 &_is_alive_closure, | |
| 270 ParallelGCThreads, | |
| 271 ParallelRefProcEnabled); | |
| 272 // Initialize the _ref_processor field of CMSGen | |
| 273 _cmsGen->set_ref_processor(_ref_processor); | |
| 274 | |
| 275 // Allocate a dummy ref processor for perm gen. | |
| 276 ReferenceProcessor* rp2 = new ReferenceProcessor(); | |
| 277 if (rp2 == NULL) { | |
| 278 vm_exit_during_initialization("Could not allocate ReferenceProcessor object"); | |
| 279 } | |
| 280 _permGen->set_ref_processor(rp2); | |
| 281 } | |
| 282 } | |
| 283 | |
| 284 CMSAdaptiveSizePolicy* CMSCollector::size_policy() { | |
| 285 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 286 assert(gch->kind() == CollectedHeap::GenCollectedHeap, | |
| 287 "Wrong type of heap"); | |
| 288 CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*) | |
| 289 gch->gen_policy()->size_policy(); | |
| 290 assert(sp->is_gc_cms_adaptive_size_policy(), | |
| 291 "Wrong type of size policy"); | |
| 292 return sp; | |
| 293 } | |
| 294 | |
| 295 CMSGCAdaptivePolicyCounters* CMSCollector::gc_adaptive_policy_counters() { | |
| 296 CMSGCAdaptivePolicyCounters* results = | |
| 297 (CMSGCAdaptivePolicyCounters*) collector_policy()->counters(); | |
| 298 assert( | |
| 299 results->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind, | |
| 300 "Wrong gc policy counter kind"); | |
| 301 return results; | |
| 302 } | |
| 303 | |
| 304 | |
| 305 void ConcurrentMarkSweepGeneration::initialize_performance_counters() { | |
| 306 | |
| 307 const char* gen_name = "old"; | |
| 308 | |
| 309 // Generation Counters - generation 1, 1 subspace | |
| 310 _gen_counters = new GenerationCounters(gen_name, 1, 1, &_virtual_space); | |
| 311 | |
| 312 _space_counters = new GSpaceCounters(gen_name, 0, | |
| 313 _virtual_space.reserved_size(), | |
| 314 this, _gen_counters); | |
| 315 } | |
| 316 | |
| 317 CMSStats::CMSStats(ConcurrentMarkSweepGeneration* cms_gen, unsigned int alpha): | |
| 318 _cms_gen(cms_gen) | |
| 319 { | |
| 320 assert(alpha <= 100, "bad value"); | |
| 321 _saved_alpha = alpha; | |
| 322 | |
| 323 // Initialize the alphas to the bootstrap value of 100. | |
| 324 _gc0_alpha = _cms_alpha = 100; | |
| 325 | |
| 326 _cms_begin_time.update(); | |
| 327 _cms_end_time.update(); | |
| 328 | |
| 329 _gc0_duration = 0.0; | |
| 330 _gc0_period = 0.0; | |
| 331 _gc0_promoted = 0; | |
| 332 | |
| 333 _cms_duration = 0.0; | |
| 334 _cms_period = 0.0; | |
| 335 _cms_allocated = 0; | |
| 336 | |
| 337 _cms_used_at_gc0_begin = 0; | |
| 338 _cms_used_at_gc0_end = 0; | |
| 339 _allow_duty_cycle_reduction = false; | |
| 340 _valid_bits = 0; | |
| 341 _icms_duty_cycle = CMSIncrementalDutyCycle; | |
| 342 } | |
| 343 | |
| 344 // If promotion failure handling is on use | |
| 345 // the padded average size of the promotion for each | |
| 346 // young generation collection. | |
| 347 double CMSStats::time_until_cms_gen_full() const { | |
| 348 size_t cms_free = _cms_gen->cmsSpace()->free(); | |
| 349 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 350 size_t expected_promotion = gch->get_gen(0)->capacity(); | |
| 351 if (HandlePromotionFailure) { | |
| 352 expected_promotion = MIN2( | |
| 353 (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average(), | |
| 354 expected_promotion); | |
| 355 } | |
| 356 if (cms_free > expected_promotion) { | |
| 357 // Start a cms collection if there isn't enough space to promote | |
| 358 // for the next minor collection. Use the padded average as | |
| 359 // a safety factor. | |
| 360 cms_free -= expected_promotion; | |
| 361 | |
| 362 // Adjust by the safety factor. | |
| 363 double cms_free_dbl = (double)cms_free; | |
| 364 cms_free_dbl = cms_free_dbl * (100.0 - CMSIncrementalSafetyFactor) / 100.0; | |
| 365 | |
| 366 if (PrintGCDetails && Verbose) { | |
| 367 gclog_or_tty->print_cr("CMSStats::time_until_cms_gen_full: cms_free " | |
| 368 SIZE_FORMAT " expected_promotion " SIZE_FORMAT, | |
| 369 cms_free, expected_promotion); | |
| 370 gclog_or_tty->print_cr(" cms_free_dbl %f cms_consumption_rate %f", | |
| 371 cms_free_dbl, cms_consumption_rate() + 1.0); | |
| 372 } | |
| 373 // Add 1 in case the consumption rate goes to zero. | |
| 374 return cms_free_dbl / (cms_consumption_rate() + 1.0); | |
| 375 } | |
| 376 return 0.0; | |
| 377 } | |
| 378 | |
| 379 // Compare the duration of the cms collection to the | |
| 380 // time remaining before the cms generation is empty. | |
| 381 // Note that the time from the start of the cms collection | |
| 382 // to the start of the cms sweep (less than the total | |
| 383 // duration of the cms collection) can be used. This | |
| 384 // has been tried and some applications experienced | |
| 385 // promotion failures early in execution. This was | |
| 386 // possibly because the averages were not accurate | |
| 387 // enough at the beginning. | |
| 388 double CMSStats::time_until_cms_start() const { | |
| 389 // We add "gc0_period" to the "work" calculation | |
| 390 // below because this query is done (mostly) at the | |
| 391 // end of a scavenge, so we need to conservatively | |
| 392 // account for that much possible delay | |
| 393 // in the query so as to avoid concurrent mode failures | |
| 394 // due to starting the collection just a wee bit too | |
| 395 // late. | |
| 396 double work = cms_duration() + gc0_period(); | |
| 397 double deadline = time_until_cms_gen_full(); | |
| 398 if (work > deadline) { | |
| 399 if (Verbose && PrintGCDetails) { | |
| 400 gclog_or_tty->print( | |
| 401 " CMSCollector: collect because of anticipated promotion " | |
| 402 "before full %3.7f + %3.7f > %3.7f ", cms_duration(), | |
| 403 gc0_period(), time_until_cms_gen_full()); | |
| 404 } | |
| 405 return 0.0; | |
| 406 } | |
| 407 return work - deadline; | |
| 408 } | |
| 409 | |
| 410 // Return a duty cycle based on old_duty_cycle and new_duty_cycle, limiting the | |
| 411 // amount of change to prevent wild oscillation. | |
| 412 unsigned int CMSStats::icms_damped_duty_cycle(unsigned int old_duty_cycle, | |
| 413 unsigned int new_duty_cycle) { | |
| 414 assert(old_duty_cycle <= 100, "bad input value"); | |
| 415 assert(new_duty_cycle <= 100, "bad input value"); | |
| 416 | |
| 417 // Note: use subtraction with caution since it may underflow (values are | |
| 418 // unsigned). Addition is safe since we're in the range 0-100. | |
| 419 unsigned int damped_duty_cycle = new_duty_cycle; | |
| 420 if (new_duty_cycle < old_duty_cycle) { | |
| 421 const unsigned int largest_delta = MAX2(old_duty_cycle / 4, 5U); | |
| 422 if (new_duty_cycle + largest_delta < old_duty_cycle) { | |
| 423 damped_duty_cycle = old_duty_cycle - largest_delta; | |
| 424 } | |
| 425 } else if (new_duty_cycle > old_duty_cycle) { | |
| 426 const unsigned int largest_delta = MAX2(old_duty_cycle / 4, 15U); | |
| 427 if (new_duty_cycle > old_duty_cycle + largest_delta) { | |
| 428 damped_duty_cycle = MIN2(old_duty_cycle + largest_delta, 100U); | |
| 429 } | |
| 430 } | |
| 431 assert(damped_duty_cycle <= 100, "invalid duty cycle computed"); | |
| 432 | |
| 433 if (CMSTraceIncrementalPacing) { | |
| 434 gclog_or_tty->print(" [icms_damped_duty_cycle(%d,%d) = %d] ", | |
| 435 old_duty_cycle, new_duty_cycle, damped_duty_cycle); | |
| 436 } | |
| 437 return damped_duty_cycle; | |
| 438 } | |
| 439 | |
| 440 unsigned int CMSStats::icms_update_duty_cycle_impl() { | |
| 441 assert(CMSIncrementalPacing && valid(), | |
| 442 "should be handled in icms_update_duty_cycle()"); | |
| 443 | |
| 444 double cms_time_so_far = cms_timer().seconds(); | |
| 445 double scaled_duration = cms_duration_per_mb() * _cms_used_at_gc0_end / M; | |
| 446 double scaled_duration_remaining = fabsd(scaled_duration - cms_time_so_far); | |
| 447 | |
| 448 // Avoid division by 0. | |
| 449 double time_until_full = MAX2(time_until_cms_gen_full(), 0.01); | |
| 450 double duty_cycle_dbl = 100.0 * scaled_duration_remaining / time_until_full; | |
| 451 | |
| 452 unsigned int new_duty_cycle = MIN2((unsigned int)duty_cycle_dbl, 100U); | |
| 453 if (new_duty_cycle > _icms_duty_cycle) { | |
| 454 // Avoid very small duty cycles (1 or 2); 0 is allowed. | |
| 455 if (new_duty_cycle > 2) { | |
| 456 _icms_duty_cycle = icms_damped_duty_cycle(_icms_duty_cycle, | |
| 457 new_duty_cycle); | |
| 458 } | |
| 459 } else if (_allow_duty_cycle_reduction) { | |
| 460 // The duty cycle is reduced only once per cms cycle (see record_cms_end()). | |
| 461 new_duty_cycle = icms_damped_duty_cycle(_icms_duty_cycle, new_duty_cycle); | |
| 462 // Respect the minimum duty cycle. | |
| 463 unsigned int min_duty_cycle = (unsigned int)CMSIncrementalDutyCycleMin; | |
| 464 _icms_duty_cycle = MAX2(new_duty_cycle, min_duty_cycle); | |
| 465 } | |
| 466 | |
| 467 if (PrintGCDetails || CMSTraceIncrementalPacing) { | |
| 468 gclog_or_tty->print(" icms_dc=%d ", _icms_duty_cycle); | |
| 469 } | |
| 470 | |
| 471 _allow_duty_cycle_reduction = false; | |
| 472 return _icms_duty_cycle; | |
| 473 } | |
| 474 | |
| 475 #ifndef PRODUCT | |
| 476 void CMSStats::print_on(outputStream *st) const { | |
| 477 st->print(" gc0_alpha=%d,cms_alpha=%d", _gc0_alpha, _cms_alpha); | |
| 478 st->print(",gc0_dur=%g,gc0_per=%g,gc0_promo=" SIZE_FORMAT, | |
| 479 gc0_duration(), gc0_period(), gc0_promoted()); | |
| 480 st->print(",cms_dur=%g,cms_dur_per_mb=%g,cms_per=%g,cms_alloc=" SIZE_FORMAT, | |
| 481 cms_duration(), cms_duration_per_mb(), | |
| 482 cms_period(), cms_allocated()); | |
| 483 st->print(",cms_since_beg=%g,cms_since_end=%g", | |
| 484 cms_time_since_begin(), cms_time_since_end()); | |
| 485 st->print(",cms_used_beg=" SIZE_FORMAT ",cms_used_end=" SIZE_FORMAT, | |
| 486 _cms_used_at_gc0_begin, _cms_used_at_gc0_end); | |
| 487 if (CMSIncrementalMode) { | |
| 488 st->print(",dc=%d", icms_duty_cycle()); | |
| 489 } | |
| 490 | |
| 491 if (valid()) { | |
| 492 st->print(",promo_rate=%g,cms_alloc_rate=%g", | |
| 493 promotion_rate(), cms_allocation_rate()); | |
| 494 st->print(",cms_consumption_rate=%g,time_until_full=%g", | |
| 495 cms_consumption_rate(), time_until_cms_gen_full()); | |
| 496 } | |
| 497 st->print(" "); | |
| 498 } | |
| 499 #endif // #ifndef PRODUCT | |
| 500 | |
| 501 CMSCollector::CollectorState CMSCollector::_collectorState = | |
| 502 CMSCollector::Idling; | |
| 503 bool CMSCollector::_foregroundGCIsActive = false; | |
| 504 bool CMSCollector::_foregroundGCShouldWait = false; | |
| 505 | |
| 506 CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, | |
| 507 ConcurrentMarkSweepGeneration* permGen, | |
| 508 CardTableRS* ct, | |
| 509 ConcurrentMarkSweepPolicy* cp): | |
| 510 _cmsGen(cmsGen), | |
| 511 _permGen(permGen), | |
| 512 _ct(ct), | |
| 513 _ref_processor(NULL), // will be set later | |
| 514 _conc_workers(NULL), // may be set later | |
| 515 _abort_preclean(false), | |
| 516 _start_sampling(false), | |
| 517 _between_prologue_and_epilogue(false), | |
| 518 _markBitMap(0, Mutex::leaf + 1, "CMS_markBitMap_lock"), | |
| 519 _perm_gen_verify_bit_map(0, -1 /* no mutex */, "No_lock"), | |
| 520 _modUnionTable((CardTableModRefBS::card_shift - LogHeapWordSize), | |
| 521 -1 /* lock-free */, "No_lock" /* dummy */), | |
| 522 _modUnionClosure(&_modUnionTable), | |
| 523 _modUnionClosurePar(&_modUnionTable), | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
524 // Adjust my span to cover old (cms) gen and perm gen |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
525 _span(cmsGen->reserved()._union(permGen->reserved())), |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
526 // Construct the is_alive_closure with _span & markBitMap |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
527 _is_alive_closure(_span, &_markBitMap), |
| 0 | 528 _restart_addr(NULL), |
| 529 _overflow_list(NULL), | |
| 530 _preserved_oop_stack(NULL), | |
| 531 _preserved_mark_stack(NULL), | |
| 532 _stats(cmsGen), | |
| 533 _eden_chunk_array(NULL), // may be set in ctor body | |
| 534 _eden_chunk_capacity(0), // -- ditto -- | |
| 535 _eden_chunk_index(0), // -- ditto -- | |
| 536 _survivor_plab_array(NULL), // -- ditto -- | |
| 537 _survivor_chunk_array(NULL), // -- ditto -- | |
| 538 _survivor_chunk_capacity(0), // -- ditto -- | |
| 539 _survivor_chunk_index(0), // -- ditto -- | |
| 540 _ser_pmc_preclean_ovflw(0), | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
541 _ser_kac_preclean_ovflw(0), |
| 0 | 542 _ser_pmc_remark_ovflw(0), |
| 543 _par_pmc_remark_ovflw(0), | |
| 544 _ser_kac_ovflw(0), | |
| 545 _par_kac_ovflw(0), | |
| 546 #ifndef PRODUCT | |
| 547 _num_par_pushes(0), | |
| 548 #endif | |
| 549 _collection_count_start(0), | |
| 550 _verifying(false), | |
| 551 _icms_start_limit(NULL), | |
| 552 _icms_stop_limit(NULL), | |
| 553 _verification_mark_bm(0, Mutex::leaf + 1, "CMS_verification_mark_bm_lock"), | |
| 554 _completed_initialization(false), | |
| 555 _collector_policy(cp), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
556 _should_unload_classes(false), |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
557 _concurrent_cycles_since_last_unload(0), |
| 0 | 558 _sweep_estimate(CMS_SweepWeight, CMS_SweepPadding) |
| 559 { | |
| 560 if (ExplicitGCInvokesConcurrentAndUnloadsClasses) { | |
| 561 ExplicitGCInvokesConcurrent = true; | |
| 562 } | |
| 563 // Now expand the span and allocate the collection support structures | |
| 564 // (MUT, marking bit map etc.) to cover both generations subject to | |
| 565 // collection. | |
| 566 | |
| 567 // First check that _permGen is adjacent to _cmsGen and above it. | |
| 568 assert( _cmsGen->reserved().word_size() > 0 | |
| 569 && _permGen->reserved().word_size() > 0, | |
| 570 "generations should not be of zero size"); | |
| 571 assert(_cmsGen->reserved().intersection(_permGen->reserved()).is_empty(), | |
| 572 "_cmsGen and _permGen should not overlap"); | |
| 573 assert(_cmsGen->reserved().end() == _permGen->reserved().start(), | |
| 574 "_cmsGen->end() different from _permGen->start()"); | |
| 575 | |
| 576 // For use by dirty card to oop closures. | |
| 577 _cmsGen->cmsSpace()->set_collector(this); | |
| 578 _permGen->cmsSpace()->set_collector(this); | |
| 579 | |
| 580 // Allocate MUT and marking bit map | |
| 581 { | |
| 582 MutexLockerEx x(_markBitMap.lock(), Mutex::_no_safepoint_check_flag); | |
| 583 if (!_markBitMap.allocate(_span)) { | |
| 584 warning("Failed to allocate CMS Bit Map"); | |
| 585 return; | |
| 586 } | |
| 587 assert(_markBitMap.covers(_span), "_markBitMap inconsistency?"); | |
| 588 } | |
| 589 { | |
| 590 _modUnionTable.allocate(_span); | |
| 591 assert(_modUnionTable.covers(_span), "_modUnionTable inconsistency?"); | |
| 592 } | |
| 593 | |
| 594 if (!_markStack.allocate(CMSMarkStackSize)) { | |
| 595 warning("Failed to allocate CMS Marking Stack"); | |
| 596 return; | |
| 597 } | |
| 598 if (!_revisitStack.allocate(CMSRevisitStackSize)) { | |
| 599 warning("Failed to allocate CMS Revisit Stack"); | |
| 600 return; | |
| 601 } | |
| 602 | |
| 603 // Support for multi-threaded concurrent phases | |
| 604 if (ParallelGCThreads > 0 && CMSConcurrentMTEnabled) { | |
| 605 if (FLAG_IS_DEFAULT(ParallelCMSThreads)) { | |
| 606 // just for now | |
| 607 FLAG_SET_DEFAULT(ParallelCMSThreads, (ParallelGCThreads + 3)/4); | |
| 608 } | |
| 609 if (ParallelCMSThreads > 1) { | |
| 610 _conc_workers = new YieldingFlexibleWorkGang("Parallel CMS Threads", | |
| 611 ParallelCMSThreads, true); | |
| 612 if (_conc_workers == NULL) { | |
| 613 warning("GC/CMS: _conc_workers allocation failure: " | |
| 614 "forcing -CMSConcurrentMTEnabled"); | |
| 615 CMSConcurrentMTEnabled = false; | |
| 616 } | |
| 617 } else { | |
| 618 CMSConcurrentMTEnabled = false; | |
| 619 } | |
| 620 } | |
| 621 if (!CMSConcurrentMTEnabled) { | |
| 622 ParallelCMSThreads = 0; | |
| 623 } else { | |
| 624 // Turn off CMSCleanOnEnter optimization temporarily for | |
| 625 // the MT case where it's not fixed yet; see 6178663. | |
| 626 CMSCleanOnEnter = false; | |
| 627 } | |
| 628 assert((_conc_workers != NULL) == (ParallelCMSThreads > 1), | |
| 629 "Inconsistency"); | |
| 630 | |
| 631 // Parallel task queues; these are shared for the | |
| 632 // concurrent and stop-world phases of CMS, but | |
| 633 // are not shared with parallel scavenge (ParNew). | |
| 634 { | |
| 635 uint i; | |
| 636 uint num_queues = (uint) MAX2(ParallelGCThreads, ParallelCMSThreads); | |
| 637 | |
| 638 if ((CMSParallelRemarkEnabled || CMSConcurrentMTEnabled | |
| 639 || ParallelRefProcEnabled) | |
| 640 && num_queues > 0) { | |
| 641 _task_queues = new OopTaskQueueSet(num_queues); | |
| 642 if (_task_queues == NULL) { | |
| 643 warning("task_queues allocation failure."); | |
| 644 return; | |
| 645 } | |
| 646 _hash_seed = NEW_C_HEAP_ARRAY(int, num_queues); | |
| 647 if (_hash_seed == NULL) { | |
| 648 warning("_hash_seed array allocation failure"); | |
| 649 return; | |
| 650 } | |
| 651 | |
| 652 // XXX use a global constant instead of 64! | |
| 653 typedef struct OopTaskQueuePadded { | |
| 654 OopTaskQueue work_queue; | |
| 655 char pad[64 - sizeof(OopTaskQueue)]; // prevent false sharing | |
| 656 } OopTaskQueuePadded; | |
| 657 | |
| 658 for (i = 0; i < num_queues; i++) { | |
| 659 OopTaskQueuePadded *q_padded = new OopTaskQueuePadded(); | |
| 660 if (q_padded == NULL) { | |
| 661 warning("work_queue allocation failure."); | |
| 662 return; | |
| 663 } | |
| 664 _task_queues->register_queue(i, &q_padded->work_queue); | |
| 665 } | |
| 666 for (i = 0; i < num_queues; i++) { | |
| 667 _task_queues->queue(i)->initialize(); | |
| 668 _hash_seed[i] = 17; // copied from ParNew | |
| 669 } | |
| 670 } | |
| 671 } | |
| 672 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
673 _cmsGen ->init_initiating_occupancy(CMSInitiatingOccupancyFraction, CMSTriggerRatio); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
674 _permGen->init_initiating_occupancy(CMSInitiatingPermOccupancyFraction, CMSTriggerPermRatio); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
675 |
| 0 | 676 // Clip CMSBootstrapOccupancy between 0 and 100. |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
677 _bootstrap_occupancy = ((double)MIN2((uintx)100, MAX2((uintx)0, CMSBootstrapOccupancy))) |
| 0 | 678 /(double)100; |
| 679 | |
| 680 _full_gcs_since_conc_gc = 0; | |
| 681 | |
| 682 // Now tell CMS generations the identity of their collector | |
| 683 ConcurrentMarkSweepGeneration::set_collector(this); | |
| 684 | |
| 685 // Create & start a CMS thread for this CMS collector | |
| 686 _cmsThread = ConcurrentMarkSweepThread::start(this); | |
| 687 assert(cmsThread() != NULL, "CMS Thread should have been created"); | |
| 688 assert(cmsThread()->collector() == this, | |
| 689 "CMS Thread should refer to this gen"); | |
| 690 assert(CGC_lock != NULL, "Where's the CGC_lock?"); | |
| 691 | |
| 692 // Support for parallelizing young gen rescan | |
| 693 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 694 _young_gen = gch->prev_gen(_cmsGen); | |
| 695 if (gch->supports_inline_contig_alloc()) { | |
| 696 _top_addr = gch->top_addr(); | |
| 697 _end_addr = gch->end_addr(); | |
| 698 assert(_young_gen != NULL, "no _young_gen"); | |
| 699 _eden_chunk_index = 0; | |
| 700 _eden_chunk_capacity = (_young_gen->max_capacity()+CMSSamplingGrain)/CMSSamplingGrain; | |
| 701 _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity); | |
| 702 if (_eden_chunk_array == NULL) { | |
| 703 _eden_chunk_capacity = 0; | |
| 704 warning("GC/CMS: _eden_chunk_array allocation failure"); | |
| 705 } | |
| 706 } | |
| 707 assert(_eden_chunk_array != NULL || _eden_chunk_capacity == 0, "Error"); | |
| 708 | |
| 709 // Support for parallelizing survivor space rescan | |
| 710 if (CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) { | |
| 711 size_t max_plab_samples = MaxNewSize/((SurvivorRatio+2)*MinTLABSize); | |
| 712 _survivor_plab_array = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads); | |
| 713 _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples); | |
| 714 _cursor = NEW_C_HEAP_ARRAY(size_t, ParallelGCThreads); | |
| 715 if (_survivor_plab_array == NULL || _survivor_chunk_array == NULL | |
| 716 || _cursor == NULL) { | |
| 717 warning("Failed to allocate survivor plab/chunk array"); | |
| 718 if (_survivor_plab_array != NULL) { | |
| 719 FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array); | |
| 720 _survivor_plab_array = NULL; | |
| 721 } | |
| 722 if (_survivor_chunk_array != NULL) { | |
| 723 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array); | |
| 724 _survivor_chunk_array = NULL; | |
| 725 } | |
| 726 if (_cursor != NULL) { | |
| 727 FREE_C_HEAP_ARRAY(size_t, _cursor); | |
| 728 _cursor = NULL; | |
| 729 } | |
| 730 } else { | |
| 731 _survivor_chunk_capacity = 2*max_plab_samples; | |
| 732 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 733 HeapWord** vec = NEW_C_HEAP_ARRAY(HeapWord*, max_plab_samples); | |
| 734 if (vec == NULL) { | |
| 735 warning("Failed to allocate survivor plab array"); | |
| 736 for (int j = i; j > 0; j--) { | |
| 737 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_plab_array[j-1].array()); | |
| 738 } | |
| 739 FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array); | |
| 740 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array); | |
| 741 _survivor_plab_array = NULL; | |
| 742 _survivor_chunk_array = NULL; | |
| 743 _survivor_chunk_capacity = 0; | |
| 744 break; | |
| 745 } else { | |
| 746 ChunkArray* cur = | |
| 747 ::new (&_survivor_plab_array[i]) ChunkArray(vec, | |
| 748 max_plab_samples); | |
| 749 assert(cur->end() == 0, "Should be 0"); | |
| 750 assert(cur->array() == vec, "Should be vec"); | |
| 751 assert(cur->capacity() == max_plab_samples, "Error"); | |
| 752 } | |
| 753 } | |
| 754 } | |
| 755 } | |
| 756 assert( ( _survivor_plab_array != NULL | |
| 757 && _survivor_chunk_array != NULL) | |
| 758 || ( _survivor_chunk_capacity == 0 | |
| 759 && _survivor_chunk_index == 0), | |
| 760 "Error"); | |
| 761 | |
| 762 // Choose what strong roots should be scanned depending on verification options | |
| 763 // and perm gen collection mode. | |
| 764 if (!CMSClassUnloadingEnabled) { | |
| 765 // If class unloading is disabled we want to include all classes into the root set. | |
| 766 add_root_scanning_option(SharedHeap::SO_AllClasses); | |
| 767 } else { | |
| 768 add_root_scanning_option(SharedHeap::SO_SystemClasses); | |
| 769 } | |
| 770 | |
| 771 NOT_PRODUCT(_overflow_counter = CMSMarkStackOverflowInterval;) | |
| 772 _gc_counters = new CollectorCounters("CMS", 1); | |
| 773 _completed_initialization = true; | |
| 774 _sweep_timer.start(); // start of time | |
| 775 } | |
| 776 | |
| 777 const char* ConcurrentMarkSweepGeneration::name() const { | |
| 778 return "concurrent mark-sweep generation"; | |
| 779 } | |
| 780 void ConcurrentMarkSweepGeneration::update_counters() { | |
| 781 if (UsePerfData) { | |
| 782 _space_counters->update_all(); | |
| 783 _gen_counters->update_all(); | |
| 784 } | |
| 785 } | |
| 786 | |
| 787 // this is an optimized version of update_counters(). it takes the | |
| 788 // used value as a parameter rather than computing it. | |
| 789 // | |
| 790 void ConcurrentMarkSweepGeneration::update_counters(size_t used) { | |
| 791 if (UsePerfData) { | |
| 792 _space_counters->update_used(used); | |
| 793 _space_counters->update_capacity(); | |
| 794 _gen_counters->update_all(); | |
| 795 } | |
| 796 } | |
| 797 | |
| 798 void ConcurrentMarkSweepGeneration::print() const { | |
| 799 Generation::print(); | |
| 800 cmsSpace()->print(); | |
| 801 } | |
| 802 | |
| 803 #ifndef PRODUCT | |
| 804 void ConcurrentMarkSweepGeneration::print_statistics() { | |
| 805 cmsSpace()->printFLCensus(0); | |
| 806 } | |
| 807 #endif | |
| 808 | |
| 809 void ConcurrentMarkSweepGeneration::printOccupancy(const char *s) { | |
| 810 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 811 if (PrintGCDetails) { | |
| 812 if (Verbose) { | |
| 813 gclog_or_tty->print(" [%d %s-%s: "SIZE_FORMAT"("SIZE_FORMAT")]", | |
| 814 level(), short_name(), s, used(), capacity()); | |
| 815 } else { | |
| 816 gclog_or_tty->print(" [%d %s-%s: "SIZE_FORMAT"K("SIZE_FORMAT"K)]", | |
| 817 level(), short_name(), s, used() / K, capacity() / K); | |
| 818 } | |
| 819 } | |
| 820 if (Verbose) { | |
| 821 gclog_or_tty->print(" "SIZE_FORMAT"("SIZE_FORMAT")", | |
| 822 gch->used(), gch->capacity()); | |
| 823 } else { | |
| 824 gclog_or_tty->print(" "SIZE_FORMAT"K("SIZE_FORMAT"K)", | |
| 825 gch->used() / K, gch->capacity() / K); | |
| 826 } | |
| 827 } | |
| 828 | |
| 829 size_t | |
| 830 ConcurrentMarkSweepGeneration::contiguous_available() const { | |
| 831 // dld proposes an improvement in precision here. If the committed | |
| 832 // part of the space ends in a free block we should add that to | |
| 833 // uncommitted size in the calculation below. Will make this | |
| 834 // change later, staying with the approximation below for the | |
| 835 // time being. -- ysr. | |
| 836 return MAX2(_virtual_space.uncommitted_size(), unsafe_max_alloc_nogc()); | |
| 837 } | |
| 838 | |
| 839 size_t | |
| 840 ConcurrentMarkSweepGeneration::unsafe_max_alloc_nogc() const { | |
| 841 return _cmsSpace->max_alloc_in_words() * HeapWordSize; | |
| 842 } | |
| 843 | |
| 844 size_t ConcurrentMarkSweepGeneration::max_available() const { | |
| 845 return free() + _virtual_space.uncommitted_size(); | |
| 846 } | |
| 847 | |
| 848 bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe( | |
| 849 size_t max_promotion_in_bytes, | |
| 850 bool younger_handles_promotion_failure) const { | |
| 851 | |
| 852 // This is the most conservative test. Full promotion is | |
| 853 // guaranteed if this is used. The multiplicative factor is to | |
| 854 // account for the worst case "dilatation". | |
| 855 double adjusted_max_promo_bytes = _dilatation_factor * max_promotion_in_bytes; | |
| 856 if (adjusted_max_promo_bytes > (double)max_uintx) { // larger than size_t | |
| 857 adjusted_max_promo_bytes = (double)max_uintx; | |
| 858 } | |
| 859 bool result = (max_contiguous_available() >= (size_t)adjusted_max_promo_bytes); | |
| 860 | |
| 861 if (younger_handles_promotion_failure && !result) { | |
| 862 // Full promotion is not guaranteed because fragmentation | |
| 863 // of the cms generation can prevent the full promotion. | |
| 864 result = (max_available() >= (size_t)adjusted_max_promo_bytes); | |
| 865 | |
| 866 if (!result) { | |
| 867 // With promotion failure handling the test for the ability | |
| 868 // to support the promotion does not have to be guaranteed. | |
| 869 // Use an average of the amount promoted. | |
| 870 result = max_available() >= (size_t) | |
| 871 gc_stats()->avg_promoted()->padded_average(); | |
| 872 if (PrintGC && Verbose && result) { | |
| 873 gclog_or_tty->print_cr( | |
| 874 "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" | |
| 875 " max_available: " SIZE_FORMAT | |
| 876 " avg_promoted: " SIZE_FORMAT, | |
| 877 max_available(), (size_t) | |
| 878 gc_stats()->avg_promoted()->padded_average()); | |
| 879 } | |
| 880 } else { | |
| 881 if (PrintGC && Verbose) { | |
| 882 gclog_or_tty->print_cr( | |
| 883 "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" | |
| 884 " max_available: " SIZE_FORMAT | |
| 885 " adj_max_promo_bytes: " SIZE_FORMAT, | |
| 886 max_available(), (size_t)adjusted_max_promo_bytes); | |
| 887 } | |
| 888 } | |
| 889 } else { | |
| 890 if (PrintGC && Verbose) { | |
| 891 gclog_or_tty->print_cr( | |
| 892 "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" | |
| 893 " contiguous_available: " SIZE_FORMAT | |
| 894 " adj_max_promo_bytes: " SIZE_FORMAT, | |
| 895 max_contiguous_available(), (size_t)adjusted_max_promo_bytes); | |
| 896 } | |
| 897 } | |
| 898 return result; | |
| 899 } | |
| 900 | |
| 901 CompactibleSpace* | |
| 902 ConcurrentMarkSweepGeneration::first_compaction_space() const { | |
| 903 return _cmsSpace; | |
| 904 } | |
| 905 | |
| 906 void ConcurrentMarkSweepGeneration::reset_after_compaction() { | |
| 907 // Clear the promotion information. These pointers can be adjusted | |
| 908 // along with all the other pointers into the heap but | |
| 909 // compaction is expected to be a rare event with | |
| 910 // a heap using cms so don't do it without seeing the need. | |
| 911 if (ParallelGCThreads > 0) { | |
| 912 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 913 _par_gc_thread_states[i]->promo.reset(); | |
| 914 } | |
| 915 } | |
| 916 } | |
| 917 | |
| 918 void ConcurrentMarkSweepGeneration::space_iterate(SpaceClosure* blk, bool usedOnly) { | |
| 919 blk->do_space(_cmsSpace); | |
| 920 } | |
| 921 | |
| 922 void ConcurrentMarkSweepGeneration::compute_new_size() { | |
| 923 assert_locked_or_safepoint(Heap_lock); | |
| 924 | |
| 925 // If incremental collection failed, we just want to expand | |
| 926 // to the limit. | |
| 927 if (incremental_collection_failed()) { | |
| 928 clear_incremental_collection_failed(); | |
| 929 grow_to_reserved(); | |
| 930 return; | |
| 931 } | |
| 932 | |
| 933 size_t expand_bytes = 0; | |
| 934 double free_percentage = ((double) free()) / capacity(); | |
| 935 double desired_free_percentage = (double) MinHeapFreeRatio / 100; | |
| 936 double maximum_free_percentage = (double) MaxHeapFreeRatio / 100; | |
| 937 | |
| 938 // compute expansion delta needed for reaching desired free percentage | |
| 939 if (free_percentage < desired_free_percentage) { | |
| 940 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); | |
| 941 assert(desired_capacity >= capacity(), "invalid expansion size"); | |
| 942 expand_bytes = MAX2(desired_capacity - capacity(), MinHeapDeltaBytes); | |
| 943 } | |
| 944 if (expand_bytes > 0) { | |
| 945 if (PrintGCDetails && Verbose) { | |
| 946 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); | |
| 947 gclog_or_tty->print_cr("\nFrom compute_new_size: "); | |
| 948 gclog_or_tty->print_cr(" Free fraction %f", free_percentage); | |
| 949 gclog_or_tty->print_cr(" Desired free fraction %f", | |
| 950 desired_free_percentage); | |
| 951 gclog_or_tty->print_cr(" Maximum free fraction %f", | |
| 952 maximum_free_percentage); | |
| 953 gclog_or_tty->print_cr(" Capactiy "SIZE_FORMAT, capacity()/1000); | |
| 954 gclog_or_tty->print_cr(" Desired capacity "SIZE_FORMAT, | |
| 955 desired_capacity/1000); | |
| 956 int prev_level = level() - 1; | |
| 957 if (prev_level >= 0) { | |
| 958 size_t prev_size = 0; | |
| 959 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 960 Generation* prev_gen = gch->_gens[prev_level]; | |
| 961 prev_size = prev_gen->capacity(); | |
| 962 gclog_or_tty->print_cr(" Younger gen size "SIZE_FORMAT, | |
| 963 prev_size/1000); | |
| 964 } | |
| 965 gclog_or_tty->print_cr(" unsafe_max_alloc_nogc "SIZE_FORMAT, | |
| 966 unsafe_max_alloc_nogc()/1000); | |
| 967 gclog_or_tty->print_cr(" contiguous available "SIZE_FORMAT, | |
| 968 contiguous_available()/1000); | |
| 969 gclog_or_tty->print_cr(" Expand by "SIZE_FORMAT" (bytes)", | |
| 970 expand_bytes); | |
| 971 } | |
| 972 // safe if expansion fails | |
| 973 expand(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio); | |
| 974 if (PrintGCDetails && Verbose) { | |
| 975 gclog_or_tty->print_cr(" Expanded free fraction %f", | |
| 976 ((double) free()) / capacity()); | |
| 977 } | |
| 978 } | |
| 979 } | |
| 980 | |
| 981 Mutex* ConcurrentMarkSweepGeneration::freelistLock() const { | |
| 982 return cmsSpace()->freelistLock(); | |
| 983 } | |
| 984 | |
| 985 HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size, | |
| 986 bool tlab) { | |
| 987 CMSSynchronousYieldRequest yr; | |
| 988 MutexLockerEx x(freelistLock(), | |
| 989 Mutex::_no_safepoint_check_flag); | |
| 990 return have_lock_and_allocate(size, tlab); | |
| 991 } | |
| 992 | |
| 993 HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size, | |
| 994 bool tlab) { | |
| 995 assert_lock_strong(freelistLock()); | |
| 996 size_t adjustedSize = CompactibleFreeListSpace::adjustObjectSize(size); | |
| 997 HeapWord* res = cmsSpace()->allocate(adjustedSize); | |
| 998 // Allocate the object live (grey) if the background collector has | |
| 999 // started marking. This is necessary because the marker may | |
| 1000 // have passed this address and consequently this object will | |
| 1001 // not otherwise be greyed and would be incorrectly swept up. | |
| 1002 // Note that if this object contains references, the writing | |
| 1003 // of those references will dirty the card containing this object | |
| 1004 // allowing the object to be blackened (and its references scanned) | |
| 1005 // either during a preclean phase or at the final checkpoint. | |
| 1006 if (res != NULL) { | |
| 1007 collector()->direct_allocated(res, adjustedSize); | |
| 1008 _direct_allocated_words += adjustedSize; | |
| 1009 // allocation counters | |
| 1010 NOT_PRODUCT( | |
| 1011 _numObjectsAllocated++; | |
| 1012 _numWordsAllocated += (int)adjustedSize; | |
| 1013 ) | |
| 1014 } | |
| 1015 return res; | |
| 1016 } | |
| 1017 | |
| 1018 // In the case of direct allocation by mutators in a generation that | |
| 1019 // is being concurrently collected, the object must be allocated | |
| 1020 // live (grey) if the background collector has started marking. | |
| 1021 // This is necessary because the marker may | |
| 1022 // have passed this address and consequently this object will | |
| 1023 // not otherwise be greyed and would be incorrectly swept up. | |
| 1024 // Note that if this object contains references, the writing | |
| 1025 // of those references will dirty the card containing this object | |
| 1026 // allowing the object to be blackened (and its references scanned) | |
| 1027 // either during a preclean phase or at the final checkpoint. | |
| 1028 void CMSCollector::direct_allocated(HeapWord* start, size_t size) { | |
| 1029 assert(_markBitMap.covers(start, size), "Out of bounds"); | |
| 1030 if (_collectorState >= Marking) { | |
| 1031 MutexLockerEx y(_markBitMap.lock(), | |
| 1032 Mutex::_no_safepoint_check_flag); | |
| 1033 // [see comments preceding SweepClosure::do_blk() below for details] | |
| 1034 // 1. need to mark the object as live so it isn't collected | |
| 1035 // 2. need to mark the 2nd bit to indicate the object may be uninitialized | |
| 1036 // 3. need to mark the end of the object so sweeper can skip over it | |
| 1037 // if it's uninitialized when the sweeper reaches it. | |
| 1038 _markBitMap.mark(start); // object is live | |
| 1039 _markBitMap.mark(start + 1); // object is potentially uninitialized? | |
| 1040 _markBitMap.mark(start + size - 1); | |
| 1041 // mark end of object | |
| 1042 } | |
| 1043 // check that oop looks uninitialized | |
| 187 | 1044 assert(oop(start)->klass_or_null() == NULL, "_klass should be NULL"); |
| 0 | 1045 } |
| 1046 | |
| 1047 void CMSCollector::promoted(bool par, HeapWord* start, | |
| 1048 bool is_obj_array, size_t obj_size) { | |
| 1049 assert(_markBitMap.covers(start), "Out of bounds"); | |
| 1050 // See comment in direct_allocated() about when objects should | |
| 1051 // be allocated live. | |
| 1052 if (_collectorState >= Marking) { | |
| 1053 // we already hold the marking bit map lock, taken in | |
| 1054 // the prologue | |
| 1055 if (par) { | |
| 1056 _markBitMap.par_mark(start); | |
| 1057 } else { | |
| 1058 _markBitMap.mark(start); | |
| 1059 } | |
| 1060 // We don't need to mark the object as uninitialized (as | |
| 1061 // in direct_allocated above) because this is being done with the | |
| 1062 // world stopped and the object will be initialized by the | |
| 1063 // time the sweeper gets to look at it. | |
| 1064 assert(SafepointSynchronize::is_at_safepoint(), | |
| 1065 "expect promotion only at safepoints"); | |
| 1066 | |
| 1067 if (_collectorState < Sweeping) { | |
| 1068 // Mark the appropriate cards in the modUnionTable, so that | |
| 1069 // this object gets scanned before the sweep. If this is | |
| 1070 // not done, CMS generation references in the object might | |
| 1071 // not get marked. | |
| 1072 // For the case of arrays, which are otherwise precisely | |
| 1073 // marked, we need to dirty the entire array, not just its head. | |
| 1074 if (is_obj_array) { | |
| 1075 // The [par_]mark_range() method expects mr.end() below to | |
| 1076 // be aligned to the granularity of a bit's representation | |
| 1077 // in the heap. In the case of the MUT below, that's a | |
| 1078 // card size. | |
| 1079 MemRegion mr(start, | |
| 1080 (HeapWord*)round_to((intptr_t)(start + obj_size), | |
| 1081 CardTableModRefBS::card_size /* bytes */)); | |
| 1082 if (par) { | |
| 1083 _modUnionTable.par_mark_range(mr); | |
| 1084 } else { | |
| 1085 _modUnionTable.mark_range(mr); | |
| 1086 } | |
| 1087 } else { // not an obj array; we can just mark the head | |
| 1088 if (par) { | |
| 1089 _modUnionTable.par_mark(start); | |
| 1090 } else { | |
| 1091 _modUnionTable.mark(start); | |
| 1092 } | |
| 1093 } | |
| 1094 } | |
| 1095 } | |
| 1096 } | |
| 1097 | |
| 1098 static inline size_t percent_of_space(Space* space, HeapWord* addr) | |
| 1099 { | |
| 1100 size_t delta = pointer_delta(addr, space->bottom()); | |
| 1101 return (size_t)(delta * 100.0 / (space->capacity() / HeapWordSize)); | |
| 1102 } | |
| 1103 | |
| 1104 void CMSCollector::icms_update_allocation_limits() | |
| 1105 { | |
| 1106 Generation* gen0 = GenCollectedHeap::heap()->get_gen(0); | |
| 1107 EdenSpace* eden = gen0->as_DefNewGeneration()->eden(); | |
| 1108 | |
| 1109 const unsigned int duty_cycle = stats().icms_update_duty_cycle(); | |
| 1110 if (CMSTraceIncrementalPacing) { | |
| 1111 stats().print(); | |
| 1112 } | |
| 1113 | |
| 1114 assert(duty_cycle <= 100, "invalid duty cycle"); | |
| 1115 if (duty_cycle != 0) { | |
| 1116 // The duty_cycle is a percentage between 0 and 100; convert to words and | |
| 1117 // then compute the offset from the endpoints of the space. | |
| 1118 size_t free_words = eden->free() / HeapWordSize; | |
| 1119 double free_words_dbl = (double)free_words; | |
| 1120 size_t duty_cycle_words = (size_t)(free_words_dbl * duty_cycle / 100.0); | |
| 1121 size_t offset_words = (free_words - duty_cycle_words) / 2; | |
| 1122 | |
| 1123 _icms_start_limit = eden->top() + offset_words; | |
| 1124 _icms_stop_limit = eden->end() - offset_words; | |
| 1125 | |
| 1126 // The limits may be adjusted (shifted to the right) by | |
| 1127 // CMSIncrementalOffset, to allow the application more mutator time after a | |
| 1128 // young gen gc (when all mutators were stopped) and before CMS starts and | |
| 1129 // takes away one or more cpus. | |
| 1130 if (CMSIncrementalOffset != 0) { | |
| 1131 double adjustment_dbl = free_words_dbl * CMSIncrementalOffset / 100.0; | |
| 1132 size_t adjustment = (size_t)adjustment_dbl; | |
| 1133 HeapWord* tmp_stop = _icms_stop_limit + adjustment; | |
| 1134 if (tmp_stop > _icms_stop_limit && tmp_stop < eden->end()) { | |
| 1135 _icms_start_limit += adjustment; | |
| 1136 _icms_stop_limit = tmp_stop; | |
| 1137 } | |
| 1138 } | |
| 1139 } | |
| 1140 if (duty_cycle == 0 || (_icms_start_limit == _icms_stop_limit)) { | |
| 1141 _icms_start_limit = _icms_stop_limit = eden->end(); | |
| 1142 } | |
| 1143 | |
| 1144 // Install the new start limit. | |
| 1145 eden->set_soft_end(_icms_start_limit); | |
| 1146 | |
| 1147 if (CMSTraceIncrementalMode) { | |
| 1148 gclog_or_tty->print(" icms alloc limits: " | |
| 1149 PTR_FORMAT "," PTR_FORMAT | |
| 1150 " (" SIZE_FORMAT "%%," SIZE_FORMAT "%%) ", | |
| 1151 _icms_start_limit, _icms_stop_limit, | |
| 1152 percent_of_space(eden, _icms_start_limit), | |
| 1153 percent_of_space(eden, _icms_stop_limit)); | |
| 1154 if (Verbose) { | |
| 1155 gclog_or_tty->print("eden: "); | |
| 1156 eden->print_on(gclog_or_tty); | |
| 1157 } | |
| 1158 } | |
| 1159 } | |
| 1160 | |
| 1161 // Any changes here should try to maintain the invariant | |
| 1162 // that if this method is called with _icms_start_limit | |
| 1163 // and _icms_stop_limit both NULL, then it should return NULL | |
| 1164 // and not notify the icms thread. | |
| 1165 HeapWord* | |
| 1166 CMSCollector::allocation_limit_reached(Space* space, HeapWord* top, | |
| 1167 size_t word_size) | |
| 1168 { | |
| 1169 // A start_limit equal to end() means the duty cycle is 0, so treat that as a | |
| 1170 // nop. | |
| 1171 if (CMSIncrementalMode && _icms_start_limit != space->end()) { | |
| 1172 if (top <= _icms_start_limit) { | |
| 1173 if (CMSTraceIncrementalMode) { | |
| 1174 space->print_on(gclog_or_tty); | |
| 1175 gclog_or_tty->stamp(); | |
| 1176 gclog_or_tty->print_cr(" start limit top=" PTR_FORMAT | |
| 1177 ", new limit=" PTR_FORMAT | |
| 1178 " (" SIZE_FORMAT "%%)", | |
| 1179 top, _icms_stop_limit, | |
| 1180 percent_of_space(space, _icms_stop_limit)); | |
| 1181 } | |
| 1182 ConcurrentMarkSweepThread::start_icms(); | |
| 1183 assert(top < _icms_stop_limit, "Tautology"); | |
| 1184 if (word_size < pointer_delta(_icms_stop_limit, top)) { | |
| 1185 return _icms_stop_limit; | |
| 1186 } | |
| 1187 | |
| 1188 // The allocation will cross both the _start and _stop limits, so do the | |
| 1189 // stop notification also and return end(). | |
| 1190 if (CMSTraceIncrementalMode) { | |
| 1191 space->print_on(gclog_or_tty); | |
| 1192 gclog_or_tty->stamp(); | |
| 1193 gclog_or_tty->print_cr(" +stop limit top=" PTR_FORMAT | |
| 1194 ", new limit=" PTR_FORMAT | |
| 1195 " (" SIZE_FORMAT "%%)", | |
| 1196 top, space->end(), | |
| 1197 percent_of_space(space, space->end())); | |
| 1198 } | |
| 1199 ConcurrentMarkSweepThread::stop_icms(); | |
| 1200 return space->end(); | |
| 1201 } | |
| 1202 | |
| 1203 if (top <= _icms_stop_limit) { | |
| 1204 if (CMSTraceIncrementalMode) { | |
| 1205 space->print_on(gclog_or_tty); | |
| 1206 gclog_or_tty->stamp(); | |
| 1207 gclog_or_tty->print_cr(" stop limit top=" PTR_FORMAT | |
| 1208 ", new limit=" PTR_FORMAT | |
| 1209 " (" SIZE_FORMAT "%%)", | |
| 1210 top, space->end(), | |
| 1211 percent_of_space(space, space->end())); | |
| 1212 } | |
| 1213 ConcurrentMarkSweepThread::stop_icms(); | |
| 1214 return space->end(); | |
| 1215 } | |
| 1216 | |
| 1217 if (CMSTraceIncrementalMode) { | |
| 1218 space->print_on(gclog_or_tty); | |
| 1219 gclog_or_tty->stamp(); | |
| 1220 gclog_or_tty->print_cr(" end limit top=" PTR_FORMAT | |
| 1221 ", new limit=" PTR_FORMAT, | |
| 1222 top, NULL); | |
| 1223 } | |
| 1224 } | |
| 1225 | |
| 1226 return NULL; | |
| 1227 } | |
| 1228 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1229 oop ConcurrentMarkSweepGeneration::promote(oop obj, size_t obj_size) { |
| 0 | 1230 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); |
| 1231 // allocate, copy and if necessary update promoinfo -- | |
| 1232 // delegate to underlying space. | |
| 1233 assert_lock_strong(freelistLock()); | |
| 1234 | |
| 1235 #ifndef PRODUCT | |
| 1236 if (Universe::heap()->promotion_should_fail()) { | |
| 1237 return NULL; | |
| 1238 } | |
| 1239 #endif // #ifndef PRODUCT | |
| 1240 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1241 oop res = _cmsSpace->promote(obj, obj_size); |
| 0 | 1242 if (res == NULL) { |
| 1243 // expand and retry | |
| 1244 size_t s = _cmsSpace->expansionSpaceRequired(obj_size); // HeapWords | |
| 1245 expand(s*HeapWordSize, MinHeapDeltaBytes, | |
| 1246 CMSExpansionCause::_satisfy_promotion); | |
| 1247 // Since there's currently no next generation, we don't try to promote | |
| 1248 // into a more senior generation. | |
| 1249 assert(next_gen() == NULL, "assumption, based upon which no attempt " | |
| 1250 "is made to pass on a possibly failing " | |
| 1251 "promotion to next generation"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1252 res = _cmsSpace->promote(obj, obj_size); |
| 0 | 1253 } |
| 1254 if (res != NULL) { | |
| 1255 // See comment in allocate() about when objects should | |
| 1256 // be allocated live. | |
| 1257 assert(obj->is_oop(), "Will dereference klass pointer below"); | |
| 1258 collector()->promoted(false, // Not parallel | |
| 1259 (HeapWord*)res, obj->is_objArray(), obj_size); | |
| 1260 // promotion counters | |
| 1261 NOT_PRODUCT( | |
| 1262 _numObjectsPromoted++; | |
| 1263 _numWordsPromoted += | |
| 1264 (int)(CompactibleFreeListSpace::adjustObjectSize(obj->size())); | |
| 1265 ) | |
| 1266 } | |
| 1267 return res; | |
| 1268 } | |
| 1269 | |
| 1270 | |
| 1271 HeapWord* | |
| 1272 ConcurrentMarkSweepGeneration::allocation_limit_reached(Space* space, | |
| 1273 HeapWord* top, | |
| 1274 size_t word_sz) | |
| 1275 { | |
| 1276 return collector()->allocation_limit_reached(space, top, word_sz); | |
| 1277 } | |
| 1278 | |
| 1279 // Things to support parallel young-gen collection. | |
| 1280 oop | |
| 1281 ConcurrentMarkSweepGeneration::par_promote(int thread_num, | |
| 1282 oop old, markOop m, | |
| 1283 size_t word_sz) { | |
| 1284 #ifndef PRODUCT | |
| 1285 if (Universe::heap()->promotion_should_fail()) { | |
| 1286 return NULL; | |
| 1287 } | |
| 1288 #endif // #ifndef PRODUCT | |
| 1289 | |
| 1290 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
| 1291 PromotionInfo* promoInfo = &ps->promo; | |
| 1292 // if we are tracking promotions, then first ensure space for | |
| 1293 // promotion (including spooling space for saving header if necessary). | |
| 1294 // then allocate and copy, then track promoted info if needed. | |
| 1295 // When tracking (see PromotionInfo::track()), the mark word may | |
| 1296 // be displaced and in this case restoration of the mark word | |
| 1297 // occurs in the (oop_since_save_marks_)iterate phase. | |
| 1298 if (promoInfo->tracking() && !promoInfo->ensure_spooling_space()) { | |
| 1299 // Out of space for allocating spooling buffers; | |
| 1300 // try expanding and allocating spooling buffers. | |
| 1301 if (!expand_and_ensure_spooling_space(promoInfo)) { | |
| 1302 return NULL; | |
| 1303 } | |
| 1304 } | |
| 1305 assert(promoInfo->has_spooling_space(), "Control point invariant"); | |
| 1306 HeapWord* obj_ptr = ps->lab.alloc(word_sz); | |
| 1307 if (obj_ptr == NULL) { | |
| 1308 obj_ptr = expand_and_par_lab_allocate(ps, word_sz); | |
| 1309 if (obj_ptr == NULL) { | |
| 1310 return NULL; | |
| 1311 } | |
| 1312 } | |
| 1313 oop obj = oop(obj_ptr); | |
| 187 | 1314 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here."); |
| 0 | 1315 // Otherwise, copy the object. Here we must be careful to insert the |
| 1316 // klass pointer last, since this marks the block as an allocated object. | |
| 187 | 1317 // Except with compressed oops it's the mark word. |
| 0 | 1318 HeapWord* old_ptr = (HeapWord*)old; |
| 1319 if (word_sz > (size_t)oopDesc::header_size()) { | |
| 1320 Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(), | |
| 1321 obj_ptr + oopDesc::header_size(), | |
| 1322 word_sz - oopDesc::header_size()); | |
| 1323 } | |
| 187 | 1324 |
| 1325 if (UseCompressedOops) { | |
| 1326 // Copy gap missed by (aligned) header size calculation above | |
| 1327 obj->set_klass_gap(old->klass_gap()); | |
| 1328 } | |
| 1329 | |
| 0 | 1330 // Restore the mark word copied above. |
| 1331 obj->set_mark(m); | |
| 187 | 1332 |
| 0 | 1333 // Now we can track the promoted object, if necessary. We take care |
| 1334 // To delay the transition from uninitialized to full object | |
| 1335 // (i.e., insertion of klass pointer) until after, so that it | |
| 1336 // atomically becomes a promoted object. | |
| 1337 if (promoInfo->tracking()) { | |
| 1338 promoInfo->track((PromotedObject*)obj, old->klass()); | |
| 1339 } | |
| 187 | 1340 |
| 1341 // Finally, install the klass pointer (this should be volatile). | |
| 0 | 1342 obj->set_klass(old->klass()); |
| 1343 | |
| 1344 assert(old->is_oop(), "Will dereference klass ptr below"); | |
| 1345 collector()->promoted(true, // parallel | |
| 1346 obj_ptr, old->is_objArray(), word_sz); | |
| 1347 | |
| 1348 NOT_PRODUCT( | |
| 1349 Atomic::inc(&_numObjectsPromoted); | |
| 1350 Atomic::add((jint)CompactibleFreeListSpace::adjustObjectSize(obj->size()), | |
| 1351 &_numWordsPromoted); | |
| 1352 ) | |
| 1353 | |
| 1354 return obj; | |
| 1355 } | |
| 1356 | |
| 1357 void | |
| 1358 ConcurrentMarkSweepGeneration:: | |
| 1359 par_promote_alloc_undo(int thread_num, | |
| 1360 HeapWord* obj, size_t word_sz) { | |
| 1361 // CMS does not support promotion undo. | |
| 1362 ShouldNotReachHere(); | |
| 1363 } | |
| 1364 | |
| 1365 void | |
| 1366 ConcurrentMarkSweepGeneration:: | |
| 1367 par_promote_alloc_done(int thread_num) { | |
| 1368 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
| 1369 ps->lab.retire(); | |
| 1370 #if CFLS_LAB_REFILL_STATS | |
| 1371 if (thread_num == 0) { | |
| 1372 _cmsSpace->print_par_alloc_stats(); | |
| 1373 } | |
| 1374 #endif | |
| 1375 } | |
| 1376 | |
| 1377 void | |
| 1378 ConcurrentMarkSweepGeneration:: | |
| 1379 par_oop_since_save_marks_iterate_done(int thread_num) { | |
| 1380 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
| 1381 ParScanWithoutBarrierClosure* dummy_cl = NULL; | |
| 1382 ps->promo.promoted_oops_iterate_nv(dummy_cl); | |
| 1383 } | |
| 1384 | |
| 1385 // XXXPERM | |
| 1386 bool ConcurrentMarkSweepGeneration::should_collect(bool full, | |
| 1387 size_t size, | |
| 1388 bool tlab) | |
| 1389 { | |
| 1390 // We allow a STW collection only if a full | |
| 1391 // collection was requested. | |
| 1392 return full || should_allocate(size, tlab); // FIX ME !!! | |
| 1393 // This and promotion failure handling are connected at the | |
| 1394 // hip and should be fixed by untying them. | |
| 1395 } | |
| 1396 | |
| 1397 bool CMSCollector::shouldConcurrentCollect() { | |
| 1398 if (_full_gc_requested) { | |
| 1399 assert(ExplicitGCInvokesConcurrent, "Unexpected state"); | |
| 1400 if (Verbose && PrintGCDetails) { | |
| 1401 gclog_or_tty->print_cr("CMSCollector: collect because of explicit " | |
| 1402 " gc request"); | |
| 1403 } | |
| 1404 return true; | |
| 1405 } | |
| 1406 | |
| 1407 // For debugging purposes, change the type of collection. | |
| 1408 // If the rotation is not on the concurrent collection | |
| 1409 // type, don't start a concurrent collection. | |
| 1410 NOT_PRODUCT( | |
| 1411 if (RotateCMSCollectionTypes && | |
| 1412 (_cmsGen->debug_collection_type() != | |
| 1413 ConcurrentMarkSweepGeneration::Concurrent_collection_type)) { | |
| 1414 assert(_cmsGen->debug_collection_type() != | |
| 1415 ConcurrentMarkSweepGeneration::Unknown_collection_type, | |
| 1416 "Bad cms collection type"); | |
| 1417 return false; | |
| 1418 } | |
| 1419 ) | |
| 1420 | |
| 1421 FreelistLocker x(this); | |
| 1422 // ------------------------------------------------------------------ | |
| 1423 // Print out lots of information which affects the initiation of | |
| 1424 // a collection. | |
| 1425 if (PrintCMSInitiationStatistics && stats().valid()) { | |
| 1426 gclog_or_tty->print("CMSCollector shouldConcurrentCollect: "); | |
| 1427 gclog_or_tty->stamp(); | |
| 1428 gclog_or_tty->print_cr(""); | |
| 1429 stats().print_on(gclog_or_tty); | |
| 1430 gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f", | |
| 1431 stats().time_until_cms_gen_full()); | |
| 1432 gclog_or_tty->print_cr("free="SIZE_FORMAT, _cmsGen->free()); | |
| 1433 gclog_or_tty->print_cr("contiguous_available="SIZE_FORMAT, | |
| 1434 _cmsGen->contiguous_available()); | |
| 1435 gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate()); | |
| 1436 gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate()); | |
| 1437 gclog_or_tty->print_cr("occupancy=%3.7f", _cmsGen->occupancy()); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1438 gclog_or_tty->print_cr("initiatingOccupancy=%3.7f", _cmsGen->initiating_occupancy()); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1439 gclog_or_tty->print_cr("initiatingPermOccupancy=%3.7f", _permGen->initiating_occupancy()); |
| 0 | 1440 } |
| 1441 // ------------------------------------------------------------------ | |
| 1442 | |
| 1443 // If the estimated time to complete a cms collection (cms_duration()) | |
| 1444 // is less than the estimated time remaining until the cms generation | |
| 1445 // is full, start a collection. | |
| 1446 if (!UseCMSInitiatingOccupancyOnly) { | |
| 1447 if (stats().valid()) { | |
| 1448 if (stats().time_until_cms_start() == 0.0) { | |
| 1449 return true; | |
| 1450 } | |
| 1451 } else { | |
| 1452 // We want to conservatively collect somewhat early in order | |
| 1453 // to try and "bootstrap" our CMS/promotion statistics; | |
| 1454 // this branch will not fire after the first successful CMS | |
| 1455 // collection because the stats should then be valid. | |
| 1456 if (_cmsGen->occupancy() >= _bootstrap_occupancy) { | |
| 1457 if (Verbose && PrintGCDetails) { | |
| 1458 gclog_or_tty->print_cr( | |
| 1459 " CMSCollector: collect for bootstrapping statistics:" | |
| 1460 " occupancy = %f, boot occupancy = %f", _cmsGen->occupancy(), | |
| 1461 _bootstrap_occupancy); | |
| 1462 } | |
| 1463 return true; | |
| 1464 } | |
| 1465 } | |
| 1466 } | |
| 1467 | |
| 1468 // Otherwise, we start a collection cycle if either the perm gen or | |
| 1469 // old gen want a collection cycle started. Each may use | |
| 1470 // an appropriate criterion for making this decision. | |
| 1471 // XXX We need to make sure that the gen expansion | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1472 // criterion dovetails well with this. XXX NEED TO FIX THIS |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1473 if (_cmsGen->should_concurrent_collect()) { |
| 0 | 1474 if (Verbose && PrintGCDetails) { |
| 1475 gclog_or_tty->print_cr("CMS old gen initiated"); | |
| 1476 } | |
| 1477 return true; | |
| 1478 } | |
| 1479 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1480 // We start a collection if we believe an incremental collection may fail; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1481 // this is not likely to be productive in practice because it's probably too |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1482 // late anyway. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1483 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1484 assert(gch->collector_policy()->is_two_generation_policy(), |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1485 "You may want to check the correctness of the following"); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1486 if (gch->incremental_collection_will_fail()) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1487 if (PrintGCDetails && Verbose) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1488 gclog_or_tty->print("CMSCollector: collect because incremental collection will fail "); |
| 0 | 1489 } |
| 1490 return true; | |
| 1491 } | |
| 1492 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1493 if (CMSClassUnloadingEnabled && _permGen->should_concurrent_collect()) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1494 bool res = update_should_unload_classes(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1495 if (res) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1496 if (Verbose && PrintGCDetails) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1497 gclog_or_tty->print_cr("CMS perm gen initiated"); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1498 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1499 return true; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1500 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1501 } |
| 0 | 1502 return false; |
| 1503 } | |
| 1504 | |
| 1505 // Clear _expansion_cause fields of constituent generations | |
| 1506 void CMSCollector::clear_expansion_cause() { | |
| 1507 _cmsGen->clear_expansion_cause(); | |
| 1508 _permGen->clear_expansion_cause(); | |
| 1509 } | |
| 1510 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1511 // We should be conservative in starting a collection cycle. To |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1512 // start too eagerly runs the risk of collecting too often in the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1513 // extreme. To collect too rarely falls back on full collections, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1514 // which works, even if not optimum in terms of concurrent work. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1515 // As a work around for too eagerly collecting, use the flag |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1516 // UseCMSInitiatingOccupancyOnly. This also has the advantage of |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1517 // giving the user an easily understandable way of controlling the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1518 // collections. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1519 // We want to start a new collection cycle if any of the following |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1520 // conditions hold: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1521 // . our current occupancy exceeds the configured initiating occupancy |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1522 // for this generation, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1523 // . we recently needed to expand this space and have not, since that |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1524 // expansion, done a collection of this generation, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1525 // . the underlying space believes that it may be a good idea to initiate |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1526 // a concurrent collection (this may be based on criteria such as the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1527 // following: the space uses linear allocation and linear allocation is |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1528 // going to fail, or there is believed to be excessive fragmentation in |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1529 // the generation, etc... or ... |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1530 // [.(currently done by CMSCollector::shouldConcurrentCollect() only for |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1531 // the case of the old generation, not the perm generation; see CR 6543076): |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1532 // we may be approaching a point at which allocation requests may fail because |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1533 // we will be out of sufficient free space given allocation rate estimates.] |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1534 bool ConcurrentMarkSweepGeneration::should_concurrent_collect() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1535 |
| 0 | 1536 assert_lock_strong(freelistLock()); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1537 if (occupancy() > initiating_occupancy()) { |
| 0 | 1538 if (PrintGCDetails && Verbose) { |
| 1539 gclog_or_tty->print(" %s: collect because of occupancy %f / %f ", | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1540 short_name(), occupancy(), initiating_occupancy()); |
| 0 | 1541 } |
| 1542 return true; | |
| 1543 } | |
| 1544 if (UseCMSInitiatingOccupancyOnly) { | |
| 1545 return false; | |
| 1546 } | |
| 1547 if (expansion_cause() == CMSExpansionCause::_satisfy_allocation) { | |
| 1548 if (PrintGCDetails && Verbose) { | |
| 1549 gclog_or_tty->print(" %s: collect because expanded for allocation ", | |
| 1550 short_name()); | |
| 1551 } | |
| 1552 return true; | |
| 1553 } | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1554 if (_cmsSpace->should_concurrent_collect()) { |
| 0 | 1555 if (PrintGCDetails && Verbose) { |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1556 gclog_or_tty->print(" %s: collect because cmsSpace says so ", |
| 0 | 1557 short_name()); |
| 1558 } | |
| 1559 return true; | |
| 1560 } | |
| 1561 return false; | |
| 1562 } | |
| 1563 | |
| 1564 void ConcurrentMarkSweepGeneration::collect(bool full, | |
| 1565 bool clear_all_soft_refs, | |
| 1566 size_t size, | |
| 1567 bool tlab) | |
| 1568 { | |
| 1569 collector()->collect(full, clear_all_soft_refs, size, tlab); | |
| 1570 } | |
| 1571 | |
| 1572 void CMSCollector::collect(bool full, | |
| 1573 bool clear_all_soft_refs, | |
| 1574 size_t size, | |
| 1575 bool tlab) | |
| 1576 { | |
| 1577 if (!UseCMSCollectionPassing && _collectorState > Idling) { | |
| 1578 // For debugging purposes skip the collection if the state | |
| 1579 // is not currently idle | |
| 1580 if (TraceCMSState) { | |
| 1581 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " skipped full:%d CMS state %d", | |
| 1582 Thread::current(), full, _collectorState); | |
| 1583 } | |
| 1584 return; | |
| 1585 } | |
| 1586 | |
| 1587 // The following "if" branch is present for defensive reasons. | |
| 1588 // In the current uses of this interface, it can be replaced with: | |
| 1589 // assert(!GC_locker.is_active(), "Can't be called otherwise"); | |
| 1590 // But I am not placing that assert here to allow future | |
| 1591 // generality in invoking this interface. | |
| 1592 if (GC_locker::is_active()) { | |
| 1593 // A consistency test for GC_locker | |
| 1594 assert(GC_locker::needs_gc(), "Should have been set already"); | |
| 1595 // Skip this foreground collection, instead | |
| 1596 // expanding the heap if necessary. | |
| 1597 // Need the free list locks for the call to free() in compute_new_size() | |
| 1598 compute_new_size(); | |
| 1599 return; | |
| 1600 } | |
| 1601 acquire_control_and_collect(full, clear_all_soft_refs); | |
| 1602 _full_gcs_since_conc_gc++; | |
| 1603 | |
| 1604 } | |
| 1605 | |
| 1606 void CMSCollector::request_full_gc(unsigned int full_gc_count) { | |
| 1607 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1608 unsigned int gc_count = gch->total_full_collections(); | |
| 1609 if (gc_count == full_gc_count) { | |
| 1610 MutexLockerEx y(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 1611 _full_gc_requested = true; | |
| 1612 CGC_lock->notify(); // nudge CMS thread | |
| 1613 } | |
| 1614 } | |
| 1615 | |
| 1616 | |
| 1617 // The foreground and background collectors need to coordinate in order | |
| 1618 // to make sure that they do not mutually interfere with CMS collections. | |
| 1619 // When a background collection is active, | |
| 1620 // the foreground collector may need to take over (preempt) and | |
| 1621 // synchronously complete an ongoing collection. Depending on the | |
| 1622 // frequency of the background collections and the heap usage | |
| 1623 // of the application, this preemption can be seldom or frequent. | |
| 1624 // There are only certain | |
| 1625 // points in the background collection that the "collection-baton" | |
| 1626 // can be passed to the foreground collector. | |
| 1627 // | |
| 1628 // The foreground collector will wait for the baton before | |
| 1629 // starting any part of the collection. The foreground collector | |
| 1630 // will only wait at one location. | |
| 1631 // | |
| 1632 // The background collector will yield the baton before starting a new | |
| 1633 // phase of the collection (e.g., before initial marking, marking from roots, | |
| 1634 // precleaning, final re-mark, sweep etc.) This is normally done at the head | |
| 1635 // of the loop which switches the phases. The background collector does some | |
| 1636 // of the phases (initial mark, final re-mark) with the world stopped. | |
| 1637 // Because of locking involved in stopping the world, | |
| 1638 // the foreground collector should not block waiting for the background | |
| 1639 // collector when it is doing a stop-the-world phase. The background | |
| 1640 // collector will yield the baton at an additional point just before | |
| 1641 // it enters a stop-the-world phase. Once the world is stopped, the | |
| 1642 // background collector checks the phase of the collection. If the | |
| 1643 // phase has not changed, it proceeds with the collection. If the | |
| 1644 // phase has changed, it skips that phase of the collection. See | |
| 1645 // the comments on the use of the Heap_lock in collect_in_background(). | |
| 1646 // | |
| 1647 // Variable used in baton passing. | |
| 1648 // _foregroundGCIsActive - Set to true by the foreground collector when | |
| 1649 // it wants the baton. The foreground clears it when it has finished | |
| 1650 // the collection. | |
| 1651 // _foregroundGCShouldWait - Set to true by the background collector | |
| 1652 // when it is running. The foreground collector waits while | |
| 1653 // _foregroundGCShouldWait is true. | |
| 1654 // CGC_lock - monitor used to protect access to the above variables | |
| 1655 // and to notify the foreground and background collectors. | |
| 1656 // _collectorState - current state of the CMS collection. | |
| 1657 // | |
| 1658 // The foreground collector | |
| 1659 // acquires the CGC_lock | |
| 1660 // sets _foregroundGCIsActive | |
| 1661 // waits on the CGC_lock for _foregroundGCShouldWait to be false | |
| 1662 // various locks acquired in preparation for the collection | |
| 1663 // are released so as not to block the background collector | |
| 1664 // that is in the midst of a collection | |
| 1665 // proceeds with the collection | |
| 1666 // clears _foregroundGCIsActive | |
| 1667 // returns | |
| 1668 // | |
| 1669 // The background collector in a loop iterating on the phases of the | |
| 1670 // collection | |
| 1671 // acquires the CGC_lock | |
| 1672 // sets _foregroundGCShouldWait | |
| 1673 // if _foregroundGCIsActive is set | |
| 1674 // clears _foregroundGCShouldWait, notifies _CGC_lock | |
| 1675 // waits on _CGC_lock for _foregroundGCIsActive to become false | |
| 1676 // and exits the loop. | |
| 1677 // otherwise | |
| 1678 // proceed with that phase of the collection | |
| 1679 // if the phase is a stop-the-world phase, | |
| 1680 // yield the baton once more just before enqueueing | |
| 1681 // the stop-world CMS operation (executed by the VM thread). | |
| 1682 // returns after all phases of the collection are done | |
| 1683 // | |
| 1684 | |
| 1685 void CMSCollector::acquire_control_and_collect(bool full, | |
| 1686 bool clear_all_soft_refs) { | |
| 1687 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); | |
| 1688 assert(!Thread::current()->is_ConcurrentGC_thread(), | |
| 1689 "shouldn't try to acquire control from self!"); | |
| 1690 | |
| 1691 // Start the protocol for acquiring control of the | |
| 1692 // collection from the background collector (aka CMS thread). | |
| 1693 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 1694 "VM thread should have CMS token"); | |
| 1695 // Remember the possibly interrupted state of an ongoing | |
| 1696 // concurrent collection | |
| 1697 CollectorState first_state = _collectorState; | |
| 1698 | |
| 1699 // Signal to a possibly ongoing concurrent collection that | |
| 1700 // we want to do a foreground collection. | |
| 1701 _foregroundGCIsActive = true; | |
| 1702 | |
| 1703 // Disable incremental mode during a foreground collection. | |
| 1704 ICMSDisabler icms_disabler; | |
| 1705 | |
| 1706 // release locks and wait for a notify from the background collector | |
| 1707 // releasing the locks in only necessary for phases which | |
| 1708 // do yields to improve the granularity of the collection. | |
| 1709 assert_lock_strong(bitMapLock()); | |
| 1710 // We need to lock the Free list lock for the space that we are | |
| 1711 // currently collecting. | |
| 1712 assert(haveFreelistLocks(), "Must be holding free list locks"); | |
| 1713 bitMapLock()->unlock(); | |
| 1714 releaseFreelistLocks(); | |
| 1715 { | |
| 1716 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 1717 if (_foregroundGCShouldWait) { | |
| 1718 // We are going to be waiting for action for the CMS thread; | |
| 1719 // it had better not be gone (for instance at shutdown)! | |
| 1720 assert(ConcurrentMarkSweepThread::cmst() != NULL, | |
| 1721 "CMS thread must be running"); | |
| 1722 // Wait here until the background collector gives us the go-ahead | |
| 1723 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 1724 ConcurrentMarkSweepThread::CMS_vm_has_token); // release token | |
| 1725 // Get a possibly blocked CMS thread going: | |
| 1726 // Note that we set _foregroundGCIsActive true above, | |
| 1727 // without protection of the CGC_lock. | |
| 1728 CGC_lock->notify(); | |
| 1729 assert(!ConcurrentMarkSweepThread::vm_thread_wants_cms_token(), | |
| 1730 "Possible deadlock"); | |
| 1731 while (_foregroundGCShouldWait) { | |
| 1732 // wait for notification | |
| 1733 CGC_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 1734 // Possibility of delay/starvation here, since CMS token does | |
| 1735 // not know to give priority to VM thread? Actually, i think | |
| 1736 // there wouldn't be any delay/starvation, but the proof of | |
| 1737 // that "fact" (?) appears non-trivial. XXX 20011219YSR | |
| 1738 } | |
| 1739 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 1740 ConcurrentMarkSweepThread::CMS_vm_has_token); | |
| 1741 } | |
| 1742 } | |
| 1743 // The CMS_token is already held. Get back the other locks. | |
| 1744 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 1745 "VM thread should have CMS token"); | |
| 1746 getFreelistLocks(); | |
| 1747 bitMapLock()->lock_without_safepoint_check(); | |
| 1748 if (TraceCMSState) { | |
| 1749 gclog_or_tty->print_cr("CMS foreground collector has asked for control " | |
| 1750 INTPTR_FORMAT " with first state %d", Thread::current(), first_state); | |
| 1751 gclog_or_tty->print_cr(" gets control with state %d", _collectorState); | |
| 1752 } | |
| 1753 | |
| 1754 // Check if we need to do a compaction, or if not, whether | |
| 1755 // we need to start the mark-sweep from scratch. | |
| 1756 bool should_compact = false; | |
| 1757 bool should_start_over = false; | |
| 1758 decide_foreground_collection_type(clear_all_soft_refs, | |
| 1759 &should_compact, &should_start_over); | |
| 1760 | |
| 1761 NOT_PRODUCT( | |
| 1762 if (RotateCMSCollectionTypes) { | |
| 1763 if (_cmsGen->debug_collection_type() == | |
| 1764 ConcurrentMarkSweepGeneration::MSC_foreground_collection_type) { | |
| 1765 should_compact = true; | |
| 1766 } else if (_cmsGen->debug_collection_type() == | |
| 1767 ConcurrentMarkSweepGeneration::MS_foreground_collection_type) { | |
| 1768 should_compact = false; | |
| 1769 } | |
| 1770 } | |
| 1771 ) | |
| 1772 | |
| 1773 if (PrintGCDetails && first_state > Idling) { | |
| 1774 GCCause::Cause cause = GenCollectedHeap::heap()->gc_cause(); | |
| 1775 if (GCCause::is_user_requested_gc(cause) || | |
| 1776 GCCause::is_serviceability_requested_gc(cause)) { | |
| 1777 gclog_or_tty->print(" (concurrent mode interrupted)"); | |
| 1778 } else { | |
| 1779 gclog_or_tty->print(" (concurrent mode failure)"); | |
| 1780 } | |
| 1781 } | |
| 1782 | |
| 1783 if (should_compact) { | |
| 1784 // If the collection is being acquired from the background | |
| 1785 // collector, there may be references on the discovered | |
| 1786 // references lists that have NULL referents (being those | |
| 1787 // that were concurrently cleared by a mutator) or | |
| 1788 // that are no longer active (having been enqueued concurrently | |
| 1789 // by the mutator). | |
| 1790 // Scrub the list of those references because Mark-Sweep-Compact | |
| 1791 // code assumes referents are not NULL and that all discovered | |
| 1792 // Reference objects are active. | |
| 1793 ref_processor()->clean_up_discovered_references(); | |
| 1794 | |
| 1795 do_compaction_work(clear_all_soft_refs); | |
| 1796 | |
| 1797 // Has the GC time limit been exceeded? | |
| 1798 check_gc_time_limit(); | |
| 1799 | |
| 1800 } else { | |
| 1801 do_mark_sweep_work(clear_all_soft_refs, first_state, | |
| 1802 should_start_over); | |
| 1803 } | |
| 1804 // Reset the expansion cause, now that we just completed | |
| 1805 // a collection cycle. | |
| 1806 clear_expansion_cause(); | |
| 1807 _foregroundGCIsActive = false; | |
| 1808 return; | |
| 1809 } | |
| 1810 | |
| 1811 void CMSCollector::check_gc_time_limit() { | |
| 1812 | |
| 1813 // Ignore explicit GC's. Exiting here does not set the flag and | |
| 1814 // does not reset the count. Updating of the averages for system | |
| 1815 // GC's is still controlled by UseAdaptiveSizePolicyWithSystemGC. | |
| 1816 GCCause::Cause gc_cause = GenCollectedHeap::heap()->gc_cause(); | |
| 1817 if (GCCause::is_user_requested_gc(gc_cause) || | |
| 1818 GCCause::is_serviceability_requested_gc(gc_cause)) { | |
| 1819 return; | |
| 1820 } | |
| 1821 | |
| 1822 // Calculate the fraction of the CMS generation was freed during | |
| 1823 // the last collection. | |
| 1824 // Only consider the STW compacting cost for now. | |
| 1825 // | |
| 1826 // Note that the gc time limit test only works for the collections | |
| 1827 // of the young gen + tenured gen and not for collections of the | |
| 1828 // permanent gen. That is because the calculation of the space | |
| 1829 // freed by the collection is the free space in the young gen + | |
| 1830 // tenured gen. | |
| 1831 | |
| 1832 double fraction_free = | |
| 1833 ((double)_cmsGen->free())/((double)_cmsGen->max_capacity()); | |
| 1834 if ((100.0 * size_policy()->compacting_gc_cost()) > | |
| 1835 ((double) GCTimeLimit) && | |
| 1836 ((fraction_free * 100) < GCHeapFreeLimit)) { | |
| 1837 size_policy()->inc_gc_time_limit_count(); | |
| 1838 if (UseGCOverheadLimit && | |
| 1839 (size_policy()->gc_time_limit_count() > | |
| 1840 AdaptiveSizePolicyGCTimeLimitThreshold)) { | |
| 1841 size_policy()->set_gc_time_limit_exceeded(true); | |
| 1842 // Avoid consecutive OOM due to the gc time limit by resetting | |
| 1843 // the counter. | |
| 1844 size_policy()->reset_gc_time_limit_count(); | |
| 1845 if (PrintGCDetails) { | |
| 1846 gclog_or_tty->print_cr(" GC is exceeding overhead limit " | |
| 1847 "of %d%%", GCTimeLimit); | |
| 1848 } | |
| 1849 } else { | |
| 1850 if (PrintGCDetails) { | |
| 1851 gclog_or_tty->print_cr(" GC would exceed overhead limit " | |
| 1852 "of %d%%", GCTimeLimit); | |
| 1853 } | |
| 1854 } | |
| 1855 } else { | |
| 1856 size_policy()->reset_gc_time_limit_count(); | |
| 1857 } | |
| 1858 } | |
| 1859 | |
| 1860 // Resize the perm generation and the tenured generation | |
| 1861 // after obtaining the free list locks for the | |
| 1862 // two generations. | |
| 1863 void CMSCollector::compute_new_size() { | |
| 1864 assert_locked_or_safepoint(Heap_lock); | |
| 1865 FreelistLocker z(this); | |
| 1866 _permGen->compute_new_size(); | |
| 1867 _cmsGen->compute_new_size(); | |
| 1868 } | |
| 1869 | |
| 1870 // A work method used by foreground collection to determine | |
| 1871 // what type of collection (compacting or not, continuing or fresh) | |
| 1872 // it should do. | |
| 1873 // NOTE: the intent is to make UseCMSCompactAtFullCollection | |
| 1874 // and CMSCompactWhenClearAllSoftRefs the default in the future | |
| 1875 // and do away with the flags after a suitable period. | |
| 1876 void CMSCollector::decide_foreground_collection_type( | |
| 1877 bool clear_all_soft_refs, bool* should_compact, | |
| 1878 bool* should_start_over) { | |
| 1879 // Normally, we'll compact only if the UseCMSCompactAtFullCollection | |
| 1880 // flag is set, and we have either requested a System.gc() or | |
| 1881 // the number of full gc's since the last concurrent cycle | |
| 1882 // has exceeded the threshold set by CMSFullGCsBeforeCompaction, | |
| 1883 // or if an incremental collection has failed | |
| 1884 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1885 assert(gch->collector_policy()->is_two_generation_policy(), | |
| 1886 "You may want to check the correctness of the following"); | |
| 1887 // Inform cms gen if this was due to partial collection failing. | |
| 1888 // The CMS gen may use this fact to determine its expansion policy. | |
| 1889 if (gch->incremental_collection_will_fail()) { | |
| 1890 assert(!_cmsGen->incremental_collection_failed(), | |
| 1891 "Should have been noticed, reacted to and cleared"); | |
| 1892 _cmsGen->set_incremental_collection_failed(); | |
| 1893 } | |
| 1894 *should_compact = | |
| 1895 UseCMSCompactAtFullCollection && | |
| 1896 ((_full_gcs_since_conc_gc >= CMSFullGCsBeforeCompaction) || | |
| 1897 GCCause::is_user_requested_gc(gch->gc_cause()) || | |
| 1898 gch->incremental_collection_will_fail()); | |
| 1899 *should_start_over = false; | |
| 1900 if (clear_all_soft_refs && !*should_compact) { | |
| 1901 // We are about to do a last ditch collection attempt | |
| 1902 // so it would normally make sense to do a compaction | |
| 1903 // to reclaim as much space as possible. | |
| 1904 if (CMSCompactWhenClearAllSoftRefs) { | |
| 1905 // Default: The rationale is that in this case either | |
| 1906 // we are past the final marking phase, in which case | |
| 1907 // we'd have to start over, or so little has been done | |
| 1908 // that there's little point in saving that work. Compaction | |
| 1909 // appears to be the sensible choice in either case. | |
| 1910 *should_compact = true; | |
| 1911 } else { | |
| 1912 // We have been asked to clear all soft refs, but not to | |
| 1913 // compact. Make sure that we aren't past the final checkpoint | |
| 1914 // phase, for that is where we process soft refs. If we are already | |
| 1915 // past that phase, we'll need to redo the refs discovery phase and | |
| 1916 // if necessary clear soft refs that weren't previously | |
| 1917 // cleared. We do so by remembering the phase in which | |
| 1918 // we came in, and if we are past the refs processing | |
| 1919 // phase, we'll choose to just redo the mark-sweep | |
| 1920 // collection from scratch. | |
| 1921 if (_collectorState > FinalMarking) { | |
| 1922 // We are past the refs processing phase; | |
| 1923 // start over and do a fresh synchronous CMS cycle | |
| 1924 _collectorState = Resetting; // skip to reset to start new cycle | |
| 1925 reset(false /* == !asynch */); | |
| 1926 *should_start_over = true; | |
| 1927 } // else we can continue a possibly ongoing current cycle | |
| 1928 } | |
| 1929 } | |
| 1930 } | |
| 1931 | |
| 1932 // A work method used by the foreground collector to do | |
| 1933 // a mark-sweep-compact. | |
| 1934 void CMSCollector::do_compaction_work(bool clear_all_soft_refs) { | |
| 1935 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1936 TraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 1937 if (PrintGC && Verbose && !(GCCause::is_user_requested_gc(gch->gc_cause()))) { | |
| 1938 gclog_or_tty->print_cr("Compact ConcurrentMarkSweepGeneration after %d " | |
| 1939 "collections passed to foreground collector", _full_gcs_since_conc_gc); | |
| 1940 } | |
| 1941 | |
| 1942 // Sample collection interval time and reset for collection pause. | |
| 1943 if (UseAdaptiveSizePolicy) { | |
| 1944 size_policy()->msc_collection_begin(); | |
| 1945 } | |
| 1946 | |
| 1947 // Temporarily widen the span of the weak reference processing to | |
| 1948 // the entire heap. | |
| 1949 MemRegion new_span(GenCollectedHeap::heap()->reserved_region()); | |
| 1950 ReferenceProcessorSpanMutator x(ref_processor(), new_span); | |
| 1951 | |
| 1952 // Temporarily, clear the "is_alive_non_header" field of the | |
| 1953 // reference processor. | |
| 1954 ReferenceProcessorIsAliveMutator y(ref_processor(), NULL); | |
| 1955 | |
| 1956 // Temporarily make reference _processing_ single threaded (non-MT). | |
| 1957 ReferenceProcessorMTProcMutator z(ref_processor(), false); | |
| 1958 | |
| 1959 // Temporarily make refs discovery atomic | |
| 1960 ReferenceProcessorAtomicMutator w(ref_processor(), true); | |
| 1961 | |
| 1962 ref_processor()->set_enqueuing_is_done(false); | |
| 1963 ref_processor()->enable_discovery(); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
1964 ref_processor()->snap_policy(clear_all_soft_refs); |
| 0 | 1965 // If an asynchronous collection finishes, the _modUnionTable is |
| 1966 // all clear. If we are assuming the collection from an asynchronous | |
| 1967 // collection, clear the _modUnionTable. | |
| 1968 assert(_collectorState != Idling || _modUnionTable.isAllClear(), | |
| 1969 "_modUnionTable should be clear if the baton was not passed"); | |
| 1970 _modUnionTable.clear_all(); | |
| 1971 | |
| 1972 // We must adjust the allocation statistics being maintained | |
| 1973 // in the free list space. We do so by reading and clearing | |
| 1974 // the sweep timer and updating the block flux rate estimates below. | |
| 1975 assert(_sweep_timer.is_active(), "We should never see the timer inactive"); | |
| 1976 _sweep_timer.stop(); | |
| 1977 // Note that we do not use this sample to update the _sweep_estimate. | |
| 1978 _cmsGen->cmsSpace()->beginSweepFLCensus((float)(_sweep_timer.seconds()), | |
| 1979 _sweep_estimate.padded_average()); | |
| 1980 | |
| 1981 GenMarkSweep::invoke_at_safepoint(_cmsGen->level(), | |
| 1982 ref_processor(), clear_all_soft_refs); | |
| 1983 #ifdef ASSERT | |
| 1984 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); | |
| 1985 size_t free_size = cms_space->free(); | |
| 1986 assert(free_size == | |
| 1987 pointer_delta(cms_space->end(), cms_space->compaction_top()) | |
| 1988 * HeapWordSize, | |
| 1989 "All the free space should be compacted into one chunk at top"); | |
| 1990 assert(cms_space->dictionary()->totalChunkSize( | |
| 1991 debug_only(cms_space->freelistLock())) == 0 || | |
| 1992 cms_space->totalSizeInIndexedFreeLists() == 0, | |
| 1993 "All the free space should be in a single chunk"); | |
| 1994 size_t num = cms_space->totalCount(); | |
| 1995 assert((free_size == 0 && num == 0) || | |
| 1996 (free_size > 0 && (num == 1 || num == 2)), | |
| 1997 "There should be at most 2 free chunks after compaction"); | |
| 1998 #endif // ASSERT | |
| 1999 _collectorState = Resetting; | |
| 2000 assert(_restart_addr == NULL, | |
| 2001 "Should have been NULL'd before baton was passed"); | |
| 2002 reset(false /* == !asynch */); | |
| 2003 _cmsGen->reset_after_compaction(); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2004 _concurrent_cycles_since_last_unload = 0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2005 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2006 if (verifying() && !should_unload_classes()) { |
| 0 | 2007 perm_gen_verify_bit_map()->clear_all(); |
| 2008 } | |
| 2009 | |
| 2010 // Clear any data recorded in the PLAB chunk arrays. | |
| 2011 if (_survivor_plab_array != NULL) { | |
| 2012 reset_survivor_plab_arrays(); | |
| 2013 } | |
| 2014 | |
| 2015 // Adjust the per-size allocation stats for the next epoch. | |
| 2016 _cmsGen->cmsSpace()->endSweepFLCensus(sweepCount() /* fake */); | |
| 2017 // Restart the "sweep timer" for next epoch. | |
| 2018 _sweep_timer.reset(); | |
| 2019 _sweep_timer.start(); | |
| 2020 | |
| 2021 // Sample collection pause time and reset for collection interval. | |
| 2022 if (UseAdaptiveSizePolicy) { | |
| 2023 size_policy()->msc_collection_end(gch->gc_cause()); | |
| 2024 } | |
| 2025 | |
| 2026 // For a mark-sweep-compact, compute_new_size() will be called | |
| 2027 // in the heap's do_collection() method. | |
| 2028 } | |
| 2029 | |
| 2030 // A work method used by the foreground collector to do | |
| 2031 // a mark-sweep, after taking over from a possibly on-going | |
| 2032 // concurrent mark-sweep collection. | |
| 2033 void CMSCollector::do_mark_sweep_work(bool clear_all_soft_refs, | |
| 2034 CollectorState first_state, bool should_start_over) { | |
| 2035 if (PrintGC && Verbose) { | |
| 2036 gclog_or_tty->print_cr("Pass concurrent collection to foreground " | |
| 2037 "collector with count %d", | |
| 2038 _full_gcs_since_conc_gc); | |
| 2039 } | |
| 2040 switch (_collectorState) { | |
| 2041 case Idling: | |
| 2042 if (first_state == Idling || should_start_over) { | |
| 2043 // The background GC was not active, or should | |
| 2044 // restarted from scratch; start the cycle. | |
| 2045 _collectorState = InitialMarking; | |
| 2046 } | |
| 2047 // If first_state was not Idling, then a background GC | |
| 2048 // was in progress and has now finished. No need to do it | |
| 2049 // again. Leave the state as Idling. | |
| 2050 break; | |
| 2051 case Precleaning: | |
| 2052 // In the foreground case don't do the precleaning since | |
| 2053 // it is not done concurrently and there is extra work | |
| 2054 // required. | |
| 2055 _collectorState = FinalMarking; | |
| 2056 } | |
| 2057 if (PrintGCDetails && | |
| 2058 (_collectorState > Idling || | |
| 2059 !GCCause::is_user_requested_gc(GenCollectedHeap::heap()->gc_cause()))) { | |
| 2060 gclog_or_tty->print(" (concurrent mode failure)"); | |
| 2061 } | |
| 2062 collect_in_foreground(clear_all_soft_refs); | |
| 2063 | |
| 2064 // For a mark-sweep, compute_new_size() will be called | |
| 2065 // in the heap's do_collection() method. | |
| 2066 } | |
| 2067 | |
| 2068 | |
| 2069 void CMSCollector::getFreelistLocks() const { | |
| 2070 // Get locks for all free lists in all generations that this | |
| 2071 // collector is responsible for | |
| 2072 _cmsGen->freelistLock()->lock_without_safepoint_check(); | |
| 2073 _permGen->freelistLock()->lock_without_safepoint_check(); | |
| 2074 } | |
| 2075 | |
| 2076 void CMSCollector::releaseFreelistLocks() const { | |
| 2077 // Release locks for all free lists in all generations that this | |
| 2078 // collector is responsible for | |
| 2079 _cmsGen->freelistLock()->unlock(); | |
| 2080 _permGen->freelistLock()->unlock(); | |
| 2081 } | |
| 2082 | |
| 2083 bool CMSCollector::haveFreelistLocks() const { | |
| 2084 // Check locks for all free lists in all generations that this | |
| 2085 // collector is responsible for | |
| 2086 assert_lock_strong(_cmsGen->freelistLock()); | |
| 2087 assert_lock_strong(_permGen->freelistLock()); | |
| 2088 PRODUCT_ONLY(ShouldNotReachHere()); | |
| 2089 return true; | |
| 2090 } | |
| 2091 | |
| 2092 // A utility class that is used by the CMS collector to | |
| 2093 // temporarily "release" the foreground collector from its | |
| 2094 // usual obligation to wait for the background collector to | |
| 2095 // complete an ongoing phase before proceeding. | |
| 2096 class ReleaseForegroundGC: public StackObj { | |
| 2097 private: | |
| 2098 CMSCollector* _c; | |
| 2099 public: | |
| 2100 ReleaseForegroundGC(CMSCollector* c) : _c(c) { | |
| 2101 assert(_c->_foregroundGCShouldWait, "Else should not need to call"); | |
| 2102 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2103 // allow a potentially blocked foreground collector to proceed | |
| 2104 _c->_foregroundGCShouldWait = false; | |
| 2105 if (_c->_foregroundGCIsActive) { | |
| 2106 CGC_lock->notify(); | |
| 2107 } | |
| 2108 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2109 "Possible deadlock"); | |
| 2110 } | |
| 2111 | |
| 2112 ~ReleaseForegroundGC() { | |
| 2113 assert(!_c->_foregroundGCShouldWait, "Usage protocol violation?"); | |
| 2114 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2115 _c->_foregroundGCShouldWait = true; | |
| 2116 } | |
| 2117 }; | |
| 2118 | |
| 2119 // There are separate collect_in_background and collect_in_foreground because of | |
| 2120 // the different locking requirements of the background collector and the | |
| 2121 // foreground collector. There was originally an attempt to share | |
| 2122 // one "collect" method between the background collector and the foreground | |
| 2123 // collector but the if-then-else required made it cleaner to have | |
| 2124 // separate methods. | |
| 2125 void CMSCollector::collect_in_background(bool clear_all_soft_refs) { | |
| 2126 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 2127 "A CMS asynchronous collection is only allowed on a CMS thread."); | |
| 2128 | |
| 2129 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2130 { | |
| 2131 bool safepoint_check = Mutex::_no_safepoint_check_flag; | |
| 2132 MutexLockerEx hl(Heap_lock, safepoint_check); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2133 FreelistLocker fll(this); |
| 0 | 2134 MutexLockerEx x(CGC_lock, safepoint_check); |
| 2135 if (_foregroundGCIsActive || !UseAsyncConcMarkSweepGC) { | |
| 2136 // The foreground collector is active or we're | |
| 2137 // not using asynchronous collections. Skip this | |
| 2138 // background collection. | |
| 2139 assert(!_foregroundGCShouldWait, "Should be clear"); | |
| 2140 return; | |
| 2141 } else { | |
| 2142 assert(_collectorState == Idling, "Should be idling before start."); | |
| 2143 _collectorState = InitialMarking; | |
| 2144 // Reset the expansion cause, now that we are about to begin | |
| 2145 // a new cycle. | |
| 2146 clear_expansion_cause(); | |
| 2147 } | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2148 // Decide if we want to enable class unloading as part of the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2149 // ensuing concurrent GC cycle. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2150 update_should_unload_classes(); |
| 0 | 2151 _full_gc_requested = false; // acks all outstanding full gc requests |
| 2152 // Signal that we are about to start a collection | |
| 2153 gch->increment_total_full_collections(); // ... starting a collection cycle | |
| 2154 _collection_count_start = gch->total_full_collections(); | |
| 2155 } | |
| 2156 | |
| 2157 // Used for PrintGC | |
| 2158 size_t prev_used; | |
| 2159 if (PrintGC && Verbose) { | |
| 2160 prev_used = _cmsGen->used(); // XXXPERM | |
| 2161 } | |
| 2162 | |
| 2163 // The change of the collection state is normally done at this level; | |
| 2164 // the exceptions are phases that are executed while the world is | |
| 2165 // stopped. For those phases the change of state is done while the | |
| 2166 // world is stopped. For baton passing purposes this allows the | |
| 2167 // background collector to finish the phase and change state atomically. | |
| 2168 // The foreground collector cannot wait on a phase that is done | |
| 2169 // while the world is stopped because the foreground collector already | |
| 2170 // has the world stopped and would deadlock. | |
| 2171 while (_collectorState != Idling) { | |
| 2172 if (TraceCMSState) { | |
| 2173 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d", | |
| 2174 Thread::current(), _collectorState); | |
| 2175 } | |
| 2176 // The foreground collector | |
| 2177 // holds the Heap_lock throughout its collection. | |
| 2178 // holds the CMS token (but not the lock) | |
| 2179 // except while it is waiting for the background collector to yield. | |
| 2180 // | |
| 2181 // The foreground collector should be blocked (not for long) | |
| 2182 // if the background collector is about to start a phase | |
| 2183 // executed with world stopped. If the background | |
| 2184 // collector has already started such a phase, the | |
| 2185 // foreground collector is blocked waiting for the | |
| 2186 // Heap_lock. The stop-world phases (InitialMarking and FinalMarking) | |
| 2187 // are executed in the VM thread. | |
| 2188 // | |
| 2189 // The locking order is | |
| 2190 // PendingListLock (PLL) -- if applicable (FinalMarking) | |
| 2191 // Heap_lock (both this & PLL locked in VM_CMS_Operation::prologue()) | |
| 2192 // CMS token (claimed in | |
| 2193 // stop_world_and_do() --> | |
| 2194 // safepoint_synchronize() --> | |
| 2195 // CMSThread::synchronize()) | |
| 2196 | |
| 2197 { | |
| 2198 // Check if the FG collector wants us to yield. | |
| 2199 CMSTokenSync x(true); // is cms thread | |
| 2200 if (waitForForegroundGC()) { | |
| 2201 // We yielded to a foreground GC, nothing more to be | |
| 2202 // done this round. | |
| 2203 assert(_foregroundGCShouldWait == false, "We set it to false in " | |
| 2204 "waitForForegroundGC()"); | |
| 2205 if (TraceCMSState) { | |
| 2206 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2207 " exiting collection CMS state %d", | |
| 2208 Thread::current(), _collectorState); | |
| 2209 } | |
| 2210 return; | |
| 2211 } else { | |
| 2212 // The background collector can run but check to see if the | |
| 2213 // foreground collector has done a collection while the | |
| 2214 // background collector was waiting to get the CGC_lock | |
| 2215 // above. If yes, break so that _foregroundGCShouldWait | |
| 2216 // is cleared before returning. | |
| 2217 if (_collectorState == Idling) { | |
| 2218 break; | |
| 2219 } | |
| 2220 } | |
| 2221 } | |
| 2222 | |
| 2223 assert(_foregroundGCShouldWait, "Foreground collector, if active, " | |
| 2224 "should be waiting"); | |
| 2225 | |
| 2226 switch (_collectorState) { | |
| 2227 case InitialMarking: | |
| 2228 { | |
| 2229 ReleaseForegroundGC x(this); | |
| 2230 stats().record_cms_begin(); | |
| 2231 | |
| 2232 VM_CMS_Initial_Mark initial_mark_op(this); | |
| 2233 VMThread::execute(&initial_mark_op); | |
| 2234 } | |
| 2235 // The collector state may be any legal state at this point | |
| 2236 // since the background collector may have yielded to the | |
| 2237 // foreground collector. | |
| 2238 break; | |
| 2239 case Marking: | |
| 2240 // initial marking in checkpointRootsInitialWork has been completed | |
| 2241 if (markFromRoots(true)) { // we were successful | |
| 2242 assert(_collectorState == Precleaning, "Collector state should " | |
| 2243 "have changed"); | |
| 2244 } else { | |
| 2245 assert(_foregroundGCIsActive, "Internal state inconsistency"); | |
| 2246 } | |
| 2247 break; | |
| 2248 case Precleaning: | |
| 2249 if (UseAdaptiveSizePolicy) { | |
| 2250 size_policy()->concurrent_precleaning_begin(); | |
| 2251 } | |
| 2252 // marking from roots in markFromRoots has been completed | |
| 2253 preclean(); | |
| 2254 if (UseAdaptiveSizePolicy) { | |
| 2255 size_policy()->concurrent_precleaning_end(); | |
| 2256 } | |
| 2257 assert(_collectorState == AbortablePreclean || | |
| 2258 _collectorState == FinalMarking, | |
| 2259 "Collector state should have changed"); | |
| 2260 break; | |
| 2261 case AbortablePreclean: | |
| 2262 if (UseAdaptiveSizePolicy) { | |
| 2263 size_policy()->concurrent_phases_resume(); | |
| 2264 } | |
| 2265 abortable_preclean(); | |
| 2266 if (UseAdaptiveSizePolicy) { | |
| 2267 size_policy()->concurrent_precleaning_end(); | |
| 2268 } | |
| 2269 assert(_collectorState == FinalMarking, "Collector state should " | |
| 2270 "have changed"); | |
| 2271 break; | |
| 2272 case FinalMarking: | |
| 2273 { | |
| 2274 ReleaseForegroundGC x(this); | |
| 2275 | |
| 2276 VM_CMS_Final_Remark final_remark_op(this); | |
| 2277 VMThread::execute(&final_remark_op); | |
| 2278 } | |
| 2279 assert(_foregroundGCShouldWait, "block post-condition"); | |
| 2280 break; | |
| 2281 case Sweeping: | |
| 2282 if (UseAdaptiveSizePolicy) { | |
| 2283 size_policy()->concurrent_sweeping_begin(); | |
| 2284 } | |
| 2285 // final marking in checkpointRootsFinal has been completed | |
| 2286 sweep(true); | |
| 2287 assert(_collectorState == Resizing, "Collector state change " | |
| 2288 "to Resizing must be done under the free_list_lock"); | |
| 2289 _full_gcs_since_conc_gc = 0; | |
| 2290 | |
| 2291 // Stop the timers for adaptive size policy for the concurrent phases | |
| 2292 if (UseAdaptiveSizePolicy) { | |
| 2293 size_policy()->concurrent_sweeping_end(); | |
| 2294 size_policy()->concurrent_phases_end(gch->gc_cause(), | |
| 2295 gch->prev_gen(_cmsGen)->capacity(), | |
| 2296 _cmsGen->free()); | |
| 2297 } | |
| 2298 | |
| 2299 case Resizing: { | |
| 2300 // Sweeping has been completed... | |
| 2301 // At this point the background collection has completed. | |
| 2302 // Don't move the call to compute_new_size() down | |
| 2303 // into code that might be executed if the background | |
| 2304 // collection was preempted. | |
| 2305 { | |
| 2306 ReleaseForegroundGC x(this); // unblock FG collection | |
| 2307 MutexLockerEx y(Heap_lock, Mutex::_no_safepoint_check_flag); | |
| 2308 CMSTokenSync z(true); // not strictly needed. | |
| 2309 if (_collectorState == Resizing) { | |
| 2310 compute_new_size(); | |
| 2311 _collectorState = Resetting; | |
| 2312 } else { | |
| 2313 assert(_collectorState == Idling, "The state should only change" | |
| 2314 " because the foreground collector has finished the collection"); | |
| 2315 } | |
| 2316 } | |
| 2317 break; | |
| 2318 } | |
| 2319 case Resetting: | |
| 2320 // CMS heap resizing has been completed | |
| 2321 reset(true); | |
| 2322 assert(_collectorState == Idling, "Collector state should " | |
| 2323 "have changed"); | |
| 2324 stats().record_cms_end(); | |
| 2325 // Don't move the concurrent_phases_end() and compute_new_size() | |
| 2326 // calls to here because a preempted background collection | |
| 2327 // has it's state set to "Resetting". | |
| 2328 break; | |
| 2329 case Idling: | |
| 2330 default: | |
| 2331 ShouldNotReachHere(); | |
| 2332 break; | |
| 2333 } | |
| 2334 if (TraceCMSState) { | |
| 2335 gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d", | |
| 2336 Thread::current(), _collectorState); | |
| 2337 } | |
| 2338 assert(_foregroundGCShouldWait, "block post-condition"); | |
| 2339 } | |
| 2340 | |
| 2341 // Should this be in gc_epilogue? | |
| 2342 collector_policy()->counters()->update_counters(); | |
| 2343 | |
| 2344 { | |
| 2345 // Clear _foregroundGCShouldWait and, in the event that the | |
| 2346 // foreground collector is waiting, notify it, before | |
| 2347 // returning. | |
| 2348 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2349 _foregroundGCShouldWait = false; | |
| 2350 if (_foregroundGCIsActive) { | |
| 2351 CGC_lock->notify(); | |
| 2352 } | |
| 2353 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2354 "Possible deadlock"); | |
| 2355 } | |
| 2356 if (TraceCMSState) { | |
| 2357 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2358 " exiting collection CMS state %d", | |
| 2359 Thread::current(), _collectorState); | |
| 2360 } | |
| 2361 if (PrintGC && Verbose) { | |
| 2362 _cmsGen->print_heap_change(prev_used); | |
| 2363 } | |
| 2364 } | |
| 2365 | |
| 2366 void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) { | |
| 2367 assert(_foregroundGCIsActive && !_foregroundGCShouldWait, | |
| 2368 "Foreground collector should be waiting, not executing"); | |
| 2369 assert(Thread::current()->is_VM_thread(), "A foreground collection" | |
| 2370 "may only be done by the VM Thread with the world stopped"); | |
| 2371 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 2372 "VM thread should have CMS token"); | |
| 2373 | |
| 2374 NOT_PRODUCT(TraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose, | |
| 2375 true, gclog_or_tty);) | |
| 2376 if (UseAdaptiveSizePolicy) { | |
| 2377 size_policy()->ms_collection_begin(); | |
| 2378 } | |
| 2379 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact); | |
| 2380 | |
| 2381 HandleMark hm; // Discard invalid handles created during verification | |
| 2382 | |
| 2383 if (VerifyBeforeGC && | |
| 2384 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2385 Universe::verify(true); | |
| 2386 } | |
| 2387 | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
2388 // Snapshot the soft reference policy to be used in this collection cycle. |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
2389 ref_processor()->snap_policy(clear_all_soft_refs); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
2390 |
| 0 | 2391 bool init_mark_was_synchronous = false; // until proven otherwise |
| 2392 while (_collectorState != Idling) { | |
| 2393 if (TraceCMSState) { | |
| 2394 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d", | |
| 2395 Thread::current(), _collectorState); | |
| 2396 } | |
| 2397 switch (_collectorState) { | |
| 2398 case InitialMarking: | |
| 2399 init_mark_was_synchronous = true; // fact to be exploited in re-mark | |
| 2400 checkpointRootsInitial(false); | |
| 2401 assert(_collectorState == Marking, "Collector state should have changed" | |
| 2402 " within checkpointRootsInitial()"); | |
| 2403 break; | |
| 2404 case Marking: | |
| 2405 // initial marking in checkpointRootsInitialWork has been completed | |
| 2406 if (VerifyDuringGC && | |
| 2407 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2408 gclog_or_tty->print("Verify before initial mark: "); | |
| 2409 Universe::verify(true); | |
| 2410 } | |
| 2411 { | |
| 2412 bool res = markFromRoots(false); | |
| 2413 assert(res && _collectorState == FinalMarking, "Collector state should " | |
| 2414 "have changed"); | |
| 2415 break; | |
| 2416 } | |
| 2417 case FinalMarking: | |
| 2418 if (VerifyDuringGC && | |
| 2419 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2420 gclog_or_tty->print("Verify before re-mark: "); | |
| 2421 Universe::verify(true); | |
| 2422 } | |
| 2423 checkpointRootsFinal(false, clear_all_soft_refs, | |
| 2424 init_mark_was_synchronous); | |
| 2425 assert(_collectorState == Sweeping, "Collector state should not " | |
| 2426 "have changed within checkpointRootsFinal()"); | |
| 2427 break; | |
| 2428 case Sweeping: | |
| 2429 // final marking in checkpointRootsFinal has been completed | |
| 2430 if (VerifyDuringGC && | |
| 2431 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2432 gclog_or_tty->print("Verify before sweep: "); | |
| 2433 Universe::verify(true); | |
| 2434 } | |
| 2435 sweep(false); | |
| 2436 assert(_collectorState == Resizing, "Incorrect state"); | |
| 2437 break; | |
| 2438 case Resizing: { | |
| 2439 // Sweeping has been completed; the actual resize in this case | |
| 2440 // is done separately; nothing to be done in this state. | |
| 2441 _collectorState = Resetting; | |
| 2442 break; | |
| 2443 } | |
| 2444 case Resetting: | |
| 2445 // The heap has been resized. | |
| 2446 if (VerifyDuringGC && | |
| 2447 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2448 gclog_or_tty->print("Verify before reset: "); | |
| 2449 Universe::verify(true); | |
| 2450 } | |
| 2451 reset(false); | |
| 2452 assert(_collectorState == Idling, "Collector state should " | |
| 2453 "have changed"); | |
| 2454 break; | |
| 2455 case Precleaning: | |
| 2456 case AbortablePreclean: | |
| 2457 // Elide the preclean phase | |
| 2458 _collectorState = FinalMarking; | |
| 2459 break; | |
| 2460 default: | |
| 2461 ShouldNotReachHere(); | |
| 2462 } | |
| 2463 if (TraceCMSState) { | |
| 2464 gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d", | |
| 2465 Thread::current(), _collectorState); | |
| 2466 } | |
| 2467 } | |
| 2468 | |
| 2469 if (UseAdaptiveSizePolicy) { | |
| 2470 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2471 size_policy()->ms_collection_end(gch->gc_cause()); | |
| 2472 } | |
| 2473 | |
| 2474 if (VerifyAfterGC && | |
| 2475 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2476 Universe::verify(true); | |
| 2477 } | |
| 2478 if (TraceCMSState) { | |
| 2479 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2480 " exiting collection CMS state %d", | |
| 2481 Thread::current(), _collectorState); | |
| 2482 } | |
| 2483 } | |
| 2484 | |
| 2485 bool CMSCollector::waitForForegroundGC() { | |
| 2486 bool res = false; | |
| 2487 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2488 "CMS thread should have CMS token"); | |
| 2489 // Block the foreground collector until the | |
| 2490 // background collectors decides whether to | |
| 2491 // yield. | |
| 2492 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2493 _foregroundGCShouldWait = true; | |
| 2494 if (_foregroundGCIsActive) { | |
| 2495 // The background collector yields to the | |
| 2496 // foreground collector and returns a value | |
| 2497 // indicating that it has yielded. The foreground | |
| 2498 // collector can proceed. | |
| 2499 res = true; | |
| 2500 _foregroundGCShouldWait = false; | |
| 2501 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 2502 ConcurrentMarkSweepThread::CMS_cms_has_token); | |
| 2503 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 2504 ConcurrentMarkSweepThread::CMS_cms_wants_token); | |
| 2505 // Get a possibly blocked foreground thread going | |
| 2506 CGC_lock->notify(); | |
| 2507 if (TraceCMSState) { | |
| 2508 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d", | |
| 2509 Thread::current(), _collectorState); | |
| 2510 } | |
| 2511 while (_foregroundGCIsActive) { | |
| 2512 CGC_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 2513 } | |
| 2514 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 2515 ConcurrentMarkSweepThread::CMS_cms_has_token); | |
| 2516 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 2517 ConcurrentMarkSweepThread::CMS_cms_wants_token); | |
| 2518 } | |
| 2519 if (TraceCMSState) { | |
| 2520 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d", | |
| 2521 Thread::current(), _collectorState); | |
| 2522 } | |
| 2523 return res; | |
| 2524 } | |
| 2525 | |
| 2526 // Because of the need to lock the free lists and other structures in | |
| 2527 // the collector, common to all the generations that the collector is | |
| 2528 // collecting, we need the gc_prologues of individual CMS generations | |
| 2529 // delegate to their collector. It may have been simpler had the | |
| 2530 // current infrastructure allowed one to call a prologue on a | |
| 2531 // collector. In the absence of that we have the generation's | |
| 2532 // prologue delegate to the collector, which delegates back | |
| 2533 // some "local" work to a worker method in the individual generations | |
| 2534 // that it's responsible for collecting, while itself doing any | |
| 2535 // work common to all generations it's responsible for. A similar | |
| 2536 // comment applies to the gc_epilogue()'s. | |
| 2537 // The role of the varaible _between_prologue_and_epilogue is to | |
| 2538 // enforce the invocation protocol. | |
| 2539 void CMSCollector::gc_prologue(bool full) { | |
| 2540 // Call gc_prologue_work() for each CMSGen and PermGen that | |
| 2541 // we are responsible for. | |
| 2542 | |
| 2543 // The following locking discipline assumes that we are only called | |
| 2544 // when the world is stopped. | |
| 2545 assert(SafepointSynchronize::is_at_safepoint(), "world is stopped assumption"); | |
| 2546 | |
| 2547 // The CMSCollector prologue must call the gc_prologues for the | |
| 2548 // "generations" (including PermGen if any) that it's responsible | |
| 2549 // for. | |
| 2550 | |
| 2551 assert( Thread::current()->is_VM_thread() | |
| 2552 || ( CMSScavengeBeforeRemark | |
| 2553 && Thread::current()->is_ConcurrentGC_thread()), | |
| 2554 "Incorrect thread type for prologue execution"); | |
| 2555 | |
| 2556 if (_between_prologue_and_epilogue) { | |
| 2557 // We have already been invoked; this is a gc_prologue delegation | |
| 2558 // from yet another CMS generation that we are responsible for, just | |
| 2559 // ignore it since all relevant work has already been done. | |
| 2560 return; | |
| 2561 } | |
| 2562 | |
| 2563 // set a bit saying prologue has been called; cleared in epilogue | |
| 2564 _between_prologue_and_epilogue = true; | |
| 2565 // Claim locks for common data structures, then call gc_prologue_work() | |
| 2566 // for each CMSGen and PermGen that we are responsible for. | |
| 2567 | |
| 2568 getFreelistLocks(); // gets free list locks on constituent spaces | |
| 2569 bitMapLock()->lock_without_safepoint_check(); | |
| 2570 | |
| 2571 // Should call gc_prologue_work() for all cms gens we are responsible for | |
| 2572 bool registerClosure = _collectorState >= Marking | |
| 2573 && _collectorState < Sweeping; | |
| 2574 ModUnionClosure* muc = ParallelGCThreads > 0 ? &_modUnionClosurePar | |
| 2575 : &_modUnionClosure; | |
| 2576 _cmsGen->gc_prologue_work(full, registerClosure, muc); | |
| 2577 _permGen->gc_prologue_work(full, registerClosure, muc); | |
| 2578 | |
| 2579 if (!full) { | |
| 2580 stats().record_gc0_begin(); | |
| 2581 } | |
| 2582 } | |
| 2583 | |
| 2584 void ConcurrentMarkSweepGeneration::gc_prologue(bool full) { | |
| 2585 // Delegate to CMScollector which knows how to coordinate between | |
| 2586 // this and any other CMS generations that it is responsible for | |
| 2587 // collecting. | |
| 2588 collector()->gc_prologue(full); | |
| 2589 } | |
| 2590 | |
| 2591 // This is a "private" interface for use by this generation's CMSCollector. | |
| 2592 // Not to be called directly by any other entity (for instance, | |
| 2593 // GenCollectedHeap, which calls the "public" gc_prologue method above). | |
| 2594 void ConcurrentMarkSweepGeneration::gc_prologue_work(bool full, | |
| 2595 bool registerClosure, ModUnionClosure* modUnionClosure) { | |
| 2596 assert(!incremental_collection_failed(), "Shouldn't be set yet"); | |
| 2597 assert(cmsSpace()->preconsumptionDirtyCardClosure() == NULL, | |
| 2598 "Should be NULL"); | |
| 2599 if (registerClosure) { | |
| 2600 cmsSpace()->setPreconsumptionDirtyCardClosure(modUnionClosure); | |
| 2601 } | |
| 2602 cmsSpace()->gc_prologue(); | |
| 2603 // Clear stat counters | |
| 2604 NOT_PRODUCT( | |
| 2605 assert(_numObjectsPromoted == 0, "check"); | |
| 2606 assert(_numWordsPromoted == 0, "check"); | |
| 2607 if (Verbose && PrintGC) { | |
| 2608 gclog_or_tty->print("Allocated "SIZE_FORMAT" objects, " | |
| 2609 SIZE_FORMAT" bytes concurrently", | |
| 2610 _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); | |
| 2611 } | |
| 2612 _numObjectsAllocated = 0; | |
| 2613 _numWordsAllocated = 0; | |
| 2614 ) | |
| 2615 } | |
| 2616 | |
| 2617 void CMSCollector::gc_epilogue(bool full) { | |
| 2618 // The following locking discipline assumes that we are only called | |
| 2619 // when the world is stopped. | |
| 2620 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2621 "world is stopped assumption"); | |
| 2622 | |
| 2623 // Currently the CMS epilogue (see CompactibleFreeListSpace) merely checks | |
| 2624 // if linear allocation blocks need to be appropriately marked to allow the | |
| 2625 // the blocks to be parsable. We also check here whether we need to nudge the | |
| 2626 // CMS collector thread to start a new cycle (if it's not already active). | |
| 2627 assert( Thread::current()->is_VM_thread() | |
| 2628 || ( CMSScavengeBeforeRemark | |
| 2629 && Thread::current()->is_ConcurrentGC_thread()), | |
| 2630 "Incorrect thread type for epilogue execution"); | |
| 2631 | |
| 2632 if (!_between_prologue_and_epilogue) { | |
| 2633 // We have already been invoked; this is a gc_epilogue delegation | |
| 2634 // from yet another CMS generation that we are responsible for, just | |
| 2635 // ignore it since all relevant work has already been done. | |
| 2636 return; | |
| 2637 } | |
| 2638 assert(haveFreelistLocks(), "must have freelist locks"); | |
| 2639 assert_lock_strong(bitMapLock()); | |
| 2640 | |
| 2641 _cmsGen->gc_epilogue_work(full); | |
| 2642 _permGen->gc_epilogue_work(full); | |
| 2643 | |
| 2644 if (_collectorState == AbortablePreclean || _collectorState == Precleaning) { | |
| 2645 // in case sampling was not already enabled, enable it | |
| 2646 _start_sampling = true; | |
| 2647 } | |
| 2648 // reset _eden_chunk_array so sampling starts afresh | |
| 2649 _eden_chunk_index = 0; | |
| 2650 | |
| 2651 size_t cms_used = _cmsGen->cmsSpace()->used(); | |
| 2652 size_t perm_used = _permGen->cmsSpace()->used(); | |
| 2653 | |
| 2654 // update performance counters - this uses a special version of | |
| 2655 // update_counters() that allows the utilization to be passed as a | |
| 2656 // parameter, avoiding multiple calls to used(). | |
| 2657 // | |
| 2658 _cmsGen->update_counters(cms_used); | |
| 2659 _permGen->update_counters(perm_used); | |
| 2660 | |
| 2661 if (CMSIncrementalMode) { | |
| 2662 icms_update_allocation_limits(); | |
| 2663 } | |
| 2664 | |
| 2665 bitMapLock()->unlock(); | |
| 2666 releaseFreelistLocks(); | |
| 2667 | |
| 2668 _between_prologue_and_epilogue = false; // ready for next cycle | |
| 2669 } | |
| 2670 | |
| 2671 void ConcurrentMarkSweepGeneration::gc_epilogue(bool full) { | |
| 2672 collector()->gc_epilogue(full); | |
| 2673 | |
| 2674 // Also reset promotion tracking in par gc thread states. | |
| 2675 if (ParallelGCThreads > 0) { | |
| 2676 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 2677 _par_gc_thread_states[i]->promo.stopTrackingPromotions(); | |
| 2678 } | |
| 2679 } | |
| 2680 } | |
| 2681 | |
| 2682 void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) { | |
| 2683 assert(!incremental_collection_failed(), "Should have been cleared"); | |
| 2684 cmsSpace()->setPreconsumptionDirtyCardClosure(NULL); | |
| 2685 cmsSpace()->gc_epilogue(); | |
| 2686 // Print stat counters | |
| 2687 NOT_PRODUCT( | |
| 2688 assert(_numObjectsAllocated == 0, "check"); | |
| 2689 assert(_numWordsAllocated == 0, "check"); | |
| 2690 if (Verbose && PrintGC) { | |
| 2691 gclog_or_tty->print("Promoted "SIZE_FORMAT" objects, " | |
| 2692 SIZE_FORMAT" bytes", | |
| 2693 _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); | |
| 2694 } | |
| 2695 _numObjectsPromoted = 0; | |
| 2696 _numWordsPromoted = 0; | |
| 2697 ) | |
| 2698 | |
| 2699 if (PrintGC && Verbose) { | |
| 2700 // Call down the chain in contiguous_available needs the freelistLock | |
| 2701 // so print this out before releasing the freeListLock. | |
| 2702 gclog_or_tty->print(" Contiguous available "SIZE_FORMAT" bytes ", | |
| 2703 contiguous_available()); | |
| 2704 } | |
| 2705 } | |
| 2706 | |
| 2707 #ifndef PRODUCT | |
| 2708 bool CMSCollector::have_cms_token() { | |
| 2709 Thread* thr = Thread::current(); | |
| 2710 if (thr->is_VM_thread()) { | |
| 2711 return ConcurrentMarkSweepThread::vm_thread_has_cms_token(); | |
| 2712 } else if (thr->is_ConcurrentGC_thread()) { | |
| 2713 return ConcurrentMarkSweepThread::cms_thread_has_cms_token(); | |
| 2714 } else if (thr->is_GC_task_thread()) { | |
| 2715 return ConcurrentMarkSweepThread::vm_thread_has_cms_token() && | |
| 2716 ParGCRareEvent_lock->owned_by_self(); | |
| 2717 } | |
| 2718 return false; | |
| 2719 } | |
| 2720 #endif | |
| 2721 | |
| 2722 // Check reachability of the given heap address in CMS generation, | |
| 2723 // treating all other generations as roots. | |
| 2724 bool CMSCollector::is_cms_reachable(HeapWord* addr) { | |
| 2725 // We could "guarantee" below, rather than assert, but i'll | |
| 2726 // leave these as "asserts" so that an adventurous debugger | |
| 2727 // could try this in the product build provided some subset of | |
| 2728 // the conditions were met, provided they were intersted in the | |
| 2729 // results and knew that the computation below wouldn't interfere | |
| 2730 // with other concurrent computations mutating the structures | |
| 2731 // being read or written. | |
| 2732 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2733 "Else mutations in object graph will make answer suspect"); | |
| 2734 assert(have_cms_token(), "Should hold cms token"); | |
| 2735 assert(haveFreelistLocks(), "must hold free list locks"); | |
| 2736 assert_lock_strong(bitMapLock()); | |
| 2737 | |
| 2738 // Clear the marking bit map array before starting, but, just | |
| 2739 // for kicks, first report if the given address is already marked | |
| 2740 gclog_or_tty->print_cr("Start: Address 0x%x is%s marked", addr, | |
| 2741 _markBitMap.isMarked(addr) ? "" : " not"); | |
| 2742 | |
| 2743 if (verify_after_remark()) { | |
| 2744 MutexLockerEx x(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag); | |
| 2745 bool result = verification_mark_bm()->isMarked(addr); | |
| 2746 gclog_or_tty->print_cr("TransitiveMark: Address 0x%x %s marked", addr, | |
| 2747 result ? "IS" : "is NOT"); | |
| 2748 return result; | |
| 2749 } else { | |
| 2750 gclog_or_tty->print_cr("Could not compute result"); | |
| 2751 return false; | |
| 2752 } | |
| 2753 } | |
| 2754 | |
| 2755 //////////////////////////////////////////////////////// | |
| 2756 // CMS Verification Support | |
| 2757 //////////////////////////////////////////////////////// | |
| 2758 // Following the remark phase, the following invariant | |
| 2759 // should hold -- each object in the CMS heap which is | |
| 2760 // marked in markBitMap() should be marked in the verification_mark_bm(). | |
| 2761 | |
| 2762 class VerifyMarkedClosure: public BitMapClosure { | |
| 2763 CMSBitMap* _marks; | |
| 2764 bool _failed; | |
| 2765 | |
| 2766 public: | |
| 2767 VerifyMarkedClosure(CMSBitMap* bm): _marks(bm), _failed(false) {} | |
| 2768 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
2769 bool do_bit(size_t offset) { |
| 0 | 2770 HeapWord* addr = _marks->offsetToHeapWord(offset); |
| 2771 if (!_marks->isMarked(addr)) { | |
| 2772 oop(addr)->print(); | |
| 2773 gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr); | |
| 2774 _failed = true; | |
| 2775 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
2776 return true; |
| 0 | 2777 } |
| 2778 | |
| 2779 bool failed() { return _failed; } | |
| 2780 }; | |
| 2781 | |
| 2782 bool CMSCollector::verify_after_remark() { | |
| 2783 gclog_or_tty->print(" [Verifying CMS Marking... "); | |
| 2784 MutexLockerEx ml(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag); | |
| 2785 static bool init = false; | |
| 2786 | |
| 2787 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2788 "Else mutations in object graph will make answer suspect"); | |
| 2789 assert(have_cms_token(), | |
| 2790 "Else there may be mutual interference in use of " | |
| 2791 " verification data structures"); | |
| 2792 assert(_collectorState > Marking && _collectorState <= Sweeping, | |
| 2793 "Else marking info checked here may be obsolete"); | |
| 2794 assert(haveFreelistLocks(), "must hold free list locks"); | |
| 2795 assert_lock_strong(bitMapLock()); | |
| 2796 | |
| 2797 | |
| 2798 // Allocate marking bit map if not already allocated | |
| 2799 if (!init) { // first time | |
| 2800 if (!verification_mark_bm()->allocate(_span)) { | |
| 2801 return false; | |
| 2802 } | |
| 2803 init = true; | |
| 2804 } | |
| 2805 | |
| 2806 assert(verification_mark_stack()->isEmpty(), "Should be empty"); | |
| 2807 | |
| 2808 // Turn off refs discovery -- so we will be tracing through refs. | |
| 2809 // This is as intended, because by this time | |
| 2810 // GC must already have cleared any refs that need to be cleared, | |
| 2811 // and traced those that need to be marked; moreover, | |
| 2812 // the marking done here is not going to intefere in any | |
| 2813 // way with the marking information used by GC. | |
| 2814 NoRefDiscovery no_discovery(ref_processor()); | |
| 2815 | |
| 2816 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 2817 | |
| 2818 // Clear any marks from a previous round | |
| 2819 verification_mark_bm()->clear_all(); | |
| 2820 assert(verification_mark_stack()->isEmpty(), "markStack should be empty"); | |
| 2821 assert(overflow_list_is_empty(), "overflow list should be empty"); | |
| 2822 | |
| 2823 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2824 gch->ensure_parsability(false); // fill TLABs, but no need to retire them | |
| 2825 // Update the saved marks which may affect the root scans. | |
| 2826 gch->save_marks(); | |
| 2827 | |
| 2828 if (CMSRemarkVerifyVariant == 1) { | |
| 2829 // In this first variant of verification, we complete | |
| 2830 // all marking, then check if the new marks-verctor is | |
| 2831 // a subset of the CMS marks-vector. | |
| 2832 verify_after_remark_work_1(); | |
| 2833 } else if (CMSRemarkVerifyVariant == 2) { | |
| 2834 // In this second variant of verification, we flag an error | |
| 2835 // (i.e. an object reachable in the new marks-vector not reachable | |
| 2836 // in the CMS marks-vector) immediately, also indicating the | |
| 2837 // identify of an object (A) that references the unmarked object (B) -- | |
| 2838 // presumably, a mutation to A failed to be picked up by preclean/remark? | |
| 2839 verify_after_remark_work_2(); | |
| 2840 } else { | |
| 2841 warning("Unrecognized value %d for CMSRemarkVerifyVariant", | |
| 2842 CMSRemarkVerifyVariant); | |
| 2843 } | |
| 2844 gclog_or_tty->print(" done] "); | |
| 2845 return true; | |
| 2846 } | |
| 2847 | |
| 2848 void CMSCollector::verify_after_remark_work_1() { | |
| 2849 ResourceMark rm; | |
| 2850 HandleMark hm; | |
| 2851 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2852 | |
| 2853 // Mark from roots one level into CMS | |
| 2854 MarkRefsIntoClosure notOlder(_span, verification_mark_bm(), true /* nmethods */); | |
| 2855 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
| 2856 | |
| 2857 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 2858 true, // younger gens are roots | |
| 2859 true, // collecting perm gen | |
| 2860 SharedHeap::ScanningOption(roots_scanning_options()), | |
| 2861 NULL, ¬Older); | |
| 2862 | |
| 2863 // Now mark from the roots | |
| 2864 assert(_revisitStack.isEmpty(), "Should be empty"); | |
| 2865 MarkFromRootsClosure markFromRootsClosure(this, _span, | |
| 2866 verification_mark_bm(), verification_mark_stack(), &_revisitStack, | |
| 2867 false /* don't yield */, true /* verifying */); | |
| 2868 assert(_restart_addr == NULL, "Expected pre-condition"); | |
| 2869 verification_mark_bm()->iterate(&markFromRootsClosure); | |
| 2870 while (_restart_addr != NULL) { | |
| 2871 // Deal with stack overflow: by restarting at the indicated | |
| 2872 // address. | |
| 2873 HeapWord* ra = _restart_addr; | |
| 2874 markFromRootsClosure.reset(ra); | |
| 2875 _restart_addr = NULL; | |
| 2876 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end()); | |
| 2877 } | |
| 2878 assert(verification_mark_stack()->isEmpty(), "Should have been drained"); | |
| 2879 verify_work_stacks_empty(); | |
| 2880 // Should reset the revisit stack above, since no class tree | |
| 2881 // surgery is forthcoming. | |
| 2882 _revisitStack.reset(); // throwing away all contents | |
| 2883 | |
| 2884 // Marking completed -- now verify that each bit marked in | |
| 2885 // verification_mark_bm() is also marked in markBitMap(); flag all | |
| 2886 // errors by printing corresponding objects. | |
| 2887 VerifyMarkedClosure vcl(markBitMap()); | |
| 2888 verification_mark_bm()->iterate(&vcl); | |
| 2889 if (vcl.failed()) { | |
| 2890 gclog_or_tty->print("Verification failed"); | |
| 2891 Universe::heap()->print(); | |
| 2892 fatal(" ... aborting"); | |
| 2893 } | |
| 2894 } | |
| 2895 | |
| 2896 void CMSCollector::verify_after_remark_work_2() { | |
| 2897 ResourceMark rm; | |
| 2898 HandleMark hm; | |
| 2899 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2900 | |
| 2901 // Mark from roots one level into CMS | |
| 2902 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(), | |
| 2903 markBitMap(), true /* nmethods */); | |
| 2904 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
| 2905 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 2906 true, // younger gens are roots | |
| 2907 true, // collecting perm gen | |
| 2908 SharedHeap::ScanningOption(roots_scanning_options()), | |
| 2909 NULL, ¬Older); | |
| 2910 | |
| 2911 // Now mark from the roots | |
| 2912 assert(_revisitStack.isEmpty(), "Should be empty"); | |
| 2913 MarkFromRootsVerifyClosure markFromRootsClosure(this, _span, | |
| 2914 verification_mark_bm(), markBitMap(), verification_mark_stack()); | |
| 2915 assert(_restart_addr == NULL, "Expected pre-condition"); | |
| 2916 verification_mark_bm()->iterate(&markFromRootsClosure); | |
| 2917 while (_restart_addr != NULL) { | |
| 2918 // Deal with stack overflow: by restarting at the indicated | |
| 2919 // address. | |
| 2920 HeapWord* ra = _restart_addr; | |
| 2921 markFromRootsClosure.reset(ra); | |
| 2922 _restart_addr = NULL; | |
| 2923 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end()); | |
| 2924 } | |
| 2925 assert(verification_mark_stack()->isEmpty(), "Should have been drained"); | |
| 2926 verify_work_stacks_empty(); | |
| 2927 // Should reset the revisit stack above, since no class tree | |
| 2928 // surgery is forthcoming. | |
| 2929 _revisitStack.reset(); // throwing away all contents | |
| 2930 | |
| 2931 // Marking completed -- now verify that each bit marked in | |
| 2932 // verification_mark_bm() is also marked in markBitMap(); flag all | |
| 2933 // errors by printing corresponding objects. | |
| 2934 VerifyMarkedClosure vcl(markBitMap()); | |
| 2935 verification_mark_bm()->iterate(&vcl); | |
| 2936 assert(!vcl.failed(), "Else verification above should not have succeeded"); | |
| 2937 } | |
| 2938 | |
| 2939 void ConcurrentMarkSweepGeneration::save_marks() { | |
| 2940 // delegate to CMS space | |
| 2941 cmsSpace()->save_marks(); | |
| 2942 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 2943 _par_gc_thread_states[i]->promo.startTrackingPromotions(); | |
| 2944 } | |
| 2945 } | |
| 2946 | |
| 2947 bool ConcurrentMarkSweepGeneration::no_allocs_since_save_marks() { | |
| 2948 return cmsSpace()->no_allocs_since_save_marks(); | |
| 2949 } | |
| 2950 | |
| 2951 #define CMS_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \ | |
| 2952 \ | |
| 2953 void ConcurrentMarkSweepGeneration:: \ | |
| 2954 oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \ | |
| 2955 cl->set_generation(this); \ | |
| 2956 cmsSpace()->oop_since_save_marks_iterate##nv_suffix(cl); \ | |
| 2957 cl->reset_generation(); \ | |
| 2958 save_marks(); \ | |
| 2959 } | |
| 2960 | |
| 2961 ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DEFN) | |
| 2962 | |
| 2963 void | |
| 2964 ConcurrentMarkSweepGeneration::object_iterate_since_last_GC(ObjectClosure* blk) | |
| 2965 { | |
| 2966 // Not currently implemented; need to do the following. -- ysr. | |
| 2967 // dld -- I think that is used for some sort of allocation profiler. So it | |
| 2968 // really means the objects allocated by the mutator since the last | |
| 2969 // GC. We could potentially implement this cheaply by recording only | |
| 2970 // the direct allocations in a side data structure. | |
| 2971 // | |
| 2972 // I think we probably ought not to be required to support these | |
| 2973 // iterations at any arbitrary point; I think there ought to be some | |
| 2974 // call to enable/disable allocation profiling in a generation/space, | |
| 2975 // and the iterator ought to return the objects allocated in the | |
| 2976 // gen/space since the enable call, or the last iterator call (which | |
| 2977 // will probably be at a GC.) That way, for gens like CM&S that would | |
| 2978 // require some extra data structure to support this, we only pay the | |
| 2979 // cost when it's in use... | |
| 2980 cmsSpace()->object_iterate_since_last_GC(blk); | |
| 2981 } | |
| 2982 | |
| 2983 void | |
| 2984 ConcurrentMarkSweepGeneration::younger_refs_iterate(OopsInGenClosure* cl) { | |
| 2985 cl->set_generation(this); | |
| 2986 younger_refs_in_space_iterate(_cmsSpace, cl); | |
| 2987 cl->reset_generation(); | |
| 2988 } | |
| 2989 | |
| 2990 void | |
| 2991 ConcurrentMarkSweepGeneration::oop_iterate(MemRegion mr, OopClosure* cl) { | |
| 2992 if (freelistLock()->owned_by_self()) { | |
| 2993 Generation::oop_iterate(mr, cl); | |
| 2994 } else { | |
| 2995 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 2996 Generation::oop_iterate(mr, cl); | |
| 2997 } | |
| 2998 } | |
| 2999 | |
| 3000 void | |
| 3001 ConcurrentMarkSweepGeneration::oop_iterate(OopClosure* cl) { | |
| 3002 if (freelistLock()->owned_by_self()) { | |
| 3003 Generation::oop_iterate(cl); | |
| 3004 } else { | |
| 3005 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3006 Generation::oop_iterate(cl); | |
| 3007 } | |
| 3008 } | |
| 3009 | |
| 3010 void | |
| 3011 ConcurrentMarkSweepGeneration::object_iterate(ObjectClosure* cl) { | |
| 3012 if (freelistLock()->owned_by_self()) { | |
| 3013 Generation::object_iterate(cl); | |
| 3014 } else { | |
| 3015 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3016 Generation::object_iterate(cl); | |
| 3017 } | |
| 3018 } | |
| 3019 | |
| 3020 void | |
| 3021 ConcurrentMarkSweepGeneration::pre_adjust_pointers() { | |
| 3022 } | |
| 3023 | |
| 3024 void | |
| 3025 ConcurrentMarkSweepGeneration::post_compact() { | |
| 3026 } | |
| 3027 | |
| 3028 void | |
| 3029 ConcurrentMarkSweepGeneration::prepare_for_verify() { | |
| 3030 // Fix the linear allocation blocks to look like free blocks. | |
| 3031 | |
| 3032 // Locks are normally acquired/released in gc_prologue/gc_epilogue, but those | |
| 3033 // are not called when the heap is verified during universe initialization and | |
| 3034 // at vm shutdown. | |
| 3035 if (freelistLock()->owned_by_self()) { | |
| 3036 cmsSpace()->prepare_for_verify(); | |
| 3037 } else { | |
| 3038 MutexLockerEx fll(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3039 cmsSpace()->prepare_for_verify(); | |
| 3040 } | |
| 3041 } | |
| 3042 | |
| 3043 void | |
| 3044 ConcurrentMarkSweepGeneration::verify(bool allow_dirty /* ignored */) { | |
| 3045 // Locks are normally acquired/released in gc_prologue/gc_epilogue, but those | |
| 3046 // are not called when the heap is verified during universe initialization and | |
| 3047 // at vm shutdown. | |
| 3048 if (freelistLock()->owned_by_self()) { | |
| 3049 cmsSpace()->verify(false /* ignored */); | |
| 3050 } else { | |
| 3051 MutexLockerEx fll(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3052 cmsSpace()->verify(false /* ignored */); | |
| 3053 } | |
| 3054 } | |
| 3055 | |
| 3056 void CMSCollector::verify(bool allow_dirty /* ignored */) { | |
| 3057 _cmsGen->verify(allow_dirty); | |
| 3058 _permGen->verify(allow_dirty); | |
| 3059 } | |
| 3060 | |
| 3061 #ifndef PRODUCT | |
| 3062 bool CMSCollector::overflow_list_is_empty() const { | |
| 3063 assert(_num_par_pushes >= 0, "Inconsistency"); | |
| 3064 if (_overflow_list == NULL) { | |
| 3065 assert(_num_par_pushes == 0, "Inconsistency"); | |
| 3066 } | |
| 3067 return _overflow_list == NULL; | |
| 3068 } | |
| 3069 | |
| 3070 // The methods verify_work_stacks_empty() and verify_overflow_empty() | |
| 3071 // merely consolidate assertion checks that appear to occur together frequently. | |
| 3072 void CMSCollector::verify_work_stacks_empty() const { | |
| 3073 assert(_markStack.isEmpty(), "Marking stack should be empty"); | |
| 3074 assert(overflow_list_is_empty(), "Overflow list should be empty"); | |
| 3075 } | |
| 3076 | |
| 3077 void CMSCollector::verify_overflow_empty() const { | |
| 3078 assert(overflow_list_is_empty(), "Overflow list should be empty"); | |
| 3079 assert(no_preserved_marks(), "No preserved marks"); | |
| 3080 } | |
| 3081 #endif // PRODUCT | |
| 3082 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3083 // Decide if we want to enable class unloading as part of the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3084 // ensuing concurrent GC cycle. We will collect the perm gen and |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3085 // unload classes if it's the case that: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3086 // (1) an explicit gc request has been made and the flag |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3087 // ExplicitGCInvokesConcurrentAndUnloadsClasses is set, OR |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3088 // (2) (a) class unloading is enabled at the command line, and |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3089 // (b) (i) perm gen threshold has been crossed, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3090 // (ii) old gen is getting really full, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3091 // (iii) the previous N CMS collections did not collect the |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3092 // perm gen |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3093 // NOTE: Provided there is no change in the state of the heap between |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3094 // calls to this method, it should have idempotent results. Moreover, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3095 // its results should be monotonically increasing (i.e. going from 0 to 1, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3096 // but not 1 to 0) between successive calls between which the heap was |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3097 // not collected. For the implementation below, it must thus rely on |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3098 // the property that concurrent_cycles_since_last_unload() |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3099 // will not decrease unless a collection cycle happened and that |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3100 // _permGen->should_concurrent_collect() and _cmsGen->is_too_full() are |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3101 // themselves also monotonic in that sense. See check_monotonicity() |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3102 // below. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3103 bool CMSCollector::update_should_unload_classes() { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3104 _should_unload_classes = false; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3105 // Condition 1 above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3106 if (_full_gc_requested && ExplicitGCInvokesConcurrentAndUnloadsClasses) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3107 _should_unload_classes = true; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3108 } else if (CMSClassUnloadingEnabled) { // Condition 2.a above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3109 // Disjuncts 2.b.(i,ii,iii) above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3110 _should_unload_classes = (concurrent_cycles_since_last_unload() >= |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3111 CMSClassUnloadingMaxInterval) |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3112 || _permGen->should_concurrent_collect() |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3113 || _cmsGen->is_too_full(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3114 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3115 return _should_unload_classes; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3116 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3117 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3118 bool ConcurrentMarkSweepGeneration::is_too_full() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3119 bool res = should_concurrent_collect(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3120 res = res && (occupancy() > (double)CMSIsTooFullPercentage/100.0); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3121 return res; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3122 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3123 |
| 0 | 3124 void CMSCollector::setup_cms_unloading_and_verification_state() { |
| 3125 const bool should_verify = VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC | |
| 3126 || VerifyBeforeExit; | |
| 3127 const int rso = SharedHeap::SO_Symbols | SharedHeap::SO_Strings | |
| 3128 | SharedHeap::SO_CodeCache; | |
| 3129 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3130 if (should_unload_classes()) { // Should unload classes this cycle |
| 0 | 3131 remove_root_scanning_option(rso); // Shrink the root set appropriately |
| 3132 set_verifying(should_verify); // Set verification state for this cycle | |
| 3133 return; // Nothing else needs to be done at this time | |
| 3134 } | |
| 3135 | |
| 3136 // Not unloading classes this cycle | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3137 assert(!should_unload_classes(), "Inconsitency!"); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3138 if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) { |
| 0 | 3139 // We were not verifying, or we _were_ unloading classes in the last cycle, |
| 3140 // AND some verification options are enabled this cycle; in this case, | |
| 3141 // we must make sure that the deadness map is allocated if not already so, | |
| 3142 // and cleared (if already allocated previously -- | |
| 3143 // CMSBitMap::sizeInBits() is used to determine if it's allocated). | |
| 3144 if (perm_gen_verify_bit_map()->sizeInBits() == 0) { | |
| 3145 if (!perm_gen_verify_bit_map()->allocate(_permGen->reserved())) { | |
| 3146 warning("Failed to allocate permanent generation verification CMS Bit Map;\n" | |
| 3147 "permanent generation verification disabled"); | |
| 3148 return; // Note that we leave verification disabled, so we'll retry this | |
| 3149 // allocation next cycle. We _could_ remember this failure | |
| 3150 // and skip further attempts and permanently disable verification | |
| 3151 // attempts if that is considered more desirable. | |
| 3152 } | |
| 3153 assert(perm_gen_verify_bit_map()->covers(_permGen->reserved()), | |
| 3154 "_perm_gen_ver_bit_map inconsistency?"); | |
| 3155 } else { | |
| 3156 perm_gen_verify_bit_map()->clear_all(); | |
| 3157 } | |
| 3158 // Include symbols, strings and code cache elements to prevent their resurrection. | |
| 3159 add_root_scanning_option(rso); | |
| 3160 set_verifying(true); | |
| 3161 } else if (verifying() && !should_verify) { | |
| 3162 // We were verifying, but some verification flags got disabled. | |
| 3163 set_verifying(false); | |
| 3164 // Exclude symbols, strings and code cache elements from root scanning to | |
| 3165 // reduce IM and RM pauses. | |
| 3166 remove_root_scanning_option(rso); | |
| 3167 } | |
| 3168 } | |
| 3169 | |
| 3170 | |
| 3171 #ifndef PRODUCT | |
| 3172 HeapWord* CMSCollector::block_start(const void* p) const { | |
| 3173 const HeapWord* addr = (HeapWord*)p; | |
| 3174 if (_span.contains(p)) { | |
| 3175 if (_cmsGen->cmsSpace()->is_in_reserved(addr)) { | |
| 3176 return _cmsGen->cmsSpace()->block_start(p); | |
| 3177 } else { | |
| 3178 assert(_permGen->cmsSpace()->is_in_reserved(addr), | |
| 3179 "Inconsistent _span?"); | |
| 3180 return _permGen->cmsSpace()->block_start(p); | |
| 3181 } | |
| 3182 } | |
| 3183 return NULL; | |
| 3184 } | |
| 3185 #endif | |
| 3186 | |
| 3187 HeapWord* | |
| 3188 ConcurrentMarkSweepGeneration::expand_and_allocate(size_t word_size, | |
| 3189 bool tlab, | |
| 3190 bool parallel) { | |
| 3191 assert(!tlab, "Can't deal with TLAB allocation"); | |
| 3192 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3193 expand(word_size*HeapWordSize, MinHeapDeltaBytes, | |
| 3194 CMSExpansionCause::_satisfy_allocation); | |
| 3195 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3196 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3197 } | |
|
9
173195ff483a
6642634: Test nsk/regression/b6186200 crashed with SIGSEGV
ysr
parents:
7
diff
changeset
|
3198 return have_lock_and_allocate(word_size, tlab); |
| 0 | 3199 } |
| 3200 | |
| 3201 // YSR: All of this generation expansion/shrinking stuff is an exact copy of | |
| 3202 // OneContigSpaceCardGeneration, which makes me wonder if we should move this | |
| 3203 // to CardGeneration and share it... | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3204 bool ConcurrentMarkSweepGeneration::expand(size_t bytes, size_t expand_bytes) { |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3205 return CardGeneration::expand(bytes, expand_bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3206 } |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3207 |
| 0 | 3208 void ConcurrentMarkSweepGeneration::expand(size_t bytes, size_t expand_bytes, |
| 3209 CMSExpansionCause::Cause cause) | |
| 3210 { | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3211 |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3212 bool success = expand(bytes, expand_bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3213 |
| 0 | 3214 // remember why we expanded; this information is used |
| 3215 // by shouldConcurrentCollect() when making decisions on whether to start | |
| 3216 // a new CMS cycle. | |
| 3217 if (success) { | |
| 3218 set_expansion_cause(cause); | |
| 3219 if (PrintGCDetails && Verbose) { | |
| 3220 gclog_or_tty->print_cr("Expanded CMS gen for %s", | |
| 3221 CMSExpansionCause::to_string(cause)); | |
| 3222 } | |
| 3223 } | |
| 3224 } | |
| 3225 | |
| 3226 HeapWord* ConcurrentMarkSweepGeneration::expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz) { | |
| 3227 HeapWord* res = NULL; | |
| 3228 MutexLocker x(ParGCRareEvent_lock); | |
| 3229 while (true) { | |
| 3230 // Expansion by some other thread might make alloc OK now: | |
| 3231 res = ps->lab.alloc(word_sz); | |
| 3232 if (res != NULL) return res; | |
| 3233 // If there's not enough expansion space available, give up. | |
| 3234 if (_virtual_space.uncommitted_size() < (word_sz * HeapWordSize)) { | |
| 3235 return NULL; | |
| 3236 } | |
| 3237 // Otherwise, we try expansion. | |
| 3238 expand(word_sz*HeapWordSize, MinHeapDeltaBytes, | |
| 3239 CMSExpansionCause::_allocate_par_lab); | |
| 3240 // Now go around the loop and try alloc again; | |
| 3241 // A competing par_promote might beat us to the expansion space, | |
| 3242 // so we may go around the loop again if promotion fails agaion. | |
| 3243 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3244 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3245 } | |
| 3246 } | |
| 3247 } | |
| 3248 | |
| 3249 | |
| 3250 bool ConcurrentMarkSweepGeneration::expand_and_ensure_spooling_space( | |
| 3251 PromotionInfo* promo) { | |
| 3252 MutexLocker x(ParGCRareEvent_lock); | |
| 3253 size_t refill_size_bytes = promo->refillSize() * HeapWordSize; | |
| 3254 while (true) { | |
| 3255 // Expansion by some other thread might make alloc OK now: | |
| 3256 if (promo->ensure_spooling_space()) { | |
| 3257 assert(promo->has_spooling_space(), | |
| 3258 "Post-condition of successful ensure_spooling_space()"); | |
| 3259 return true; | |
| 3260 } | |
| 3261 // If there's not enough expansion space available, give up. | |
| 3262 if (_virtual_space.uncommitted_size() < refill_size_bytes) { | |
| 3263 return false; | |
| 3264 } | |
| 3265 // Otherwise, we try expansion. | |
| 3266 expand(refill_size_bytes, MinHeapDeltaBytes, | |
| 3267 CMSExpansionCause::_allocate_par_spooling_space); | |
| 3268 // Now go around the loop and try alloc again; | |
| 3269 // A competing allocation might beat us to the expansion space, | |
| 3270 // so we may go around the loop again if allocation fails again. | |
| 3271 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3272 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3273 } | |
| 3274 } | |
| 3275 } | |
| 3276 | |
| 3277 | |
| 3278 | |
| 3279 void ConcurrentMarkSweepGeneration::shrink(size_t bytes) { | |
| 3280 assert_locked_or_safepoint(Heap_lock); | |
| 3281 size_t size = ReservedSpace::page_align_size_down(bytes); | |
| 3282 if (size > 0) { | |
| 3283 shrink_by(size); | |
| 3284 } | |
| 3285 } | |
| 3286 | |
| 3287 bool ConcurrentMarkSweepGeneration::grow_by(size_t bytes) { | |
| 3288 assert_locked_or_safepoint(Heap_lock); | |
| 3289 bool result = _virtual_space.expand_by(bytes); | |
| 3290 if (result) { | |
| 3291 HeapWord* old_end = _cmsSpace->end(); | |
| 3292 size_t new_word_size = | |
| 3293 heap_word_size(_virtual_space.committed_size()); | |
| 3294 MemRegion mr(_cmsSpace->bottom(), new_word_size); | |
| 3295 _bts->resize(new_word_size); // resize the block offset shared array | |
| 3296 Universe::heap()->barrier_set()->resize_covered_region(mr); | |
| 3297 // Hmmmm... why doesn't CFLS::set_end verify locking? | |
| 3298 // This is quite ugly; FIX ME XXX | |
| 3299 _cmsSpace->assert_locked(); | |
| 3300 _cmsSpace->set_end((HeapWord*)_virtual_space.high()); | |
| 3301 | |
| 3302 // update the space and generation capacity counters | |
| 3303 if (UsePerfData) { | |
| 3304 _space_counters->update_capacity(); | |
| 3305 _gen_counters->update_all(); | |
| 3306 } | |
| 3307 | |
| 3308 if (Verbose && PrintGC) { | |
| 3309 size_t new_mem_size = _virtual_space.committed_size(); | |
| 3310 size_t old_mem_size = new_mem_size - bytes; | |
| 3311 gclog_or_tty->print_cr("Expanding %s from %ldK by %ldK to %ldK", | |
| 3312 name(), old_mem_size/K, bytes/K, new_mem_size/K); | |
| 3313 } | |
| 3314 } | |
| 3315 return result; | |
| 3316 } | |
| 3317 | |
| 3318 bool ConcurrentMarkSweepGeneration::grow_to_reserved() { | |
| 3319 assert_locked_or_safepoint(Heap_lock); | |
| 3320 bool success = true; | |
| 3321 const size_t remaining_bytes = _virtual_space.uncommitted_size(); | |
| 3322 if (remaining_bytes > 0) { | |
| 3323 success = grow_by(remaining_bytes); | |
| 3324 DEBUG_ONLY(if (!success) warning("grow to reserved failed");) | |
| 3325 } | |
| 3326 return success; | |
| 3327 } | |
| 3328 | |
| 3329 void ConcurrentMarkSweepGeneration::shrink_by(size_t bytes) { | |
| 3330 assert_locked_or_safepoint(Heap_lock); | |
| 3331 assert_lock_strong(freelistLock()); | |
| 3332 // XXX Fix when compaction is implemented. | |
| 3333 warning("Shrinking of CMS not yet implemented"); | |
| 3334 return; | |
| 3335 } | |
| 3336 | |
| 3337 | |
| 3338 // Simple ctor/dtor wrapper for accounting & timer chores around concurrent | |
| 3339 // phases. | |
| 3340 class CMSPhaseAccounting: public StackObj { | |
| 3341 public: | |
| 3342 CMSPhaseAccounting(CMSCollector *collector, | |
| 3343 const char *phase, | |
| 3344 bool print_cr = true); | |
| 3345 ~CMSPhaseAccounting(); | |
| 3346 | |
| 3347 private: | |
| 3348 CMSCollector *_collector; | |
| 3349 const char *_phase; | |
| 3350 elapsedTimer _wallclock; | |
| 3351 bool _print_cr; | |
| 3352 | |
| 3353 public: | |
| 3354 // Not MT-safe; so do not pass around these StackObj's | |
| 3355 // where they may be accessed by other threads. | |
| 3356 jlong wallclock_millis() { | |
| 3357 assert(_wallclock.is_active(), "Wall clock should not stop"); | |
| 3358 _wallclock.stop(); // to record time | |
| 3359 jlong ret = _wallclock.milliseconds(); | |
| 3360 _wallclock.start(); // restart | |
| 3361 return ret; | |
| 3362 } | |
| 3363 }; | |
| 3364 | |
| 3365 CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector, | |
| 3366 const char *phase, | |
| 3367 bool print_cr) : | |
| 3368 _collector(collector), _phase(phase), _print_cr(print_cr) { | |
| 3369 | |
| 3370 if (PrintCMSStatistics != 0) { | |
| 3371 _collector->resetYields(); | |
| 3372 } | |
| 3373 if (PrintGCDetails && PrintGCTimeStamps) { | |
| 3374 gclog_or_tty->date_stamp(PrintGCDateStamps); | |
| 3375 gclog_or_tty->stamp(); | |
| 3376 gclog_or_tty->print_cr(": [%s-concurrent-%s-start]", | |
| 3377 _collector->cmsGen()->short_name(), _phase); | |
| 3378 } | |
| 3379 _collector->resetTimer(); | |
| 3380 _wallclock.start(); | |
| 3381 _collector->startTimer(); | |
| 3382 } | |
| 3383 | |
| 3384 CMSPhaseAccounting::~CMSPhaseAccounting() { | |
| 3385 assert(_wallclock.is_active(), "Wall clock should not have stopped"); | |
| 3386 _collector->stopTimer(); | |
| 3387 _wallclock.stop(); | |
| 3388 if (PrintGCDetails) { | |
| 3389 gclog_or_tty->date_stamp(PrintGCDateStamps); | |
| 3390 if (PrintGCTimeStamps) { | |
| 3391 gclog_or_tty->stamp(); | |
| 3392 gclog_or_tty->print(": "); | |
| 3393 } | |
| 3394 gclog_or_tty->print("[%s-concurrent-%s: %3.3f/%3.3f secs]", | |
| 3395 _collector->cmsGen()->short_name(), | |
| 3396 _phase, _collector->timerValue(), _wallclock.seconds()); | |
| 3397 if (_print_cr) { | |
| 3398 gclog_or_tty->print_cr(""); | |
| 3399 } | |
| 3400 if (PrintCMSStatistics != 0) { | |
| 3401 gclog_or_tty->print_cr(" (CMS-concurrent-%s yielded %d times)", _phase, | |
| 3402 _collector->yields()); | |
| 3403 } | |
| 3404 } | |
| 3405 } | |
| 3406 | |
| 3407 // CMS work | |
| 3408 | |
| 3409 // Checkpoint the roots into this generation from outside | |
| 3410 // this generation. [Note this initial checkpoint need only | |
| 3411 // be approximate -- we'll do a catch up phase subsequently.] | |
| 3412 void CMSCollector::checkpointRootsInitial(bool asynch) { | |
| 3413 assert(_collectorState == InitialMarking, "Wrong collector state"); | |
| 3414 check_correct_thread_executing(); | |
| 3415 ReferenceProcessor* rp = ref_processor(); | |
| 3416 SpecializationStats::clear(); | |
| 3417 assert(_restart_addr == NULL, "Control point invariant"); | |
| 3418 if (asynch) { | |
| 3419 // acquire locks for subsequent manipulations | |
| 3420 MutexLockerEx x(bitMapLock(), | |
| 3421 Mutex::_no_safepoint_check_flag); | |
| 3422 checkpointRootsInitialWork(asynch); | |
| 3423 rp->verify_no_references_recorded(); | |
| 3424 rp->enable_discovery(); // enable ("weak") refs discovery | |
| 3425 _collectorState = Marking; | |
| 3426 } else { | |
| 3427 // (Weak) Refs discovery: this is controlled from genCollectedHeap::do_collection | |
| 3428 // which recognizes if we are a CMS generation, and doesn't try to turn on | |
| 3429 // discovery; verify that they aren't meddling. | |
| 3430 assert(!rp->discovery_is_atomic(), | |
| 3431 "incorrect setting of discovery predicate"); | |
| 3432 assert(!rp->discovery_enabled(), "genCollectedHeap shouldn't control " | |
| 3433 "ref discovery for this generation kind"); | |
| 3434 // already have locks | |
| 3435 checkpointRootsInitialWork(asynch); | |
| 3436 rp->enable_discovery(); // now enable ("weak") refs discovery | |
| 3437 _collectorState = Marking; | |
| 3438 } | |
| 3439 SpecializationStats::print(); | |
| 3440 } | |
| 3441 | |
| 3442 void CMSCollector::checkpointRootsInitialWork(bool asynch) { | |
| 3443 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); | |
| 3444 assert(_collectorState == InitialMarking, "just checking"); | |
| 3445 | |
| 3446 // If there has not been a GC[n-1] since last GC[n] cycle completed, | |
| 3447 // precede our marking with a collection of all | |
| 3448 // younger generations to keep floating garbage to a minimum. | |
| 3449 // XXX: we won't do this for now -- it's an optimization to be done later. | |
| 3450 | |
| 3451 // already have locks | |
| 3452 assert_lock_strong(bitMapLock()); | |
| 3453 assert(_markBitMap.isAllClear(), "was reset at end of previous cycle"); | |
| 3454 | |
| 3455 // Setup the verification and class unloading state for this | |
| 3456 // CMS collection cycle. | |
| 3457 setup_cms_unloading_and_verification_state(); | |
| 3458 | |
| 3459 NOT_PRODUCT(TraceTime t("\ncheckpointRootsInitialWork", | |
| 3460 PrintGCDetails && Verbose, true, gclog_or_tty);) | |
| 3461 if (UseAdaptiveSizePolicy) { | |
| 3462 size_policy()->checkpoint_roots_initial_begin(); | |
| 3463 } | |
| 3464 | |
| 3465 // Reset all the PLAB chunk arrays if necessary. | |
| 3466 if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) { | |
| 3467 reset_survivor_plab_arrays(); | |
| 3468 } | |
| 3469 | |
| 3470 ResourceMark rm; | |
| 3471 HandleMark hm; | |
| 3472 | |
| 3473 FalseClosure falseClosure; | |
| 3474 // In the case of a synchronous collection, we will elide the | |
| 3475 // remark step, so it's important to catch all the nmethod oops | |
| 3476 // in this step; hence the last argument to the constrcutor below. | |
| 3477 MarkRefsIntoClosure notOlder(_span, &_markBitMap, !asynch /* nmethods */); | |
| 3478 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 3479 | |
| 3480 verify_work_stacks_empty(); | |
| 3481 verify_overflow_empty(); | |
| 3482 | |
| 3483 gch->ensure_parsability(false); // fill TLABs, but no need to retire them | |
| 3484 // Update the saved marks which may affect the root scans. | |
| 3485 gch->save_marks(); | |
| 3486 | |
| 3487 // weak reference processing has not started yet. | |
| 3488 ref_processor()->set_enqueuing_is_done(false); | |
| 3489 | |
| 3490 { | |
| 3491 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 3492 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
| 3493 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 3494 true, // younger gens are roots | |
| 3495 true, // collecting perm gen | |
| 3496 SharedHeap::ScanningOption(roots_scanning_options()), | |
| 3497 NULL, ¬Older); | |
| 3498 } | |
| 3499 | |
| 3500 // Clear mod-union table; it will be dirtied in the prologue of | |
| 3501 // CMS generation per each younger generation collection. | |
| 3502 | |
| 3503 assert(_modUnionTable.isAllClear(), | |
| 3504 "Was cleared in most recent final checkpoint phase" | |
| 3505 " or no bits are set in the gc_prologue before the start of the next " | |
| 3506 "subsequent marking phase."); | |
| 3507 | |
| 3508 // Temporarily disabled, since pre/post-consumption closures don't | |
| 3509 // care about precleaned cards | |
| 3510 #if 0 | |
| 3511 { | |
| 3512 MemRegion mr = MemRegion((HeapWord*)_virtual_space.low(), | |
| 3513 (HeapWord*)_virtual_space.high()); | |
| 3514 _ct->ct_bs()->preclean_dirty_cards(mr); | |
| 3515 } | |
| 3516 #endif | |
| 3517 | |
| 3518 // Save the end of the used_region of the constituent generations | |
| 3519 // to be used to limit the extent of sweep in each generation. | |
| 3520 save_sweep_limits(); | |
| 3521 if (UseAdaptiveSizePolicy) { | |
| 3522 size_policy()->checkpoint_roots_initial_end(gch->gc_cause()); | |
| 3523 } | |
| 3524 verify_overflow_empty(); | |
| 3525 } | |
| 3526 | |
| 3527 bool CMSCollector::markFromRoots(bool asynch) { | |
| 3528 // we might be tempted to assert that: | |
| 3529 // assert(asynch == !SafepointSynchronize::is_at_safepoint(), | |
| 3530 // "inconsistent argument?"); | |
| 3531 // However that wouldn't be right, because it's possible that | |
| 3532 // a safepoint is indeed in progress as a younger generation | |
| 3533 // stop-the-world GC happens even as we mark in this generation. | |
| 3534 assert(_collectorState == Marking, "inconsistent state?"); | |
| 3535 check_correct_thread_executing(); | |
| 3536 verify_overflow_empty(); | |
| 3537 | |
| 3538 bool res; | |
| 3539 if (asynch) { | |
| 3540 | |
| 3541 // Start the timers for adaptive size policy for the concurrent phases | |
| 3542 // Do it here so that the foreground MS can use the concurrent | |
| 3543 // timer since a foreground MS might has the sweep done concurrently | |
| 3544 // or STW. | |
| 3545 if (UseAdaptiveSizePolicy) { | |
| 3546 size_policy()->concurrent_marking_begin(); | |
| 3547 } | |
| 3548 | |
| 3549 // Weak ref discovery note: We may be discovering weak | |
| 3550 // refs in this generation concurrent (but interleaved) with | |
| 3551 // weak ref discovery by a younger generation collector. | |
| 3552 | |
| 3553 CMSTokenSyncWithLocks ts(true, bitMapLock()); | |
| 3554 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 3555 CMSPhaseAccounting pa(this, "mark", !PrintGCDetails); | |
| 3556 res = markFromRootsWork(asynch); | |
| 3557 if (res) { | |
| 3558 _collectorState = Precleaning; | |
| 3559 } else { // We failed and a foreground collection wants to take over | |
| 3560 assert(_foregroundGCIsActive, "internal state inconsistency"); | |
| 3561 assert(_restart_addr == NULL, "foreground will restart from scratch"); | |
| 3562 if (PrintGCDetails) { | |
| 3563 gclog_or_tty->print_cr("bailing out to foreground collection"); | |
| 3564 } | |
| 3565 } | |
| 3566 if (UseAdaptiveSizePolicy) { | |
| 3567 size_policy()->concurrent_marking_end(); | |
| 3568 } | |
| 3569 } else { | |
| 3570 assert(SafepointSynchronize::is_at_safepoint(), | |
| 3571 "inconsistent with asynch == false"); | |
| 3572 if (UseAdaptiveSizePolicy) { | |
| 3573 size_policy()->ms_collection_marking_begin(); | |
| 3574 } | |
| 3575 // already have locks | |
| 3576 res = markFromRootsWork(asynch); | |
| 3577 _collectorState = FinalMarking; | |
| 3578 if (UseAdaptiveSizePolicy) { | |
| 3579 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 3580 size_policy()->ms_collection_marking_end(gch->gc_cause()); | |
| 3581 } | |
| 3582 } | |
| 3583 verify_overflow_empty(); | |
| 3584 return res; | |
| 3585 } | |
| 3586 | |
| 3587 bool CMSCollector::markFromRootsWork(bool asynch) { | |
| 3588 // iterate over marked bits in bit map, doing a full scan and mark | |
| 3589 // from these roots using the following algorithm: | |
| 3590 // . if oop is to the right of the current scan pointer, | |
| 3591 // mark corresponding bit (we'll process it later) | |
| 3592 // . else (oop is to left of current scan pointer) | |
| 3593 // push oop on marking stack | |
| 3594 // . drain the marking stack | |
| 3595 | |
| 3596 // Note that when we do a marking step we need to hold the | |
| 3597 // bit map lock -- recall that direct allocation (by mutators) | |
| 3598 // and promotion (by younger generation collectors) is also | |
| 3599 // marking the bit map. [the so-called allocate live policy.] | |
| 3600 // Because the implementation of bit map marking is not | |
| 3601 // robust wrt simultaneous marking of bits in the same word, | |
| 3602 // we need to make sure that there is no such interference | |
| 3603 // between concurrent such updates. | |
| 3604 | |
| 3605 // already have locks | |
| 3606 assert_lock_strong(bitMapLock()); | |
| 3607 | |
| 3608 // Clear the revisit stack, just in case there are any | |
| 3609 // obsolete contents from a short-circuited previous CMS cycle. | |
| 3610 _revisitStack.reset(); | |
| 3611 verify_work_stacks_empty(); | |
| 3612 verify_overflow_empty(); | |
| 3613 assert(_revisitStack.isEmpty(), "tabula rasa"); | |
| 3614 | |
| 3615 bool result = false; | |
| 3616 if (CMSConcurrentMTEnabled && ParallelCMSThreads > 0) { | |
| 3617 result = do_marking_mt(asynch); | |
| 3618 } else { | |
| 3619 result = do_marking_st(asynch); | |
| 3620 } | |
| 3621 return result; | |
| 3622 } | |
| 3623 | |
| 3624 // Forward decl | |
| 3625 class CMSConcMarkingTask; | |
| 3626 | |
| 3627 class CMSConcMarkingTerminator: public ParallelTaskTerminator { | |
| 3628 CMSCollector* _collector; | |
| 3629 CMSConcMarkingTask* _task; | |
| 3630 bool _yield; | |
| 3631 protected: | |
| 3632 virtual void yield(); | |
| 3633 public: | |
| 3634 // "n_threads" is the number of threads to be terminated. | |
| 3635 // "queue_set" is a set of work queues of other threads. | |
| 3636 // "collector" is the CMS collector associated with this task terminator. | |
| 3637 // "yield" indicates whether we need the gang as a whole to yield. | |
| 3638 CMSConcMarkingTerminator(int n_threads, TaskQueueSetSuper* queue_set, | |
| 3639 CMSCollector* collector, bool yield) : | |
| 3640 ParallelTaskTerminator(n_threads, queue_set), | |
| 3641 _collector(collector), | |
| 3642 _yield(yield) { } | |
| 3643 | |
| 3644 void set_task(CMSConcMarkingTask* task) { | |
| 3645 _task = task; | |
| 3646 } | |
| 3647 }; | |
| 3648 | |
| 3649 // MT Concurrent Marking Task | |
| 3650 class CMSConcMarkingTask: public YieldingFlexibleGangTask { | |
| 3651 CMSCollector* _collector; | |
| 3652 YieldingFlexibleWorkGang* _workers; // the whole gang | |
| 3653 int _n_workers; // requested/desired # workers | |
| 3654 bool _asynch; | |
| 3655 bool _result; | |
| 3656 CompactibleFreeListSpace* _cms_space; | |
| 3657 CompactibleFreeListSpace* _perm_space; | |
| 3658 HeapWord* _global_finger; | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3659 HeapWord* _restart_addr; |
| 0 | 3660 |
| 3661 // Exposed here for yielding support | |
| 3662 Mutex* const _bit_map_lock; | |
| 3663 | |
| 3664 // The per thread work queues, available here for stealing | |
| 3665 OopTaskQueueSet* _task_queues; | |
| 3666 CMSConcMarkingTerminator _term; | |
| 3667 | |
| 3668 public: | |
| 3669 CMSConcMarkingTask(CMSCollector* collector, | |
| 3670 CompactibleFreeListSpace* cms_space, | |
| 3671 CompactibleFreeListSpace* perm_space, | |
| 3672 bool asynch, int n_workers, | |
| 3673 YieldingFlexibleWorkGang* workers, | |
| 3674 OopTaskQueueSet* task_queues): | |
| 3675 YieldingFlexibleGangTask("Concurrent marking done multi-threaded"), | |
| 3676 _collector(collector), | |
| 3677 _cms_space(cms_space), | |
| 3678 _perm_space(perm_space), | |
| 3679 _asynch(asynch), _n_workers(n_workers), _result(true), | |
| 3680 _workers(workers), _task_queues(task_queues), | |
| 3681 _term(n_workers, task_queues, _collector, asynch), | |
| 3682 _bit_map_lock(collector->bitMapLock()) | |
| 3683 { | |
| 3684 assert(n_workers <= workers->total_workers(), | |
| 3685 "Else termination won't work correctly today"); // XXX FIX ME! | |
| 3686 _requested_size = n_workers; | |
| 3687 _term.set_task(this); | |
| 3688 assert(_cms_space->bottom() < _perm_space->bottom(), | |
| 3689 "Finger incorrectly initialized below"); | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3690 _restart_addr = _global_finger = _cms_space->bottom(); |
| 0 | 3691 } |
| 3692 | |
| 3693 | |
| 3694 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 3695 | |
| 3696 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 3697 | |
| 3698 HeapWord** global_finger_addr() { return &_global_finger; } | |
| 3699 | |
| 3700 CMSConcMarkingTerminator* terminator() { return &_term; } | |
| 3701 | |
| 3702 void work(int i); | |
| 3703 | |
| 3704 virtual void coordinator_yield(); // stuff done by coordinator | |
| 3705 bool result() { return _result; } | |
| 3706 | |
| 3707 void reset(HeapWord* ra) { | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3708 assert(_global_finger >= _cms_space->end(), "Postcondition of ::work(i)"); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3709 assert(_global_finger >= _perm_space->end(), "Postcondition of ::work(i)"); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3710 assert(ra < _perm_space->end(), "ra too large"); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3711 _restart_addr = _global_finger = ra; |
| 0 | 3712 _term.reset_for_reuse(); |
| 3713 } | |
| 3714 | |
| 3715 static bool get_work_from_overflow_stack(CMSMarkStack* ovflw_stk, | |
| 3716 OopTaskQueue* work_q); | |
| 3717 | |
| 3718 private: | |
| 3719 void do_scan_and_mark(int i, CompactibleFreeListSpace* sp); | |
| 3720 void do_work_steal(int i); | |
| 3721 void bump_global_finger(HeapWord* f); | |
| 3722 }; | |
| 3723 | |
| 3724 void CMSConcMarkingTerminator::yield() { | |
| 3725 if (ConcurrentMarkSweepThread::should_yield() && | |
| 3726 !_collector->foregroundGCIsActive() && | |
| 3727 _yield) { | |
| 3728 _task->yield(); | |
| 3729 } else { | |
| 3730 ParallelTaskTerminator::yield(); | |
| 3731 } | |
| 3732 } | |
| 3733 | |
| 3734 //////////////////////////////////////////////////////////////// | |
| 3735 // Concurrent Marking Algorithm Sketch | |
| 3736 //////////////////////////////////////////////////////////////// | |
| 3737 // Until all tasks exhausted (both spaces): | |
| 3738 // -- claim next available chunk | |
| 3739 // -- bump global finger via CAS | |
| 3740 // -- find first object that starts in this chunk | |
| 3741 // and start scanning bitmap from that position | |
| 3742 // -- scan marked objects for oops | |
| 3743 // -- CAS-mark target, and if successful: | |
| 3744 // . if target oop is above global finger (volatile read) | |
| 3745 // nothing to do | |
| 3746 // . if target oop is in chunk and above local finger | |
| 3747 // then nothing to do | |
| 3748 // . else push on work-queue | |
| 3749 // -- Deal with possible overflow issues: | |
| 3750 // . local work-queue overflow causes stuff to be pushed on | |
| 3751 // global (common) overflow queue | |
| 3752 // . always first empty local work queue | |
| 3753 // . then get a batch of oops from global work queue if any | |
| 3754 // . then do work stealing | |
| 3755 // -- When all tasks claimed (both spaces) | |
| 3756 // and local work queue empty, | |
| 3757 // then in a loop do: | |
| 3758 // . check global overflow stack; steal a batch of oops and trace | |
| 3759 // . try to steal from other threads oif GOS is empty | |
| 3760 // . if neither is available, offer termination | |
| 3761 // -- Terminate and return result | |
| 3762 // | |
| 3763 void CMSConcMarkingTask::work(int i) { | |
| 3764 elapsedTimer _timer; | |
| 3765 ResourceMark rm; | |
| 3766 HandleMark hm; | |
| 3767 | |
| 3768 DEBUG_ONLY(_collector->verify_overflow_empty();) | |
| 3769 | |
| 3770 // Before we begin work, our work queue should be empty | |
| 3771 assert(work_queue(i)->size() == 0, "Expected to be empty"); | |
| 3772 // Scan the bitmap covering _cms_space, tracing through grey objects. | |
| 3773 _timer.start(); | |
| 3774 do_scan_and_mark(i, _cms_space); | |
| 3775 _timer.stop(); | |
| 3776 if (PrintCMSStatistics != 0) { | |
| 3777 gclog_or_tty->print_cr("Finished cms space scanning in %dth thread: %3.3f sec", | |
| 3778 i, _timer.seconds()); // XXX: need xxx/xxx type of notation, two timers | |
| 3779 } | |
| 3780 | |
| 3781 // ... do the same for the _perm_space | |
| 3782 _timer.reset(); | |
| 3783 _timer.start(); | |
| 3784 do_scan_and_mark(i, _perm_space); | |
| 3785 _timer.stop(); | |
| 3786 if (PrintCMSStatistics != 0) { | |
| 3787 gclog_or_tty->print_cr("Finished perm space scanning in %dth thread: %3.3f sec", | |
| 3788 i, _timer.seconds()); // XXX: need xxx/xxx type of notation, two timers | |
| 3789 } | |
| 3790 | |
| 3791 // ... do work stealing | |
| 3792 _timer.reset(); | |
| 3793 _timer.start(); | |
| 3794 do_work_steal(i); | |
| 3795 _timer.stop(); | |
| 3796 if (PrintCMSStatistics != 0) { | |
| 3797 gclog_or_tty->print_cr("Finished work stealing in %dth thread: %3.3f sec", | |
| 3798 i, _timer.seconds()); // XXX: need xxx/xxx type of notation, two timers | |
| 3799 } | |
| 3800 assert(_collector->_markStack.isEmpty(), "Should have been emptied"); | |
| 3801 assert(work_queue(i)->size() == 0, "Should have been emptied"); | |
| 3802 // Note that under the current task protocol, the | |
| 3803 // following assertion is true even of the spaces | |
| 3804 // expanded since the completion of the concurrent | |
| 3805 // marking. XXX This will likely change under a strict | |
| 3806 // ABORT semantics. | |
| 3807 assert(_global_finger > _cms_space->end() && | |
| 3808 _global_finger >= _perm_space->end(), | |
| 3809 "All tasks have been completed"); | |
| 3810 DEBUG_ONLY(_collector->verify_overflow_empty();) | |
| 3811 } | |
| 3812 | |
| 3813 void CMSConcMarkingTask::bump_global_finger(HeapWord* f) { | |
| 3814 HeapWord* read = _global_finger; | |
| 3815 HeapWord* cur = read; | |
| 3816 while (f > read) { | |
| 3817 cur = read; | |
| 3818 read = (HeapWord*) Atomic::cmpxchg_ptr(f, &_global_finger, cur); | |
| 3819 if (cur == read) { | |
| 3820 // our cas succeeded | |
| 3821 assert(_global_finger >= f, "protocol consistency"); | |
| 3822 break; | |
| 3823 } | |
| 3824 } | |
| 3825 } | |
| 3826 | |
| 3827 // This is really inefficient, and should be redone by | |
| 3828 // using (not yet available) block-read and -write interfaces to the | |
| 3829 // stack and the work_queue. XXX FIX ME !!! | |
| 3830 bool CMSConcMarkingTask::get_work_from_overflow_stack(CMSMarkStack* ovflw_stk, | |
| 3831 OopTaskQueue* work_q) { | |
| 3832 // Fast lock-free check | |
| 3833 if (ovflw_stk->length() == 0) { | |
| 3834 return false; | |
| 3835 } | |
| 3836 assert(work_q->size() == 0, "Shouldn't steal"); | |
| 3837 MutexLockerEx ml(ovflw_stk->par_lock(), | |
| 3838 Mutex::_no_safepoint_check_flag); | |
| 3839 // Grab up to 1/4 the size of the work queue | |
| 3840 size_t num = MIN2((size_t)work_q->max_elems()/4, | |
| 3841 (size_t)ParGCDesiredObjsFromOverflowList); | |
| 3842 num = MIN2(num, ovflw_stk->length()); | |
| 3843 for (int i = (int) num; i > 0; i--) { | |
| 3844 oop cur = ovflw_stk->pop(); | |
| 3845 assert(cur != NULL, "Counted wrong?"); | |
| 3846 work_q->push(cur); | |
| 3847 } | |
| 3848 return num > 0; | |
| 3849 } | |
| 3850 | |
| 3851 void CMSConcMarkingTask::do_scan_and_mark(int i, CompactibleFreeListSpace* sp) { | |
| 3852 SequentialSubTasksDone* pst = sp->conc_par_seq_tasks(); | |
| 3853 int n_tasks = pst->n_tasks(); | |
| 3854 // We allow that there may be no tasks to do here because | |
| 3855 // we are restarting after a stack overflow. | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3856 assert(pst->valid() || n_tasks == 0, "Uninitialized use?"); |
| 0 | 3857 int nth_task = 0; |
| 3858 | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3859 HeapWord* aligned_start = sp->bottom(); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3860 if (sp->used_region().contains(_restart_addr)) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3861 // Align down to a card boundary for the start of 0th task |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3862 // for this space. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3863 aligned_start = |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3864 (HeapWord*)align_size_down((uintptr_t)_restart_addr, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3865 CardTableModRefBS::card_size); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3866 } |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3867 |
| 0 | 3868 size_t chunk_size = sp->marking_task_size(); |
| 3869 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 3870 // Having claimed the nth task in this space, | |
| 3871 // compute the chunk that it corresponds to: | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3872 MemRegion span = MemRegion(aligned_start + nth_task*chunk_size, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3873 aligned_start + (nth_task+1)*chunk_size); |
| 0 | 3874 // Try and bump the global finger via a CAS; |
| 3875 // note that we need to do the global finger bump | |
| 3876 // _before_ taking the intersection below, because | |
| 3877 // the task corresponding to that region will be | |
| 3878 // deemed done even if the used_region() expands | |
| 3879 // because of allocation -- as it almost certainly will | |
| 3880 // during start-up while the threads yield in the | |
| 3881 // closure below. | |
| 3882 HeapWord* finger = span.end(); | |
| 3883 bump_global_finger(finger); // atomically | |
| 3884 // There are null tasks here corresponding to chunks | |
| 3885 // beyond the "top" address of the space. | |
| 3886 span = span.intersection(sp->used_region()); | |
| 3887 if (!span.is_empty()) { // Non-null task | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3888 HeapWord* prev_obj; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3889 assert(!span.contains(_restart_addr) || nth_task == 0, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3890 "Inconsistency"); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3891 if (nth_task == 0) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3892 // For the 0th task, we'll not need to compute a block_start. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3893 if (span.contains(_restart_addr)) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3894 // In the case of a restart because of stack overflow, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3895 // we might additionally skip a chunk prefix. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3896 prev_obj = _restart_addr; |
| 0 | 3897 } else { |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3898 prev_obj = span.start(); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3899 } |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3900 } else { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3901 // We want to skip the first object because |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3902 // the protocol is to scan any object in its entirety |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3903 // that _starts_ in this span; a fortiori, any |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3904 // object starting in an earlier span is scanned |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3905 // as part of an earlier claimed task. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3906 // Below we use the "careful" version of block_start |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3907 // so we do not try to navigate uninitialized objects. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3908 prev_obj = sp->block_start_careful(span.start()); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3909 // Below we use a variant of block_size that uses the |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3910 // Printezis bits to avoid waiting for allocated |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3911 // objects to become initialized/parsable. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3912 while (prev_obj < span.start()) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3913 size_t sz = sp->block_size_no_stall(prev_obj, _collector); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3914 if (sz > 0) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3915 prev_obj += sz; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3916 } else { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3917 // In this case we may end up doing a bit of redundant |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3918 // scanning, but that appears unavoidable, short of |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3919 // locking the free list locks; see bug 6324141. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3920 break; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3921 } |
| 0 | 3922 } |
| 3923 } | |
| 3924 if (prev_obj < span.end()) { | |
| 3925 MemRegion my_span = MemRegion(prev_obj, span.end()); | |
| 3926 // Do the marking work within a non-empty span -- | |
| 3927 // the last argument to the constructor indicates whether the | |
| 3928 // iteration should be incremental with periodic yields. | |
| 3929 Par_MarkFromRootsClosure cl(this, _collector, my_span, | |
| 3930 &_collector->_markBitMap, | |
| 3931 work_queue(i), | |
| 3932 &_collector->_markStack, | |
| 3933 &_collector->_revisitStack, | |
| 3934 _asynch); | |
| 3935 _collector->_markBitMap.iterate(&cl, my_span.start(), my_span.end()); | |
| 3936 } // else nothing to do for this task | |
| 3937 } // else nothing to do for this task | |
| 3938 } | |
| 3939 // We'd be tempted to assert here that since there are no | |
| 3940 // more tasks left to claim in this space, the global_finger | |
| 3941 // must exceed space->top() and a fortiori space->end(). However, | |
| 3942 // that would not quite be correct because the bumping of | |
| 3943 // global_finger occurs strictly after the claiming of a task, | |
| 3944 // so by the time we reach here the global finger may not yet | |
| 3945 // have been bumped up by the thread that claimed the last | |
| 3946 // task. | |
| 3947 pst->all_tasks_completed(); | |
| 3948 } | |
| 3949 | |
| 3950 class Par_ConcMarkingClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3951 private: |
| 0 | 3952 CMSCollector* _collector; |
| 3953 MemRegion _span; | |
| 3954 CMSBitMap* _bit_map; | |
| 3955 CMSMarkStack* _overflow_stack; | |
| 3956 CMSMarkStack* _revisit_stack; // XXXXXX Check proper use | |
| 3957 OopTaskQueue* _work_queue; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3958 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3959 DO_OOP_WORK_DEFN |
| 0 | 3960 public: |
| 3961 Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue, | |
| 3962 CMSBitMap* bit_map, CMSMarkStack* overflow_stack): | |
| 3963 _collector(collector), | |
| 3964 _span(_collector->_span), | |
| 3965 _work_queue(work_queue), | |
| 3966 _bit_map(bit_map), | |
| 3967 _overflow_stack(overflow_stack) { } // need to initialize revisit stack etc. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3968 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3969 virtual void do_oop(narrowOop* p); |
| 0 | 3970 void trim_queue(size_t max); |
| 3971 void handle_stack_overflow(HeapWord* lost); | |
| 3972 }; | |
| 3973 | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3974 // Grey object scanning during work stealing phase -- |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3975 // the salient assumption here is that any references |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3976 // that are in these stolen objects being scanned must |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3977 // already have been initialized (else they would not have |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3978 // been published), so we do not need to check for |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3979 // uninitialized objects before pushing here. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3980 void Par_ConcMarkingClosure::do_oop(oop obj) { |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3981 assert(obj->is_oop_or_null(true), "expected an oop or NULL"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
3982 HeapWord* addr = (HeapWord*)obj; |
| 0 | 3983 // Check if oop points into the CMS generation |
| 3984 // and is not marked | |
| 3985 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 3986 // a white object ... | |
| 3987 // If we manage to "claim" the object, by being the | |
| 3988 // first thread to mark it, then we push it on our | |
| 3989 // marking stack | |
| 3990 if (_bit_map->par_mark(addr)) { // ... now grey | |
| 3991 // push on work queue (grey set) | |
| 3992 bool simulate_overflow = false; | |
| 3993 NOT_PRODUCT( | |
| 3994 if (CMSMarkStackOverflowALot && | |
| 3995 _collector->simulate_overflow()) { | |
| 3996 // simulate a stack overflow | |
| 3997 simulate_overflow = true; | |
| 3998 } | |
| 3999 ) | |
| 4000 if (simulate_overflow || | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4001 !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { |
| 0 | 4002 // stack overflow |
| 4003 if (PrintCMSStatistics != 0) { | |
| 4004 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 4005 SIZE_FORMAT, _overflow_stack->capacity()); | |
| 4006 } | |
| 4007 // We cannot assert that the overflow stack is full because | |
| 4008 // it may have been emptied since. | |
| 4009 assert(simulate_overflow || | |
| 4010 _work_queue->size() == _work_queue->max_elems(), | |
| 4011 "Else push should have succeeded"); | |
| 4012 handle_stack_overflow(addr); | |
| 4013 } | |
| 4014 } // Else, some other thread got there first | |
| 4015 } | |
| 4016 } | |
| 4017 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4018 void Par_ConcMarkingClosure::do_oop(oop* p) { Par_ConcMarkingClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4019 void Par_ConcMarkingClosure::do_oop(narrowOop* p) { Par_ConcMarkingClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4020 |
| 0 | 4021 void Par_ConcMarkingClosure::trim_queue(size_t max) { |
| 4022 while (_work_queue->size() > max) { | |
| 4023 oop new_oop; | |
| 4024 if (_work_queue->pop_local(new_oop)) { | |
| 4025 assert(new_oop->is_oop(), "Should be an oop"); | |
| 4026 assert(_bit_map->isMarked((HeapWord*)new_oop), "Grey object"); | |
| 4027 assert(_span.contains((HeapWord*)new_oop), "Not in span"); | |
| 4028 assert(new_oop->is_parsable(), "Should be parsable"); | |
| 4029 new_oop->oop_iterate(this); // do_oop() above | |
| 4030 } | |
| 4031 } | |
| 4032 } | |
| 4033 | |
| 4034 // Upon stack overflow, we discard (part of) the stack, | |
| 4035 // remembering the least address amongst those discarded | |
| 4036 // in CMSCollector's _restart_address. | |
| 4037 void Par_ConcMarkingClosure::handle_stack_overflow(HeapWord* lost) { | |
| 4038 // We need to do this under a mutex to prevent other | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4039 // workers from interfering with the work done below. |
| 0 | 4040 MutexLockerEx ml(_overflow_stack->par_lock(), |
| 4041 Mutex::_no_safepoint_check_flag); | |
| 4042 // Remember the least grey address discarded | |
| 4043 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost); | |
| 4044 _collector->lower_restart_addr(ra); | |
| 4045 _overflow_stack->reset(); // discard stack contents | |
| 4046 _overflow_stack->expand(); // expand the stack if possible | |
| 4047 } | |
| 4048 | |
| 4049 | |
| 4050 void CMSConcMarkingTask::do_work_steal(int i) { | |
| 4051 OopTaskQueue* work_q = work_queue(i); | |
| 4052 oop obj_to_scan; | |
| 4053 CMSBitMap* bm = &(_collector->_markBitMap); | |
| 4054 CMSMarkStack* ovflw = &(_collector->_markStack); | |
| 4055 int* seed = _collector->hash_seed(i); | |
| 4056 Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw); | |
| 4057 while (true) { | |
| 4058 cl.trim_queue(0); | |
| 4059 assert(work_q->size() == 0, "Should have been emptied above"); | |
| 4060 if (get_work_from_overflow_stack(ovflw, work_q)) { | |
| 4061 // Can't assert below because the work obtained from the | |
| 4062 // overflow stack may already have been stolen from us. | |
| 4063 // assert(work_q->size() > 0, "Work from overflow stack"); | |
| 4064 continue; | |
| 4065 } else if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 4066 assert(obj_to_scan->is_oop(), "Should be an oop"); | |
| 4067 assert(bm->isMarked((HeapWord*)obj_to_scan), "Grey object"); | |
| 4068 obj_to_scan->oop_iterate(&cl); | |
| 4069 } else if (terminator()->offer_termination()) { | |
| 4070 assert(work_q->size() == 0, "Impossible!"); | |
| 4071 break; | |
| 4072 } | |
| 4073 } | |
| 4074 } | |
| 4075 | |
| 4076 // This is run by the CMS (coordinator) thread. | |
| 4077 void CMSConcMarkingTask::coordinator_yield() { | |
| 4078 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 4079 "CMS thread should hold CMS token"); | |
| 4080 | |
| 4081 // First give up the locks, then yield, then re-lock | |
| 4082 // We should probably use a constructor/destructor idiom to | |
| 4083 // do this unlock/lock or modify the MutexUnlocker class to | |
| 4084 // serve our purpose. XXX | |
| 4085 assert_lock_strong(_bit_map_lock); | |
| 4086 _bit_map_lock->unlock(); | |
| 4087 ConcurrentMarkSweepThread::desynchronize(true); | |
| 4088 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 4089 _collector->stopTimer(); | |
| 4090 if (PrintCMSStatistics != 0) { | |
| 4091 _collector->incrementYields(); | |
| 4092 } | |
| 4093 _collector->icms_wait(); | |
| 4094 | |
| 4095 // It is possible for whichever thread initiated the yield request | |
| 4096 // not to get a chance to wake up and take the bitmap lock between | |
| 4097 // this thread releasing it and reacquiring it. So, while the | |
| 4098 // should_yield() flag is on, let's sleep for a bit to give the | |
| 4099 // other thread a chance to wake up. The limit imposed on the number | |
| 4100 // of iterations is defensive, to avoid any unforseen circumstances | |
| 4101 // putting us into an infinite loop. Since it's always been this | |
| 4102 // (coordinator_yield()) method that was observed to cause the | |
| 4103 // problem, we are using a parameter (CMSCoordinatorYieldSleepCount) | |
| 4104 // which is by default non-zero. For the other seven methods that | |
| 4105 // also perform the yield operation, as are using a different | |
| 4106 // parameter (CMSYieldSleepCount) which is by default zero. This way we | |
| 4107 // can enable the sleeping for those methods too, if necessary. | |
| 4108 // See 6442774. | |
| 4109 // | |
| 4110 // We really need to reconsider the synchronization between the GC | |
| 4111 // thread and the yield-requesting threads in the future and we | |
| 4112 // should really use wait/notify, which is the recommended | |
| 4113 // way of doing this type of interaction. Additionally, we should | |
| 4114 // consolidate the eight methods that do the yield operation and they | |
| 4115 // are almost identical into one for better maintenability and | |
| 4116 // readability. See 6445193. | |
| 4117 // | |
| 4118 // Tony 2006.06.29 | |
| 4119 for (unsigned i = 0; i < CMSCoordinatorYieldSleepCount && | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4120 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4121 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 4122 os::sleep(Thread::current(), 1, false); |
| 4123 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 4124 } | |
| 4125 | |
| 4126 ConcurrentMarkSweepThread::synchronize(true); | |
| 4127 _bit_map_lock->lock_without_safepoint_check(); | |
| 4128 _collector->startTimer(); | |
| 4129 } | |
| 4130 | |
| 4131 bool CMSCollector::do_marking_mt(bool asynch) { | |
| 4132 assert(ParallelCMSThreads > 0 && conc_workers() != NULL, "precondition"); | |
| 4133 // In the future this would be determined ergonomically, based | |
| 4134 // on #cpu's, # active mutator threads (and load), and mutation rate. | |
| 4135 int num_workers = ParallelCMSThreads; | |
| 4136 | |
| 4137 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); | |
| 4138 CompactibleFreeListSpace* perm_space = _permGen->cmsSpace(); | |
| 4139 | |
| 4140 CMSConcMarkingTask tsk(this, cms_space, perm_space, | |
| 4141 asynch, num_workers /* number requested XXX */, | |
| 4142 conc_workers(), task_queues()); | |
| 4143 | |
| 4144 // Since the actual number of workers we get may be different | |
| 4145 // from the number we requested above, do we need to do anything different | |
| 4146 // below? In particular, may be we need to subclass the SequantialSubTasksDone | |
| 4147 // class?? XXX | |
| 4148 cms_space ->initialize_sequential_subtasks_for_marking(num_workers); | |
| 4149 perm_space->initialize_sequential_subtasks_for_marking(num_workers); | |
| 4150 | |
| 4151 // Refs discovery is already non-atomic. | |
| 4152 assert(!ref_processor()->discovery_is_atomic(), "Should be non-atomic"); | |
| 4153 // Mutate the Refs discovery so it is MT during the | |
| 4154 // multi-threaded marking phase. | |
| 4155 ReferenceProcessorMTMutator mt(ref_processor(), num_workers > 1); | |
| 4156 | |
| 4157 conc_workers()->start_task(&tsk); | |
| 4158 while (tsk.yielded()) { | |
| 4159 tsk.coordinator_yield(); | |
| 4160 conc_workers()->continue_task(&tsk); | |
| 4161 } | |
| 4162 // If the task was aborted, _restart_addr will be non-NULL | |
| 4163 assert(tsk.completed() || _restart_addr != NULL, "Inconsistency"); | |
| 4164 while (_restart_addr != NULL) { | |
| 4165 // XXX For now we do not make use of ABORTED state and have not | |
| 4166 // yet implemented the right abort semantics (even in the original | |
| 4167 // single-threaded CMS case). That needs some more investigation | |
| 4168 // and is deferred for now; see CR# TBF. 07252005YSR. XXX | |
| 4169 assert(!CMSAbortSemantics || tsk.aborted(), "Inconsistency"); | |
| 4170 // If _restart_addr is non-NULL, a marking stack overflow | |
| 4171 // occured; we need to do a fresh marking iteration from the | |
| 4172 // indicated restart address. | |
| 4173 if (_foregroundGCIsActive && asynch) { | |
| 4174 // We may be running into repeated stack overflows, having | |
| 4175 // reached the limit of the stack size, while making very | |
| 4176 // slow forward progress. It may be best to bail out and | |
| 4177 // let the foreground collector do its job. | |
| 4178 // Clear _restart_addr, so that foreground GC | |
| 4179 // works from scratch. This avoids the headache of | |
| 4180 // a "rescan" which would otherwise be needed because | |
| 4181 // of the dirty mod union table & card table. | |
| 4182 _restart_addr = NULL; | |
| 4183 return false; | |
| 4184 } | |
| 4185 // Adjust the task to restart from _restart_addr | |
| 4186 tsk.reset(_restart_addr); | |
| 4187 cms_space ->initialize_sequential_subtasks_for_marking(num_workers, | |
| 4188 _restart_addr); | |
| 4189 perm_space->initialize_sequential_subtasks_for_marking(num_workers, | |
| 4190 _restart_addr); | |
| 4191 _restart_addr = NULL; | |
| 4192 // Get the workers going again | |
| 4193 conc_workers()->start_task(&tsk); | |
| 4194 while (tsk.yielded()) { | |
| 4195 tsk.coordinator_yield(); | |
| 4196 conc_workers()->continue_task(&tsk); | |
| 4197 } | |
| 4198 } | |
| 4199 assert(tsk.completed(), "Inconsistency"); | |
| 4200 assert(tsk.result() == true, "Inconsistency"); | |
| 4201 return true; | |
| 4202 } | |
| 4203 | |
| 4204 bool CMSCollector::do_marking_st(bool asynch) { | |
| 4205 ResourceMark rm; | |
| 4206 HandleMark hm; | |
| 4207 | |
| 4208 MarkFromRootsClosure markFromRootsClosure(this, _span, &_markBitMap, | |
| 4209 &_markStack, &_revisitStack, CMSYield && asynch); | |
| 4210 // the last argument to iterate indicates whether the iteration | |
| 4211 // should be incremental with periodic yields. | |
| 4212 _markBitMap.iterate(&markFromRootsClosure); | |
| 4213 // If _restart_addr is non-NULL, a marking stack overflow | |
| 4214 // occured; we need to do a fresh iteration from the | |
| 4215 // indicated restart address. | |
| 4216 while (_restart_addr != NULL) { | |
| 4217 if (_foregroundGCIsActive && asynch) { | |
| 4218 // We may be running into repeated stack overflows, having | |
| 4219 // reached the limit of the stack size, while making very | |
| 4220 // slow forward progress. It may be best to bail out and | |
| 4221 // let the foreground collector do its job. | |
| 4222 // Clear _restart_addr, so that foreground GC | |
| 4223 // works from scratch. This avoids the headache of | |
| 4224 // a "rescan" which would otherwise be needed because | |
| 4225 // of the dirty mod union table & card table. | |
| 4226 _restart_addr = NULL; | |
| 4227 return false; // indicating failure to complete marking | |
| 4228 } | |
| 4229 // Deal with stack overflow: | |
| 4230 // we restart marking from _restart_addr | |
| 4231 HeapWord* ra = _restart_addr; | |
| 4232 markFromRootsClosure.reset(ra); | |
| 4233 _restart_addr = NULL; | |
| 4234 _markBitMap.iterate(&markFromRootsClosure, ra, _span.end()); | |
| 4235 } | |
| 4236 return true; | |
| 4237 } | |
| 4238 | |
| 4239 void CMSCollector::preclean() { | |
| 4240 check_correct_thread_executing(); | |
| 4241 assert(Thread::current()->is_ConcurrentGC_thread(), "Wrong thread"); | |
| 4242 verify_work_stacks_empty(); | |
| 4243 verify_overflow_empty(); | |
| 4244 _abort_preclean = false; | |
| 4245 if (CMSPrecleaningEnabled) { | |
| 4246 _eden_chunk_index = 0; | |
| 4247 size_t used = get_eden_used(); | |
| 4248 size_t capacity = get_eden_capacity(); | |
| 4249 // Don't start sampling unless we will get sufficiently | |
| 4250 // many samples. | |
| 4251 if (used < (capacity/(CMSScheduleRemarkSamplingRatio * 100) | |
| 4252 * CMSScheduleRemarkEdenPenetration)) { | |
| 4253 _start_sampling = true; | |
| 4254 } else { | |
| 4255 _start_sampling = false; | |
| 4256 } | |
| 4257 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 4258 CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails); | |
| 4259 preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1); | |
| 4260 } | |
| 4261 CMSTokenSync x(true); // is cms thread | |
| 4262 if (CMSPrecleaningEnabled) { | |
| 4263 sample_eden(); | |
| 4264 _collectorState = AbortablePreclean; | |
| 4265 } else { | |
| 4266 _collectorState = FinalMarking; | |
| 4267 } | |
| 4268 verify_work_stacks_empty(); | |
| 4269 verify_overflow_empty(); | |
| 4270 } | |
| 4271 | |
| 4272 // Try and schedule the remark such that young gen | |
| 4273 // occupancy is CMSScheduleRemarkEdenPenetration %. | |
| 4274 void CMSCollector::abortable_preclean() { | |
| 4275 check_correct_thread_executing(); | |
| 4276 assert(CMSPrecleaningEnabled, "Inconsistent control state"); | |
| 4277 assert(_collectorState == AbortablePreclean, "Inconsistent control state"); | |
| 4278 | |
| 4279 // If Eden's current occupancy is below this threshold, | |
| 4280 // immediately schedule the remark; else preclean | |
| 4281 // past the next scavenge in an effort to | |
| 4282 // schedule the pause as described avove. By choosing | |
| 4283 // CMSScheduleRemarkEdenSizeThreshold >= max eden size | |
| 4284 // we will never do an actual abortable preclean cycle. | |
| 4285 if (get_eden_used() > CMSScheduleRemarkEdenSizeThreshold) { | |
| 4286 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 4287 CMSPhaseAccounting pa(this, "abortable-preclean", !PrintGCDetails); | |
| 4288 // We need more smarts in the abortable preclean | |
| 4289 // loop below to deal with cases where allocation | |
| 4290 // in young gen is very very slow, and our precleaning | |
| 4291 // is running a losing race against a horde of | |
| 4292 // mutators intent on flooding us with CMS updates | |
| 4293 // (dirty cards). | |
| 4294 // One, admittedly dumb, strategy is to give up | |
| 4295 // after a certain number of abortable precleaning loops | |
| 4296 // or after a certain maximum time. We want to make | |
| 4297 // this smarter in the next iteration. | |
| 4298 // XXX FIX ME!!! YSR | |
| 4299 size_t loops = 0, workdone = 0, cumworkdone = 0, waited = 0; | |
| 4300 while (!(should_abort_preclean() || | |
| 4301 ConcurrentMarkSweepThread::should_terminate())) { | |
| 4302 workdone = preclean_work(CMSPrecleanRefLists2, CMSPrecleanSurvivors2); | |
| 4303 cumworkdone += workdone; | |
| 4304 loops++; | |
| 4305 // Voluntarily terminate abortable preclean phase if we have | |
| 4306 // been at it for too long. | |
| 4307 if ((CMSMaxAbortablePrecleanLoops != 0) && | |
| 4308 loops >= CMSMaxAbortablePrecleanLoops) { | |
| 4309 if (PrintGCDetails) { | |
| 4310 gclog_or_tty->print(" CMS: abort preclean due to loops "); | |
| 4311 } | |
| 4312 break; | |
| 4313 } | |
| 4314 if (pa.wallclock_millis() > CMSMaxAbortablePrecleanTime) { | |
| 4315 if (PrintGCDetails) { | |
| 4316 gclog_or_tty->print(" CMS: abort preclean due to time "); | |
| 4317 } | |
| 4318 break; | |
| 4319 } | |
| 4320 // If we are doing little work each iteration, we should | |
| 4321 // take a short break. | |
| 4322 if (workdone < CMSAbortablePrecleanMinWorkPerIteration) { | |
| 4323 // Sleep for some time, waiting for work to accumulate | |
| 4324 stopTimer(); | |
| 4325 cmsThread()->wait_on_cms_lock(CMSAbortablePrecleanWaitMillis); | |
| 4326 startTimer(); | |
| 4327 waited++; | |
| 4328 } | |
| 4329 } | |
| 4330 if (PrintCMSStatistics > 0) { | |
| 4331 gclog_or_tty->print(" [%d iterations, %d waits, %d cards)] ", | |
| 4332 loops, waited, cumworkdone); | |
| 4333 } | |
| 4334 } | |
| 4335 CMSTokenSync x(true); // is cms thread | |
| 4336 if (_collectorState != Idling) { | |
| 4337 assert(_collectorState == AbortablePreclean, | |
| 4338 "Spontaneous state transition?"); | |
| 4339 _collectorState = FinalMarking; | |
| 4340 } // Else, a foreground collection completed this CMS cycle. | |
| 4341 return; | |
| 4342 } | |
| 4343 | |
| 4344 // Respond to an Eden sampling opportunity | |
| 4345 void CMSCollector::sample_eden() { | |
| 4346 // Make sure a young gc cannot sneak in between our | |
| 4347 // reading and recording of a sample. | |
| 4348 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 4349 "Only the cms thread may collect Eden samples"); | |
| 4350 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 4351 "Should collect samples while holding CMS token"); | |
| 4352 if (!_start_sampling) { | |
| 4353 return; | |
| 4354 } | |
| 4355 if (_eden_chunk_array) { | |
| 4356 if (_eden_chunk_index < _eden_chunk_capacity) { | |
| 4357 _eden_chunk_array[_eden_chunk_index] = *_top_addr; // take sample | |
| 4358 assert(_eden_chunk_array[_eden_chunk_index] <= *_end_addr, | |
| 4359 "Unexpected state of Eden"); | |
| 4360 // We'd like to check that what we just sampled is an oop-start address; | |
| 4361 // however, we cannot do that here since the object may not yet have been | |
| 4362 // initialized. So we'll instead do the check when we _use_ this sample | |
| 4363 // later. | |
| 4364 if (_eden_chunk_index == 0 || | |
| 4365 (pointer_delta(_eden_chunk_array[_eden_chunk_index], | |
| 4366 _eden_chunk_array[_eden_chunk_index-1]) | |
| 4367 >= CMSSamplingGrain)) { | |
| 4368 _eden_chunk_index++; // commit sample | |
| 4369 } | |
| 4370 } | |
| 4371 } | |
| 4372 if ((_collectorState == AbortablePreclean) && !_abort_preclean) { | |
| 4373 size_t used = get_eden_used(); | |
| 4374 size_t capacity = get_eden_capacity(); | |
| 4375 assert(used <= capacity, "Unexpected state of Eden"); | |
| 4376 if (used > (capacity/100 * CMSScheduleRemarkEdenPenetration)) { | |
| 4377 _abort_preclean = true; | |
| 4378 } | |
| 4379 } | |
| 4380 } | |
| 4381 | |
| 4382 | |
| 4383 size_t CMSCollector::preclean_work(bool clean_refs, bool clean_survivor) { | |
| 4384 assert(_collectorState == Precleaning || | |
| 4385 _collectorState == AbortablePreclean, "incorrect state"); | |
| 4386 ResourceMark rm; | |
| 4387 HandleMark hm; | |
| 4388 // Do one pass of scrubbing the discovered reference lists | |
| 4389 // to remove any reference objects with strongly-reachable | |
| 4390 // referents. | |
| 4391 if (clean_refs) { | |
| 4392 ReferenceProcessor* rp = ref_processor(); | |
| 4393 CMSPrecleanRefsYieldClosure yield_cl(this); | |
| 4394 assert(rp->span().equals(_span), "Spans should be equal"); | |
| 4395 CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap, | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4396 &_markStack, true /* preclean */); |
| 0 | 4397 CMSDrainMarkingStackClosure complete_trace(this, |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4398 _span, &_markBitMap, &_markStack, |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4399 &keep_alive, true /* preclean */); |
| 0 | 4400 |
| 4401 // We don't want this step to interfere with a young | |
| 4402 // collection because we don't want to take CPU | |
| 4403 // or memory bandwidth away from the young GC threads | |
| 4404 // (which may be as many as there are CPUs). | |
| 4405 // Note that we don't need to protect ourselves from | |
| 4406 // interference with mutators because they can't | |
| 4407 // manipulate the discovered reference lists nor affect | |
| 4408 // the computed reachability of the referents, the | |
| 4409 // only properties manipulated by the precleaning | |
| 4410 // of these reference lists. | |
| 4411 stopTimer(); | |
| 4412 CMSTokenSyncWithLocks x(true /* is cms thread */, | |
| 4413 bitMapLock()); | |
| 4414 startTimer(); | |
| 4415 sample_eden(); | |
| 4416 // The following will yield to allow foreground | |
| 4417 // collection to proceed promptly. XXX YSR: | |
| 4418 // The code in this method may need further | |
| 4419 // tweaking for better performance and some restructuring | |
| 4420 // for cleaner interfaces. | |
| 4421 rp->preclean_discovered_references( | |
| 4422 rp->is_alive_non_header(), &keep_alive, &complete_trace, | |
| 4423 &yield_cl); | |
| 4424 } | |
| 4425 | |
| 4426 if (clean_survivor) { // preclean the active survivor space(s) | |
| 4427 assert(_young_gen->kind() == Generation::DefNew || | |
| 4428 _young_gen->kind() == Generation::ParNew || | |
| 4429 _young_gen->kind() == Generation::ASParNew, | |
| 4430 "incorrect type for cast"); | |
| 4431 DefNewGeneration* dng = (DefNewGeneration*)_young_gen; | |
| 4432 PushAndMarkClosure pam_cl(this, _span, ref_processor(), | |
| 4433 &_markBitMap, &_modUnionTable, | |
| 4434 &_markStack, &_revisitStack, | |
| 4435 true /* precleaning phase */); | |
| 4436 stopTimer(); | |
| 4437 CMSTokenSyncWithLocks ts(true /* is cms thread */, | |
| 4438 bitMapLock()); | |
| 4439 startTimer(); | |
| 4440 unsigned int before_count = | |
| 4441 GenCollectedHeap::heap()->total_collections(); | |
| 4442 SurvivorSpacePrecleanClosure | |
| 4443 sss_cl(this, _span, &_markBitMap, &_markStack, | |
| 4444 &pam_cl, before_count, CMSYield); | |
| 4445 dng->from()->object_iterate_careful(&sss_cl); | |
| 4446 dng->to()->object_iterate_careful(&sss_cl); | |
| 4447 } | |
| 4448 MarkRefsIntoAndScanClosure | |
| 4449 mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable, | |
| 4450 &_markStack, &_revisitStack, this, CMSYield, | |
| 4451 true /* precleaning phase */); | |
| 4452 // CAUTION: The following closure has persistent state that may need to | |
| 4453 // be reset upon a decrease in the sequence of addresses it | |
| 4454 // processes. | |
| 4455 ScanMarkedObjectsAgainCarefullyClosure | |
| 4456 smoac_cl(this, _span, | |
| 4457 &_markBitMap, &_markStack, &_revisitStack, &mrias_cl, CMSYield); | |
| 4458 | |
| 4459 // Preclean dirty cards in ModUnionTable and CardTable using | |
| 4460 // appropriate convergence criterion; | |
| 4461 // repeat CMSPrecleanIter times unless we find that | |
| 4462 // we are losing. | |
| 4463 assert(CMSPrecleanIter < 10, "CMSPrecleanIter is too large"); | |
| 4464 assert(CMSPrecleanNumerator < CMSPrecleanDenominator, | |
| 4465 "Bad convergence multiplier"); | |
| 4466 assert(CMSPrecleanThreshold >= 100, | |
| 4467 "Unreasonably low CMSPrecleanThreshold"); | |
| 4468 | |
| 4469 size_t numIter, cumNumCards, lastNumCards, curNumCards; | |
| 4470 for (numIter = 0, cumNumCards = lastNumCards = curNumCards = 0; | |
| 4471 numIter < CMSPrecleanIter; | |
| 4472 numIter++, lastNumCards = curNumCards, cumNumCards += curNumCards) { | |
| 4473 curNumCards = preclean_mod_union_table(_cmsGen, &smoac_cl); | |
| 4474 if (CMSPermGenPrecleaningEnabled) { | |
| 4475 curNumCards += preclean_mod_union_table(_permGen, &smoac_cl); | |
| 4476 } | |
| 4477 if (Verbose && PrintGCDetails) { | |
| 4478 gclog_or_tty->print(" (modUnionTable: %d cards)", curNumCards); | |
| 4479 } | |
| 4480 // Either there are very few dirty cards, so re-mark | |
| 4481 // pause will be small anyway, or our pre-cleaning isn't | |
| 4482 // that much faster than the rate at which cards are being | |
| 4483 // dirtied, so we might as well stop and re-mark since | |
| 4484 // precleaning won't improve our re-mark time by much. | |
| 4485 if (curNumCards <= CMSPrecleanThreshold || | |
| 4486 (numIter > 0 && | |
| 4487 (curNumCards * CMSPrecleanDenominator > | |
| 4488 lastNumCards * CMSPrecleanNumerator))) { | |
| 4489 numIter++; | |
| 4490 cumNumCards += curNumCards; | |
| 4491 break; | |
| 4492 } | |
| 4493 } | |
| 4494 curNumCards = preclean_card_table(_cmsGen, &smoac_cl); | |
| 4495 if (CMSPermGenPrecleaningEnabled) { | |
| 4496 curNumCards += preclean_card_table(_permGen, &smoac_cl); | |
| 4497 } | |
| 4498 cumNumCards += curNumCards; | |
| 4499 if (PrintGCDetails && PrintCMSStatistics != 0) { | |
| 4500 gclog_or_tty->print_cr(" (cardTable: %d cards, re-scanned %d cards, %d iterations)", | |
| 4501 curNumCards, cumNumCards, numIter); | |
| 4502 } | |
| 4503 return cumNumCards; // as a measure of useful work done | |
| 4504 } | |
| 4505 | |
| 4506 // PRECLEANING NOTES: | |
| 4507 // Precleaning involves: | |
| 4508 // . reading the bits of the modUnionTable and clearing the set bits. | |
| 4509 // . For the cards corresponding to the set bits, we scan the | |
| 4510 // objects on those cards. This means we need the free_list_lock | |
| 4511 // so that we can safely iterate over the CMS space when scanning | |
| 4512 // for oops. | |
| 4513 // . When we scan the objects, we'll be both reading and setting | |
| 4514 // marks in the marking bit map, so we'll need the marking bit map. | |
| 4515 // . For protecting _collector_state transitions, we take the CGC_lock. | |
| 4516 // Note that any races in the reading of of card table entries by the | |
| 4517 // CMS thread on the one hand and the clearing of those entries by the | |
| 4518 // VM thread or the setting of those entries by the mutator threads on the | |
| 4519 // other are quite benign. However, for efficiency it makes sense to keep | |
| 4520 // the VM thread from racing with the CMS thread while the latter is | |
| 4521 // dirty card info to the modUnionTable. We therefore also use the | |
| 4522 // CGC_lock to protect the reading of the card table and the mod union | |
| 4523 // table by the CM thread. | |
| 4524 // . We run concurrently with mutator updates, so scanning | |
| 4525 // needs to be done carefully -- we should not try to scan | |
| 4526 // potentially uninitialized objects. | |
| 4527 // | |
| 4528 // Locking strategy: While holding the CGC_lock, we scan over and | |
| 4529 // reset a maximal dirty range of the mod union / card tables, then lock | |
| 4530 // the free_list_lock and bitmap lock to do a full marking, then | |
| 4531 // release these locks; and repeat the cycle. This allows for a | |
| 4532 // certain amount of fairness in the sharing of these locks between | |
| 4533 // the CMS collector on the one hand, and the VM thread and the | |
| 4534 // mutators on the other. | |
| 4535 | |
| 4536 // NOTE: preclean_mod_union_table() and preclean_card_table() | |
| 4537 // further below are largely identical; if you need to modify | |
| 4538 // one of these methods, please check the other method too. | |
| 4539 | |
| 4540 size_t CMSCollector::preclean_mod_union_table( | |
| 4541 ConcurrentMarkSweepGeneration* gen, | |
| 4542 ScanMarkedObjectsAgainCarefullyClosure* cl) { | |
| 4543 verify_work_stacks_empty(); | |
| 4544 verify_overflow_empty(); | |
| 4545 | |
| 4546 // strategy: starting with the first card, accumulate contiguous | |
| 4547 // ranges of dirty cards; clear these cards, then scan the region | |
| 4548 // covered by these cards. | |
| 4549 | |
| 4550 // Since all of the MUT is committed ahead, we can just use | |
| 4551 // that, in case the generations expand while we are precleaning. | |
| 4552 // It might also be fine to just use the committed part of the | |
| 4553 // generation, but we might potentially miss cards when the | |
| 4554 // generation is rapidly expanding while we are in the midst | |
| 4555 // of precleaning. | |
| 4556 HeapWord* startAddr = gen->reserved().start(); | |
| 4557 HeapWord* endAddr = gen->reserved().end(); | |
| 4558 | |
| 4559 cl->setFreelistLock(gen->freelistLock()); // needed for yielding | |
| 4560 | |
| 4561 size_t numDirtyCards, cumNumDirtyCards; | |
| 4562 HeapWord *nextAddr, *lastAddr; | |
| 4563 for (cumNumDirtyCards = numDirtyCards = 0, | |
| 4564 nextAddr = lastAddr = startAddr; | |
| 4565 nextAddr < endAddr; | |
| 4566 nextAddr = lastAddr, cumNumDirtyCards += numDirtyCards) { | |
| 4567 | |
| 4568 ResourceMark rm; | |
| 4569 HandleMark hm; | |
| 4570 | |
| 4571 MemRegion dirtyRegion; | |
| 4572 { | |
| 4573 stopTimer(); | |
| 4574 CMSTokenSync ts(true); | |
| 4575 startTimer(); | |
| 4576 sample_eden(); | |
| 4577 // Get dirty region starting at nextOffset (inclusive), | |
| 4578 // simultaneously clearing it. | |
| 4579 dirtyRegion = | |
| 4580 _modUnionTable.getAndClearMarkedRegion(nextAddr, endAddr); | |
| 4581 assert(dirtyRegion.start() >= nextAddr, | |
| 4582 "returned region inconsistent?"); | |
| 4583 } | |
| 4584 // Remember where the next search should begin. | |
| 4585 // The returned region (if non-empty) is a right open interval, | |
| 4586 // so lastOffset is obtained from the right end of that | |
| 4587 // interval. | |
| 4588 lastAddr = dirtyRegion.end(); | |
| 4589 // Should do something more transparent and less hacky XXX | |
| 4590 numDirtyCards = | |
| 4591 _modUnionTable.heapWordDiffToOffsetDiff(dirtyRegion.word_size()); | |
| 4592 | |
| 4593 // We'll scan the cards in the dirty region (with periodic | |
| 4594 // yields for foreground GC as needed). | |
| 4595 if (!dirtyRegion.is_empty()) { | |
| 4596 assert(numDirtyCards > 0, "consistency check"); | |
| 4597 HeapWord* stop_point = NULL; | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4598 stopTimer(); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4599 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4600 bitMapLock()); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4601 startTimer(); |
| 0 | 4602 { |
| 4603 verify_work_stacks_empty(); | |
| 4604 verify_overflow_empty(); | |
| 4605 sample_eden(); | |
| 4606 stop_point = | |
| 4607 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); | |
| 4608 } | |
| 4609 if (stop_point != NULL) { | |
| 4610 // The careful iteration stopped early either because it found an | |
| 4611 // uninitialized object, or because we were in the midst of an | |
| 4612 // "abortable preclean", which should now be aborted. Redirty | |
| 4613 // the bits corresponding to the partially-scanned or unscanned | |
| 4614 // cards. We'll either restart at the next block boundary or | |
| 4615 // abort the preclean. | |
| 4616 assert((CMSPermGenPrecleaningEnabled && (gen == _permGen)) || | |
| 4617 (_collectorState == AbortablePreclean && should_abort_preclean()), | |
| 4618 "Unparsable objects should only be in perm gen."); | |
| 4619 _modUnionTable.mark_range(MemRegion(stop_point, dirtyRegion.end())); | |
| 4620 if (should_abort_preclean()) { | |
| 4621 break; // out of preclean loop | |
| 4622 } else { | |
| 4623 // Compute the next address at which preclean should pick up; | |
| 4624 // might need bitMapLock in order to read P-bits. | |
| 4625 lastAddr = next_card_start_after_block(stop_point); | |
| 4626 } | |
| 4627 } | |
| 4628 } else { | |
| 4629 assert(lastAddr == endAddr, "consistency check"); | |
| 4630 assert(numDirtyCards == 0, "consistency check"); | |
| 4631 break; | |
| 4632 } | |
| 4633 } | |
| 4634 verify_work_stacks_empty(); | |
| 4635 verify_overflow_empty(); | |
| 4636 return cumNumDirtyCards; | |
| 4637 } | |
| 4638 | |
| 4639 // NOTE: preclean_mod_union_table() above and preclean_card_table() | |
| 4640 // below are largely identical; if you need to modify | |
| 4641 // one of these methods, please check the other method too. | |
| 4642 | |
| 4643 size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* gen, | |
| 4644 ScanMarkedObjectsAgainCarefullyClosure* cl) { | |
| 4645 // strategy: it's similar to precleamModUnionTable above, in that | |
| 4646 // we accumulate contiguous ranges of dirty cards, mark these cards | |
| 4647 // precleaned, then scan the region covered by these cards. | |
| 4648 HeapWord* endAddr = (HeapWord*)(gen->_virtual_space.high()); | |
| 4649 HeapWord* startAddr = (HeapWord*)(gen->_virtual_space.low()); | |
| 4650 | |
| 4651 cl->setFreelistLock(gen->freelistLock()); // needed for yielding | |
| 4652 | |
| 4653 size_t numDirtyCards, cumNumDirtyCards; | |
| 4654 HeapWord *lastAddr, *nextAddr; | |
| 4655 | |
| 4656 for (cumNumDirtyCards = numDirtyCards = 0, | |
| 4657 nextAddr = lastAddr = startAddr; | |
| 4658 nextAddr < endAddr; | |
| 4659 nextAddr = lastAddr, cumNumDirtyCards += numDirtyCards) { | |
| 4660 | |
| 4661 ResourceMark rm; | |
| 4662 HandleMark hm; | |
| 4663 | |
| 4664 MemRegion dirtyRegion; | |
| 4665 { | |
| 4666 // See comments in "Precleaning notes" above on why we | |
| 4667 // do this locking. XXX Could the locking overheads be | |
| 4668 // too high when dirty cards are sparse? [I don't think so.] | |
| 4669 stopTimer(); | |
| 4670 CMSTokenSync x(true); // is cms thread | |
| 4671 startTimer(); | |
| 4672 sample_eden(); | |
| 4673 // Get and clear dirty region from card table | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4674 dirtyRegion = _ct->ct_bs()->dirty_card_range_after_reset( |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4675 MemRegion(nextAddr, endAddr), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4676 true, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4677 CardTableModRefBS::precleaned_card_val()); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4678 |
| 0 | 4679 assert(dirtyRegion.start() >= nextAddr, |
| 4680 "returned region inconsistent?"); | |
| 4681 } | |
| 4682 lastAddr = dirtyRegion.end(); | |
| 4683 numDirtyCards = | |
| 4684 dirtyRegion.word_size()/CardTableModRefBS::card_size_in_words; | |
| 4685 | |
| 4686 if (!dirtyRegion.is_empty()) { | |
| 4687 stopTimer(); | |
| 4688 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock()); | |
| 4689 startTimer(); | |
| 4690 sample_eden(); | |
| 4691 verify_work_stacks_empty(); | |
| 4692 verify_overflow_empty(); | |
| 4693 HeapWord* stop_point = | |
| 4694 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); | |
| 4695 if (stop_point != NULL) { | |
| 4696 // The careful iteration stopped early because it found an | |
| 4697 // uninitialized object. Redirty the bits corresponding to the | |
| 4698 // partially-scanned or unscanned cards, and start again at the | |
| 4699 // next block boundary. | |
| 4700 assert(CMSPermGenPrecleaningEnabled || | |
| 4701 (_collectorState == AbortablePreclean && should_abort_preclean()), | |
| 4702 "Unparsable objects should only be in perm gen."); | |
| 4703 _ct->ct_bs()->invalidate(MemRegion(stop_point, dirtyRegion.end())); | |
| 4704 if (should_abort_preclean()) { | |
| 4705 break; // out of preclean loop | |
| 4706 } else { | |
| 4707 // Compute the next address at which preclean should pick up. | |
| 4708 lastAddr = next_card_start_after_block(stop_point); | |
| 4709 } | |
| 4710 } | |
| 4711 } else { | |
| 4712 break; | |
| 4713 } | |
| 4714 } | |
| 4715 verify_work_stacks_empty(); | |
| 4716 verify_overflow_empty(); | |
| 4717 return cumNumDirtyCards; | |
| 4718 } | |
| 4719 | |
| 4720 void CMSCollector::checkpointRootsFinal(bool asynch, | |
| 4721 bool clear_all_soft_refs, bool init_mark_was_synchronous) { | |
| 4722 assert(_collectorState == FinalMarking, "incorrect state transition?"); | |
| 4723 check_correct_thread_executing(); | |
| 4724 // world is stopped at this checkpoint | |
| 4725 assert(SafepointSynchronize::is_at_safepoint(), | |
| 4726 "world should be stopped"); | |
| 4727 verify_work_stacks_empty(); | |
| 4728 verify_overflow_empty(); | |
| 4729 | |
| 4730 SpecializationStats::clear(); | |
| 4731 if (PrintGCDetails) { | |
| 4732 gclog_or_tty->print("[YG occupancy: "SIZE_FORMAT" K ("SIZE_FORMAT" K)]", | |
| 4733 _young_gen->used() / K, | |
| 4734 _young_gen->capacity() / K); | |
| 4735 } | |
| 4736 if (asynch) { | |
| 4737 if (CMSScavengeBeforeRemark) { | |
| 4738 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 4739 // Temporarily set flag to false, GCH->do_collection will | |
| 4740 // expect it to be false and set to true | |
| 4741 FlagSetting fl(gch->_is_gc_active, false); | |
| 4742 NOT_PRODUCT(TraceTime t("Scavenge-Before-Remark", | |
| 4743 PrintGCDetails && Verbose, true, gclog_or_tty);) | |
| 4744 int level = _cmsGen->level() - 1; | |
| 4745 if (level >= 0) { | |
| 4746 gch->do_collection(true, // full (i.e. force, see below) | |
| 4747 false, // !clear_all_soft_refs | |
| 4748 0, // size | |
| 4749 false, // is_tlab | |
| 4750 level // max_level | |
| 4751 ); | |
| 4752 } | |
| 4753 } | |
| 4754 FreelistLocker x(this); | |
| 4755 MutexLockerEx y(bitMapLock(), | |
| 4756 Mutex::_no_safepoint_check_flag); | |
| 4757 assert(!init_mark_was_synchronous, "but that's impossible!"); | |
| 4758 checkpointRootsFinalWork(asynch, clear_all_soft_refs, false); | |
| 4759 } else { | |
| 4760 // already have all the locks | |
| 4761 checkpointRootsFinalWork(asynch, clear_all_soft_refs, | |
| 4762 init_mark_was_synchronous); | |
| 4763 } | |
| 4764 verify_work_stacks_empty(); | |
| 4765 verify_overflow_empty(); | |
| 4766 SpecializationStats::print(); | |
| 4767 } | |
| 4768 | |
| 4769 void CMSCollector::checkpointRootsFinalWork(bool asynch, | |
| 4770 bool clear_all_soft_refs, bool init_mark_was_synchronous) { | |
| 4771 | |
| 4772 NOT_PRODUCT(TraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, gclog_or_tty);) | |
| 4773 | |
| 4774 assert(haveFreelistLocks(), "must have free list locks"); | |
| 4775 assert_lock_strong(bitMapLock()); | |
| 4776 | |
| 4777 if (UseAdaptiveSizePolicy) { | |
| 4778 size_policy()->checkpoint_roots_final_begin(); | |
| 4779 } | |
| 4780 | |
| 4781 ResourceMark rm; | |
| 4782 HandleMark hm; | |
| 4783 | |
| 4784 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 4785 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
4786 if (should_unload_classes()) { |
| 0 | 4787 CodeCache::gc_prologue(); |
| 4788 } | |
| 4789 assert(haveFreelistLocks(), "must have free list locks"); | |
| 4790 assert_lock_strong(bitMapLock()); | |
| 4791 | |
| 4792 if (!init_mark_was_synchronous) { | |
| 4793 // We might assume that we need not fill TLAB's when | |
| 4794 // CMSScavengeBeforeRemark is set, because we may have just done | |
| 4795 // a scavenge which would have filled all TLAB's -- and besides | |
| 4796 // Eden would be empty. This however may not always be the case -- | |
| 4797 // for instance although we asked for a scavenge, it may not have | |
| 4798 // happened because of a JNI critical section. We probably need | |
| 4799 // a policy for deciding whether we can in that case wait until | |
| 4800 // the critical section releases and then do the remark following | |
| 4801 // the scavenge, and skip it here. In the absence of that policy, | |
| 4802 // or of an indication of whether the scavenge did indeed occur, | |
| 4803 // we cannot rely on TLAB's having been filled and must do | |
| 4804 // so here just in case a scavenge did not happen. | |
| 4805 gch->ensure_parsability(false); // fill TLAB's, but no need to retire them | |
| 4806 // Update the saved marks which may affect the root scans. | |
| 4807 gch->save_marks(); | |
| 4808 | |
| 4809 { | |
| 4810 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 4811 | |
| 4812 // Note on the role of the mod union table: | |
| 4813 // Since the marker in "markFromRoots" marks concurrently with | |
| 4814 // mutators, it is possible for some reachable objects not to have been | |
| 4815 // scanned. For instance, an only reference to an object A was | |
| 4816 // placed in object B after the marker scanned B. Unless B is rescanned, | |
| 4817 // A would be collected. Such updates to references in marked objects | |
| 4818 // are detected via the mod union table which is the set of all cards | |
| 4819 // dirtied since the first checkpoint in this GC cycle and prior to | |
| 4820 // the most recent young generation GC, minus those cleaned up by the | |
| 4821 // concurrent precleaning. | |
| 4822 if (CMSParallelRemarkEnabled && ParallelGCThreads > 0) { | |
| 4823 TraceTime t("Rescan (parallel) ", PrintGCDetails, false, gclog_or_tty); | |
| 4824 do_remark_parallel(); | |
| 4825 } else { | |
| 4826 TraceTime t("Rescan (non-parallel) ", PrintGCDetails, false, | |
| 4827 gclog_or_tty); | |
| 4828 do_remark_non_parallel(); | |
| 4829 } | |
| 4830 } | |
| 4831 } else { | |
| 4832 assert(!asynch, "Can't have init_mark_was_synchronous in asynch mode"); | |
| 4833 // The initial mark was stop-world, so there's no rescanning to | |
| 4834 // do; go straight on to the next step below. | |
| 4835 } | |
| 4836 verify_work_stacks_empty(); | |
| 4837 verify_overflow_empty(); | |
| 4838 | |
| 4839 { | |
| 4840 NOT_PRODUCT(TraceTime ts("refProcessingWork", PrintGCDetails, false, gclog_or_tty);) | |
| 4841 refProcessingWork(asynch, clear_all_soft_refs); | |
| 4842 } | |
| 4843 verify_work_stacks_empty(); | |
| 4844 verify_overflow_empty(); | |
| 4845 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
4846 if (should_unload_classes()) { |
| 0 | 4847 CodeCache::gc_epilogue(); |
| 4848 } | |
| 4849 | |
| 4850 // If we encountered any (marking stack / work queue) overflow | |
| 4851 // events during the current CMS cycle, take appropriate | |
| 4852 // remedial measures, where possible, so as to try and avoid | |
| 4853 // recurrence of that condition. | |
| 4854 assert(_markStack.isEmpty(), "No grey objects"); | |
| 4855 size_t ser_ovflw = _ser_pmc_remark_ovflw + _ser_pmc_preclean_ovflw + | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4856 _ser_kac_ovflw + _ser_kac_preclean_ovflw; |
| 0 | 4857 if (ser_ovflw > 0) { |
| 4858 if (PrintCMSStatistics != 0) { | |
| 4859 gclog_or_tty->print_cr("Marking stack overflow (benign) " | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4860 "(pmc_pc="SIZE_FORMAT", pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4861 ", kac_preclean="SIZE_FORMAT")", |
| 0 | 4862 _ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw, |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4863 _ser_kac_ovflw, _ser_kac_preclean_ovflw); |
| 0 | 4864 } |
| 4865 _markStack.expand(); | |
| 4866 _ser_pmc_remark_ovflw = 0; | |
| 4867 _ser_pmc_preclean_ovflw = 0; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4868 _ser_kac_preclean_ovflw = 0; |
| 0 | 4869 _ser_kac_ovflw = 0; |
| 4870 } | |
| 4871 if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) { | |
| 4872 if (PrintCMSStatistics != 0) { | |
| 4873 gclog_or_tty->print_cr("Work queue overflow (benign) " | |
| 4874 "(pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT")", | |
| 4875 _par_pmc_remark_ovflw, _par_kac_ovflw); | |
| 4876 } | |
| 4877 _par_pmc_remark_ovflw = 0; | |
| 4878 _par_kac_ovflw = 0; | |
| 4879 } | |
| 4880 if (PrintCMSStatistics != 0) { | |
| 4881 if (_markStack._hit_limit > 0) { | |
| 4882 gclog_or_tty->print_cr(" (benign) Hit max stack size limit ("SIZE_FORMAT")", | |
| 4883 _markStack._hit_limit); | |
| 4884 } | |
| 4885 if (_markStack._failed_double > 0) { | |
| 4886 gclog_or_tty->print_cr(" (benign) Failed stack doubling ("SIZE_FORMAT")," | |
| 4887 " current capacity "SIZE_FORMAT, | |
| 4888 _markStack._failed_double, | |
| 4889 _markStack.capacity()); | |
| 4890 } | |
| 4891 } | |
| 4892 _markStack._hit_limit = 0; | |
| 4893 _markStack._failed_double = 0; | |
| 4894 | |
| 4895 if ((VerifyAfterGC || VerifyDuringGC) && | |
| 4896 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 4897 verify_after_remark(); | |
| 4898 } | |
| 4899 | |
| 4900 // Change under the freelistLocks. | |
| 4901 _collectorState = Sweeping; | |
| 4902 // Call isAllClear() under bitMapLock | |
| 4903 assert(_modUnionTable.isAllClear(), "Should be clear by end of the" | |
| 4904 " final marking"); | |
| 4905 if (UseAdaptiveSizePolicy) { | |
| 4906 size_policy()->checkpoint_roots_final_end(gch->gc_cause()); | |
| 4907 } | |
| 4908 } | |
| 4909 | |
| 4910 // Parallel remark task | |
| 4911 class CMSParRemarkTask: public AbstractGangTask { | |
| 4912 CMSCollector* _collector; | |
| 4913 WorkGang* _workers; | |
| 4914 int _n_workers; | |
| 4915 CompactibleFreeListSpace* _cms_space; | |
| 4916 CompactibleFreeListSpace* _perm_space; | |
| 4917 | |
| 4918 // The per-thread work queues, available here for stealing. | |
| 4919 OopTaskQueueSet* _task_queues; | |
| 4920 ParallelTaskTerminator _term; | |
| 4921 | |
| 4922 public: | |
| 4923 CMSParRemarkTask(CMSCollector* collector, | |
| 4924 CompactibleFreeListSpace* cms_space, | |
| 4925 CompactibleFreeListSpace* perm_space, | |
| 4926 int n_workers, WorkGang* workers, | |
| 4927 OopTaskQueueSet* task_queues): | |
| 4928 AbstractGangTask("Rescan roots and grey objects in parallel"), | |
| 4929 _collector(collector), | |
| 4930 _cms_space(cms_space), _perm_space(perm_space), | |
| 4931 _n_workers(n_workers), | |
| 4932 _workers(workers), | |
| 4933 _task_queues(task_queues), | |
| 4934 _term(workers->total_workers(), task_queues) { } | |
| 4935 | |
| 4936 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 4937 | |
| 4938 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 4939 | |
| 4940 ParallelTaskTerminator* terminator() { return &_term; } | |
| 4941 | |
| 4942 void work(int i); | |
| 4943 | |
| 4944 private: | |
| 4945 // Work method in support of parallel rescan ... of young gen spaces | |
| 4946 void do_young_space_rescan(int i, Par_MarkRefsIntoAndScanClosure* cl, | |
| 4947 ContiguousSpace* space, | |
| 4948 HeapWord** chunk_array, size_t chunk_top); | |
| 4949 | |
| 4950 // ... of dirty cards in old space | |
| 4951 void do_dirty_card_rescan_tasks(CompactibleFreeListSpace* sp, int i, | |
| 4952 Par_MarkRefsIntoAndScanClosure* cl); | |
| 4953 | |
| 4954 // ... work stealing for the above | |
| 4955 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed); | |
| 4956 }; | |
| 4957 | |
| 4958 void CMSParRemarkTask::work(int i) { | |
| 4959 elapsedTimer _timer; | |
| 4960 ResourceMark rm; | |
| 4961 HandleMark hm; | |
| 4962 | |
| 4963 // ---------- rescan from roots -------------- | |
| 4964 _timer.start(); | |
| 4965 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 4966 Par_MarkRefsIntoAndScanClosure par_mrias_cl(_collector, | |
| 4967 _collector->_span, _collector->ref_processor(), | |
| 4968 &(_collector->_markBitMap), | |
| 4969 work_queue(i), &(_collector->_revisitStack)); | |
| 4970 | |
| 4971 // Rescan young gen roots first since these are likely | |
| 4972 // coarsely partitioned and may, on that account, constitute | |
| 4973 // the critical path; thus, it's best to start off that | |
| 4974 // work first. | |
| 4975 // ---------- young gen roots -------------- | |
| 4976 { | |
| 4977 DefNewGeneration* dng = _collector->_young_gen->as_DefNewGeneration(); | |
| 4978 EdenSpace* eden_space = dng->eden(); | |
| 4979 ContiguousSpace* from_space = dng->from(); | |
| 4980 ContiguousSpace* to_space = dng->to(); | |
| 4981 | |
| 4982 HeapWord** eca = _collector->_eden_chunk_array; | |
| 4983 size_t ect = _collector->_eden_chunk_index; | |
| 4984 HeapWord** sca = _collector->_survivor_chunk_array; | |
| 4985 size_t sct = _collector->_survivor_chunk_index; | |
| 4986 | |
| 4987 assert(ect <= _collector->_eden_chunk_capacity, "out of bounds"); | |
| 4988 assert(sct <= _collector->_survivor_chunk_capacity, "out of bounds"); | |
| 4989 | |
| 4990 do_young_space_rescan(i, &par_mrias_cl, to_space, NULL, 0); | |
| 4991 do_young_space_rescan(i, &par_mrias_cl, from_space, sca, sct); | |
| 4992 do_young_space_rescan(i, &par_mrias_cl, eden_space, eca, ect); | |
| 4993 | |
| 4994 _timer.stop(); | |
| 4995 if (PrintCMSStatistics != 0) { | |
| 4996 gclog_or_tty->print_cr( | |
| 4997 "Finished young gen rescan work in %dth thread: %3.3f sec", | |
| 4998 i, _timer.seconds()); | |
| 4999 } | |
| 5000 } | |
| 5001 | |
| 5002 // ---------- remaining roots -------------- | |
| 5003 _timer.reset(); | |
| 5004 _timer.start(); | |
| 5005 gch->gen_process_strong_roots(_collector->_cmsGen->level(), | |
| 5006 false, // yg was scanned above | |
| 5007 true, // collecting perm gen | |
| 5008 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), | |
| 5009 NULL, &par_mrias_cl); | |
| 5010 _timer.stop(); | |
| 5011 if (PrintCMSStatistics != 0) { | |
| 5012 gclog_or_tty->print_cr( | |
| 5013 "Finished remaining root rescan work in %dth thread: %3.3f sec", | |
| 5014 i, _timer.seconds()); | |
| 5015 } | |
| 5016 | |
| 5017 // ---------- rescan dirty cards ------------ | |
| 5018 _timer.reset(); | |
| 5019 _timer.start(); | |
| 5020 | |
| 5021 // Do the rescan tasks for each of the two spaces | |
| 5022 // (cms_space and perm_space) in turn. | |
| 5023 do_dirty_card_rescan_tasks(_cms_space, i, &par_mrias_cl); | |
| 5024 do_dirty_card_rescan_tasks(_perm_space, i, &par_mrias_cl); | |
| 5025 _timer.stop(); | |
| 5026 if (PrintCMSStatistics != 0) { | |
| 5027 gclog_or_tty->print_cr( | |
| 5028 "Finished dirty card rescan work in %dth thread: %3.3f sec", | |
| 5029 i, _timer.seconds()); | |
| 5030 } | |
| 5031 | |
| 5032 // ---------- steal work from other threads ... | |
| 5033 // ---------- ... and drain overflow list. | |
| 5034 _timer.reset(); | |
| 5035 _timer.start(); | |
| 5036 do_work_steal(i, &par_mrias_cl, _collector->hash_seed(i)); | |
| 5037 _timer.stop(); | |
| 5038 if (PrintCMSStatistics != 0) { | |
| 5039 gclog_or_tty->print_cr( | |
| 5040 "Finished work stealing in %dth thread: %3.3f sec", | |
| 5041 i, _timer.seconds()); | |
| 5042 } | |
| 5043 } | |
| 5044 | |
| 5045 void | |
| 5046 CMSParRemarkTask::do_young_space_rescan(int i, | |
| 5047 Par_MarkRefsIntoAndScanClosure* cl, ContiguousSpace* space, | |
| 5048 HeapWord** chunk_array, size_t chunk_top) { | |
| 5049 // Until all tasks completed: | |
| 5050 // . claim an unclaimed task | |
| 5051 // . compute region boundaries corresponding to task claimed | |
| 5052 // using chunk_array | |
| 5053 // . par_oop_iterate(cl) over that region | |
| 5054 | |
| 5055 ResourceMark rm; | |
| 5056 HandleMark hm; | |
| 5057 | |
| 5058 SequentialSubTasksDone* pst = space->par_seq_tasks(); | |
| 5059 assert(pst->valid(), "Uninitialized use?"); | |
| 5060 | |
| 5061 int nth_task = 0; | |
| 5062 int n_tasks = pst->n_tasks(); | |
| 5063 | |
| 5064 HeapWord *start, *end; | |
| 5065 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 5066 // We claimed task # nth_task; compute its boundaries. | |
| 5067 if (chunk_top == 0) { // no samples were taken | |
| 5068 assert(nth_task == 0 && n_tasks == 1, "Can have only 1 EdenSpace task"); | |
| 5069 start = space->bottom(); | |
| 5070 end = space->top(); | |
| 5071 } else if (nth_task == 0) { | |
| 5072 start = space->bottom(); | |
| 5073 end = chunk_array[nth_task]; | |
| 5074 } else if (nth_task < (jint)chunk_top) { | |
| 5075 assert(nth_task >= 1, "Control point invariant"); | |
| 5076 start = chunk_array[nth_task - 1]; | |
| 5077 end = chunk_array[nth_task]; | |
| 5078 } else { | |
| 5079 assert(nth_task == (jint)chunk_top, "Control point invariant"); | |
| 5080 start = chunk_array[chunk_top - 1]; | |
| 5081 end = space->top(); | |
| 5082 } | |
| 5083 MemRegion mr(start, end); | |
| 5084 // Verify that mr is in space | |
| 5085 assert(mr.is_empty() || space->used_region().contains(mr), | |
| 5086 "Should be in space"); | |
| 5087 // Verify that "start" is an object boundary | |
| 5088 assert(mr.is_empty() || oop(mr.start())->is_oop(), | |
| 5089 "Should be an oop"); | |
| 5090 space->par_oop_iterate(mr, cl); | |
| 5091 } | |
| 5092 pst->all_tasks_completed(); | |
| 5093 } | |
| 5094 | |
| 5095 void | |
| 5096 CMSParRemarkTask::do_dirty_card_rescan_tasks( | |
| 5097 CompactibleFreeListSpace* sp, int i, | |
| 5098 Par_MarkRefsIntoAndScanClosure* cl) { | |
| 5099 // Until all tasks completed: | |
| 5100 // . claim an unclaimed task | |
| 5101 // . compute region boundaries corresponding to task claimed | |
| 5102 // . transfer dirty bits ct->mut for that region | |
| 5103 // . apply rescanclosure to dirty mut bits for that region | |
| 5104 | |
| 5105 ResourceMark rm; | |
| 5106 HandleMark hm; | |
| 5107 | |
| 5108 OopTaskQueue* work_q = work_queue(i); | |
| 5109 ModUnionClosure modUnionClosure(&(_collector->_modUnionTable)); | |
| 5110 // CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! | |
| 5111 // CAUTION: This closure has state that persists across calls to | |
| 5112 // the work method dirty_range_iterate_clear() in that it has | |
| 5113 // imbedded in it a (subtype of) UpwardsObjectClosure. The | |
| 5114 // use of that state in the imbedded UpwardsObjectClosure instance | |
| 5115 // assumes that the cards are always iterated (even if in parallel | |
| 5116 // by several threads) in monotonically increasing order per each | |
| 5117 // thread. This is true of the implementation below which picks | |
| 5118 // card ranges (chunks) in monotonically increasing order globally | |
| 5119 // and, a-fortiori, in monotonically increasing order per thread | |
| 5120 // (the latter order being a subsequence of the former). | |
| 5121 // If the work code below is ever reorganized into a more chaotic | |
| 5122 // work-partitioning form than the current "sequential tasks" | |
| 5123 // paradigm, the use of that persistent state will have to be | |
| 5124 // revisited and modified appropriately. See also related | |
| 5125 // bug 4756801 work on which should examine this code to make | |
| 5126 // sure that the changes there do not run counter to the | |
| 5127 // assumptions made here and necessary for correctness and | |
| 5128 // efficiency. Note also that this code might yield inefficient | |
| 5129 // behaviour in the case of very large objects that span one or | |
| 5130 // more work chunks. Such objects would potentially be scanned | |
| 5131 // several times redundantly. Work on 4756801 should try and | |
| 5132 // address that performance anomaly if at all possible. XXX | |
| 5133 MemRegion full_span = _collector->_span; | |
| 5134 CMSBitMap* bm = &(_collector->_markBitMap); // shared | |
| 5135 CMSMarkStack* rs = &(_collector->_revisitStack); // shared | |
| 5136 MarkFromDirtyCardsClosure | |
| 5137 greyRescanClosure(_collector, full_span, // entire span of interest | |
| 5138 sp, bm, work_q, rs, cl); | |
| 5139 | |
| 5140 SequentialSubTasksDone* pst = sp->conc_par_seq_tasks(); | |
| 5141 assert(pst->valid(), "Uninitialized use?"); | |
| 5142 int nth_task = 0; | |
| 5143 const int alignment = CardTableModRefBS::card_size * BitsPerWord; | |
| 5144 MemRegion span = sp->used_region(); | |
| 5145 HeapWord* start_addr = span.start(); | |
| 5146 HeapWord* end_addr = (HeapWord*)round_to((intptr_t)span.end(), | |
| 5147 alignment); | |
| 5148 const size_t chunk_size = sp->rescan_task_size(); // in HeapWord units | |
| 5149 assert((HeapWord*)round_to((intptr_t)start_addr, alignment) == | |
| 5150 start_addr, "Check alignment"); | |
| 5151 assert((size_t)round_to((intptr_t)chunk_size, alignment) == | |
| 5152 chunk_size, "Check alignment"); | |
| 5153 | |
| 5154 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 5155 // Having claimed the nth_task, compute corresponding mem-region, | |
| 5156 // which is a-fortiori aligned correctly (i.e. at a MUT bopundary). | |
| 5157 // The alignment restriction ensures that we do not need any | |
| 5158 // synchronization with other gang-workers while setting or | |
| 5159 // clearing bits in thus chunk of the MUT. | |
| 5160 MemRegion this_span = MemRegion(start_addr + nth_task*chunk_size, | |
| 5161 start_addr + (nth_task+1)*chunk_size); | |
| 5162 // The last chunk's end might be way beyond end of the | |
| 5163 // used region. In that case pull back appropriately. | |
| 5164 if (this_span.end() > end_addr) { | |
| 5165 this_span.set_end(end_addr); | |
| 5166 assert(!this_span.is_empty(), "Program logic (calculation of n_tasks)"); | |
| 5167 } | |
| 5168 // Iterate over the dirty cards covering this chunk, marking them | |
| 5169 // precleaned, and setting the corresponding bits in the mod union | |
| 5170 // table. Since we have been careful to partition at Card and MUT-word | |
| 5171 // boundaries no synchronization is needed between parallel threads. | |
| 5172 _collector->_ct->ct_bs()->dirty_card_iterate(this_span, | |
| 5173 &modUnionClosure); | |
| 5174 | |
| 5175 // Having transferred these marks into the modUnionTable, | |
| 5176 // rescan the marked objects on the dirty cards in the modUnionTable. | |
| 5177 // Even if this is at a synchronous collection, the initial marking | |
| 5178 // may have been done during an asynchronous collection so there | |
| 5179 // may be dirty bits in the mod-union table. | |
| 5180 _collector->_modUnionTable.dirty_range_iterate_clear( | |
| 5181 this_span, &greyRescanClosure); | |
| 5182 _collector->_modUnionTable.verifyNoOneBitsInRange( | |
| 5183 this_span.start(), | |
| 5184 this_span.end()); | |
| 5185 } | |
| 5186 pst->all_tasks_completed(); // declare that i am done | |
| 5187 } | |
| 5188 | |
| 5189 // . see if we can share work_queues with ParNew? XXX | |
| 5190 void | |
| 5191 CMSParRemarkTask::do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, | |
| 5192 int* seed) { | |
| 5193 OopTaskQueue* work_q = work_queue(i); | |
| 5194 NOT_PRODUCT(int num_steals = 0;) | |
| 5195 oop obj_to_scan; | |
| 5196 CMSBitMap* bm = &(_collector->_markBitMap); | |
| 5197 size_t num_from_overflow_list = | |
| 5198 MIN2((size_t)work_q->max_elems()/4, | |
| 5199 (size_t)ParGCDesiredObjsFromOverflowList); | |
| 5200 | |
| 5201 while (true) { | |
| 5202 // Completely finish any left over work from (an) earlier round(s) | |
| 5203 cl->trim_queue(0); | |
| 5204 // Now check if there's any work in the overflow list | |
| 5205 if (_collector->par_take_from_overflow_list(num_from_overflow_list, | |
| 5206 work_q)) { | |
| 5207 // found something in global overflow list; | |
| 5208 // not yet ready to go stealing work from others. | |
| 5209 // We'd like to assert(work_q->size() != 0, ...) | |
| 5210 // because we just took work from the overflow list, | |
| 5211 // but of course we can't since all of that could have | |
| 5212 // been already stolen from us. | |
| 5213 // "He giveth and He taketh away." | |
| 5214 continue; | |
| 5215 } | |
| 5216 // Verify that we have no work before we resort to stealing | |
| 5217 assert(work_q->size() == 0, "Have work, shouldn't steal"); | |
| 5218 // Try to steal from other queues that have work | |
| 5219 if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 5220 NOT_PRODUCT(num_steals++;) | |
| 5221 assert(obj_to_scan->is_oop(), "Oops, not an oop!"); | |
| 5222 assert(bm->isMarked((HeapWord*)obj_to_scan), "Stole an unmarked oop?"); | |
| 5223 // Do scanning work | |
| 5224 obj_to_scan->oop_iterate(cl); | |
| 5225 // Loop around, finish this work, and try to steal some more | |
| 5226 } else if (terminator()->offer_termination()) { | |
| 5227 break; // nirvana from the infinite cycle | |
| 5228 } | |
| 5229 } | |
| 5230 NOT_PRODUCT( | |
| 5231 if (PrintCMSStatistics != 0) { | |
| 5232 gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); | |
| 5233 } | |
| 5234 ) | |
| 5235 assert(work_q->size() == 0 && _collector->overflow_list_is_empty(), | |
| 5236 "Else our work is not yet done"); | |
| 5237 } | |
| 5238 | |
| 5239 // Return a thread-local PLAB recording array, as appropriate. | |
| 5240 void* CMSCollector::get_data_recorder(int thr_num) { | |
| 5241 if (_survivor_plab_array != NULL && | |
| 5242 (CMSPLABRecordAlways || | |
| 5243 (_collectorState > Marking && _collectorState < FinalMarking))) { | |
| 5244 assert(thr_num < (int)ParallelGCThreads, "thr_num is out of bounds"); | |
| 5245 ChunkArray* ca = &_survivor_plab_array[thr_num]; | |
| 5246 ca->reset(); // clear it so that fresh data is recorded | |
| 5247 return (void*) ca; | |
| 5248 } else { | |
| 5249 return NULL; | |
| 5250 } | |
| 5251 } | |
| 5252 | |
| 5253 // Reset all the thread-local PLAB recording arrays | |
| 5254 void CMSCollector::reset_survivor_plab_arrays() { | |
| 5255 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 5256 _survivor_plab_array[i].reset(); | |
| 5257 } | |
| 5258 } | |
| 5259 | |
| 5260 // Merge the per-thread plab arrays into the global survivor chunk | |
| 5261 // array which will provide the partitioning of the survivor space | |
| 5262 // for CMS rescan. | |
| 5263 void CMSCollector::merge_survivor_plab_arrays(ContiguousSpace* surv) { | |
| 5264 assert(_survivor_plab_array != NULL, "Error"); | |
| 5265 assert(_survivor_chunk_array != NULL, "Error"); | |
| 5266 assert(_collectorState == FinalMarking, "Error"); | |
| 5267 for (uint j = 0; j < ParallelGCThreads; j++) { | |
| 5268 _cursor[j] = 0; | |
| 5269 } | |
| 5270 HeapWord* top = surv->top(); | |
| 5271 size_t i; | |
| 5272 for (i = 0; i < _survivor_chunk_capacity; i++) { // all sca entries | |
| 5273 HeapWord* min_val = top; // Higher than any PLAB address | |
| 5274 uint min_tid = 0; // position of min_val this round | |
| 5275 for (uint j = 0; j < ParallelGCThreads; j++) { | |
| 5276 ChunkArray* cur_sca = &_survivor_plab_array[j]; | |
| 5277 if (_cursor[j] == cur_sca->end()) { | |
| 5278 continue; | |
| 5279 } | |
| 5280 assert(_cursor[j] < cur_sca->end(), "ctl pt invariant"); | |
| 5281 HeapWord* cur_val = cur_sca->nth(_cursor[j]); | |
| 5282 assert(surv->used_region().contains(cur_val), "Out of bounds value"); | |
| 5283 if (cur_val < min_val) { | |
| 5284 min_tid = j; | |
| 5285 min_val = cur_val; | |
| 5286 } else { | |
| 5287 assert(cur_val < top, "All recorded addresses should be less"); | |
| 5288 } | |
| 5289 } | |
| 5290 // At this point min_val and min_tid are respectively | |
| 5291 // the least address in _survivor_plab_array[j]->nth(_cursor[j]) | |
| 5292 // and the thread (j) that witnesses that address. | |
| 5293 // We record this address in the _survivor_chunk_array[i] | |
| 5294 // and increment _cursor[min_tid] prior to the next round i. | |
| 5295 if (min_val == top) { | |
| 5296 break; | |
| 5297 } | |
| 5298 _survivor_chunk_array[i] = min_val; | |
| 5299 _cursor[min_tid]++; | |
| 5300 } | |
| 5301 // We are all done; record the size of the _survivor_chunk_array | |
| 5302 _survivor_chunk_index = i; // exclusive: [0, i) | |
| 5303 if (PrintCMSStatistics > 0) { | |
| 5304 gclog_or_tty->print(" (Survivor:" SIZE_FORMAT "chunks) ", i); | |
| 5305 } | |
| 5306 // Verify that we used up all the recorded entries | |
| 5307 #ifdef ASSERT | |
| 5308 size_t total = 0; | |
| 5309 for (uint j = 0; j < ParallelGCThreads; j++) { | |
| 5310 assert(_cursor[j] == _survivor_plab_array[j].end(), "Ctl pt invariant"); | |
| 5311 total += _cursor[j]; | |
| 5312 } | |
| 5313 assert(total == _survivor_chunk_index, "Ctl Pt Invariant"); | |
| 5314 // Check that the merged array is in sorted order | |
| 5315 if (total > 0) { | |
| 5316 for (size_t i = 0; i < total - 1; i++) { | |
| 5317 if (PrintCMSStatistics > 0) { | |
| 5318 gclog_or_tty->print(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ", | |
| 5319 i, _survivor_chunk_array[i]); | |
| 5320 } | |
| 5321 assert(_survivor_chunk_array[i] < _survivor_chunk_array[i+1], | |
| 5322 "Not sorted"); | |
| 5323 } | |
| 5324 } | |
| 5325 #endif // ASSERT | |
| 5326 } | |
| 5327 | |
| 5328 // Set up the space's par_seq_tasks structure for work claiming | |
| 5329 // for parallel rescan of young gen. | |
| 5330 // See ParRescanTask where this is currently used. | |
| 5331 void | |
| 5332 CMSCollector:: | |
| 5333 initialize_sequential_subtasks_for_young_gen_rescan(int n_threads) { | |
| 5334 assert(n_threads > 0, "Unexpected n_threads argument"); | |
| 5335 DefNewGeneration* dng = (DefNewGeneration*)_young_gen; | |
| 5336 | |
| 5337 // Eden space | |
| 5338 { | |
| 5339 SequentialSubTasksDone* pst = dng->eden()->par_seq_tasks(); | |
| 5340 assert(!pst->valid(), "Clobbering existing data?"); | |
| 5341 // Each valid entry in [0, _eden_chunk_index) represents a task. | |
| 5342 size_t n_tasks = _eden_chunk_index + 1; | |
| 5343 assert(n_tasks == 1 || _eden_chunk_array != NULL, "Error"); | |
| 5344 pst->set_par_threads(n_threads); | |
| 5345 pst->set_n_tasks((int)n_tasks); | |
| 5346 } | |
| 5347 | |
| 5348 // Merge the survivor plab arrays into _survivor_chunk_array | |
| 5349 if (_survivor_plab_array != NULL) { | |
| 5350 merge_survivor_plab_arrays(dng->from()); | |
| 5351 } else { | |
| 5352 assert(_survivor_chunk_index == 0, "Error"); | |
| 5353 } | |
| 5354 | |
| 5355 // To space | |
| 5356 { | |
| 5357 SequentialSubTasksDone* pst = dng->to()->par_seq_tasks(); | |
| 5358 assert(!pst->valid(), "Clobbering existing data?"); | |
| 5359 pst->set_par_threads(n_threads); | |
| 5360 pst->set_n_tasks(1); | |
| 5361 assert(pst->valid(), "Error"); | |
| 5362 } | |
| 5363 | |
| 5364 // From space | |
| 5365 { | |
| 5366 SequentialSubTasksDone* pst = dng->from()->par_seq_tasks(); | |
| 5367 assert(!pst->valid(), "Clobbering existing data?"); | |
| 5368 size_t n_tasks = _survivor_chunk_index + 1; | |
| 5369 assert(n_tasks == 1 || _survivor_chunk_array != NULL, "Error"); | |
| 5370 pst->set_par_threads(n_threads); | |
| 5371 pst->set_n_tasks((int)n_tasks); | |
| 5372 assert(pst->valid(), "Error"); | |
| 5373 } | |
| 5374 } | |
| 5375 | |
| 5376 // Parallel version of remark | |
| 5377 void CMSCollector::do_remark_parallel() { | |
| 5378 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5379 WorkGang* workers = gch->workers(); | |
| 5380 assert(workers != NULL, "Need parallel worker threads."); | |
| 5381 int n_workers = workers->total_workers(); | |
| 5382 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); | |
| 5383 CompactibleFreeListSpace* perm_space = _permGen->cmsSpace(); | |
| 5384 | |
| 5385 CMSParRemarkTask tsk(this, | |
| 5386 cms_space, perm_space, | |
| 5387 n_workers, workers, task_queues()); | |
| 5388 | |
| 5389 // Set up for parallel process_strong_roots work. | |
| 5390 gch->set_par_threads(n_workers); | |
| 5391 gch->change_strong_roots_parity(); | |
| 5392 // We won't be iterating over the cards in the card table updating | |
| 5393 // the younger_gen cards, so we shouldn't call the following else | |
| 5394 // the verification code as well as subsequent younger_refs_iterate | |
| 5395 // code would get confused. XXX | |
| 5396 // gch->rem_set()->prepare_for_younger_refs_iterate(true); // parallel | |
| 5397 | |
| 5398 // The young gen rescan work will not be done as part of | |
| 5399 // process_strong_roots (which currently doesn't knw how to | |
| 5400 // parallelize such a scan), but rather will be broken up into | |
| 5401 // a set of parallel tasks (via the sampling that the [abortable] | |
| 5402 // preclean phase did of EdenSpace, plus the [two] tasks of | |
| 5403 // scanning the [two] survivor spaces. Further fine-grain | |
| 5404 // parallelization of the scanning of the survivor spaces | |
| 5405 // themselves, and of precleaning of the younger gen itself | |
| 5406 // is deferred to the future. | |
| 5407 initialize_sequential_subtasks_for_young_gen_rescan(n_workers); | |
| 5408 | |
| 5409 // The dirty card rescan work is broken up into a "sequence" | |
| 5410 // of parallel tasks (per constituent space) that are dynamically | |
| 5411 // claimed by the parallel threads. | |
| 5412 cms_space->initialize_sequential_subtasks_for_rescan(n_workers); | |
| 5413 perm_space->initialize_sequential_subtasks_for_rescan(n_workers); | |
| 5414 | |
| 5415 // It turns out that even when we're using 1 thread, doing the work in a | |
| 5416 // separate thread causes wide variance in run times. We can't help this | |
| 5417 // in the multi-threaded case, but we special-case n=1 here to get | |
| 5418 // repeatable measurements of the 1-thread overhead of the parallel code. | |
| 5419 if (n_workers > 1) { | |
| 5420 // Make refs discovery MT-safe | |
| 5421 ReferenceProcessorMTMutator mt(ref_processor(), true); | |
| 5422 workers->run_task(&tsk); | |
| 5423 } else { | |
| 5424 tsk.work(0); | |
| 5425 } | |
| 5426 gch->set_par_threads(0); // 0 ==> non-parallel. | |
| 5427 // restore, single-threaded for now, any preserved marks | |
| 5428 // as a result of work_q overflow | |
| 5429 restore_preserved_marks_if_any(); | |
| 5430 } | |
| 5431 | |
| 5432 // Non-parallel version of remark | |
| 5433 void CMSCollector::do_remark_non_parallel() { | |
| 5434 ResourceMark rm; | |
| 5435 HandleMark hm; | |
| 5436 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5437 MarkRefsIntoAndScanClosure | |
| 5438 mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable, | |
| 5439 &_markStack, &_revisitStack, this, | |
| 5440 false /* should_yield */, false /* not precleaning */); | |
| 5441 MarkFromDirtyCardsClosure | |
| 5442 markFromDirtyCardsClosure(this, _span, | |
| 5443 NULL, // space is set further below | |
| 5444 &_markBitMap, &_markStack, &_revisitStack, | |
| 5445 &mrias_cl); | |
| 5446 { | |
| 5447 TraceTime t("grey object rescan", PrintGCDetails, false, gclog_or_tty); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
5448 // Iterate over the dirty cards, setting the corresponding bits in the |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
5449 // mod union table. |
| 0 | 5450 { |
| 5451 ModUnionClosure modUnionClosure(&_modUnionTable); | |
| 5452 _ct->ct_bs()->dirty_card_iterate( | |
| 5453 _cmsGen->used_region(), | |
| 5454 &modUnionClosure); | |
| 5455 _ct->ct_bs()->dirty_card_iterate( | |
| 5456 _permGen->used_region(), | |
| 5457 &modUnionClosure); | |
| 5458 } | |
| 5459 // Having transferred these marks into the modUnionTable, we just need | |
| 5460 // to rescan the marked objects on the dirty cards in the modUnionTable. | |
| 5461 // The initial marking may have been done during an asynchronous | |
| 5462 // collection so there may be dirty bits in the mod-union table. | |
| 5463 const int alignment = | |
| 5464 CardTableModRefBS::card_size * BitsPerWord; | |
| 5465 { | |
| 5466 // ... First handle dirty cards in CMS gen | |
| 5467 markFromDirtyCardsClosure.set_space(_cmsGen->cmsSpace()); | |
| 5468 MemRegion ur = _cmsGen->used_region(); | |
| 5469 HeapWord* lb = ur.start(); | |
| 5470 HeapWord* ub = (HeapWord*)round_to((intptr_t)ur.end(), alignment); | |
| 5471 MemRegion cms_span(lb, ub); | |
| 5472 _modUnionTable.dirty_range_iterate_clear(cms_span, | |
| 5473 &markFromDirtyCardsClosure); | |
| 5474 verify_work_stacks_empty(); | |
| 5475 if (PrintCMSStatistics != 0) { | |
| 5476 gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in cms gen) ", | |
| 5477 markFromDirtyCardsClosure.num_dirty_cards()); | |
| 5478 } | |
| 5479 } | |
| 5480 { | |
| 5481 // .. and then repeat for dirty cards in perm gen | |
| 5482 markFromDirtyCardsClosure.set_space(_permGen->cmsSpace()); | |
| 5483 MemRegion ur = _permGen->used_region(); | |
| 5484 HeapWord* lb = ur.start(); | |
| 5485 HeapWord* ub = (HeapWord*)round_to((intptr_t)ur.end(), alignment); | |
| 5486 MemRegion perm_span(lb, ub); | |
| 5487 _modUnionTable.dirty_range_iterate_clear(perm_span, | |
| 5488 &markFromDirtyCardsClosure); | |
| 5489 verify_work_stacks_empty(); | |
| 5490 if (PrintCMSStatistics != 0) { | |
| 5491 gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in perm gen) ", | |
| 5492 markFromDirtyCardsClosure.num_dirty_cards()); | |
| 5493 } | |
| 5494 } | |
| 5495 } | |
| 5496 if (VerifyDuringGC && | |
| 5497 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 5498 HandleMark hm; // Discard invalid handles created during verification | |
| 5499 Universe::verify(true); | |
| 5500 } | |
| 5501 { | |
| 5502 TraceTime t("root rescan", PrintGCDetails, false, gclog_or_tty); | |
| 5503 | |
| 5504 verify_work_stacks_empty(); | |
| 5505 | |
| 5506 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
| 5507 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 5508 true, // younger gens as roots | |
| 5509 true, // collecting perm gen | |
| 5510 SharedHeap::ScanningOption(roots_scanning_options()), | |
| 5511 NULL, &mrias_cl); | |
| 5512 } | |
| 5513 verify_work_stacks_empty(); | |
| 5514 // Restore evacuated mark words, if any, used for overflow list links | |
| 5515 if (!CMSOverflowEarlyRestoration) { | |
| 5516 restore_preserved_marks_if_any(); | |
| 5517 } | |
| 5518 verify_overflow_empty(); | |
| 5519 } | |
| 5520 | |
| 5521 //////////////////////////////////////////////////////// | |
| 5522 // Parallel Reference Processing Task Proxy Class | |
| 5523 //////////////////////////////////////////////////////// | |
| 5524 class CMSRefProcTaskProxy: public AbstractGangTask { | |
| 5525 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; | |
| 5526 CMSCollector* _collector; | |
| 5527 CMSBitMap* _mark_bit_map; | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5528 const MemRegion _span; |
| 0 | 5529 OopTaskQueueSet* _task_queues; |
| 5530 ParallelTaskTerminator _term; | |
| 5531 ProcessTask& _task; | |
| 5532 | |
| 5533 public: | |
| 5534 CMSRefProcTaskProxy(ProcessTask& task, | |
| 5535 CMSCollector* collector, | |
| 5536 const MemRegion& span, | |
| 5537 CMSBitMap* mark_bit_map, | |
| 5538 int total_workers, | |
| 5539 OopTaskQueueSet* task_queues): | |
| 5540 AbstractGangTask("Process referents by policy in parallel"), | |
| 5541 _task(task), | |
| 5542 _collector(collector), _span(span), _mark_bit_map(mark_bit_map), | |
| 5543 _task_queues(task_queues), | |
| 5544 _term(total_workers, task_queues) | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5545 { |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5546 assert(_collector->_span.equals(_span) && !_span.is_empty(), |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5547 "Inconsistency in _span"); |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5548 } |
| 0 | 5549 |
| 5550 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 5551 | |
| 5552 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 5553 | |
| 5554 ParallelTaskTerminator* terminator() { return &_term; } | |
| 5555 | |
| 5556 void do_work_steal(int i, | |
| 5557 CMSParDrainMarkingStackClosure* drain, | |
| 5558 CMSParKeepAliveClosure* keep_alive, | |
| 5559 int* seed); | |
| 5560 | |
| 5561 virtual void work(int i); | |
| 5562 }; | |
| 5563 | |
| 5564 void CMSRefProcTaskProxy::work(int i) { | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5565 assert(_collector->_span.equals(_span), "Inconsistency in _span"); |
| 0 | 5566 CMSParKeepAliveClosure par_keep_alive(_collector, _span, |
| 5567 _mark_bit_map, work_queue(i)); | |
| 5568 CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span, | |
| 5569 _mark_bit_map, work_queue(i)); | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5570 CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map); |
| 0 | 5571 _task.work(i, is_alive_closure, par_keep_alive, par_drain_stack); |
| 5572 if (_task.marks_oops_alive()) { | |
| 5573 do_work_steal(i, &par_drain_stack, &par_keep_alive, | |
| 5574 _collector->hash_seed(i)); | |
| 5575 } | |
| 5576 assert(work_queue(i)->size() == 0, "work_queue should be empty"); | |
| 5577 assert(_collector->_overflow_list == NULL, "non-empty _overflow_list"); | |
| 5578 } | |
| 5579 | |
| 5580 class CMSRefEnqueueTaskProxy: public AbstractGangTask { | |
| 5581 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; | |
| 5582 EnqueueTask& _task; | |
| 5583 | |
| 5584 public: | |
| 5585 CMSRefEnqueueTaskProxy(EnqueueTask& task) | |
| 5586 : AbstractGangTask("Enqueue reference objects in parallel"), | |
| 5587 _task(task) | |
| 5588 { } | |
| 5589 | |
| 5590 virtual void work(int i) | |
| 5591 { | |
| 5592 _task.work(i); | |
| 5593 } | |
| 5594 }; | |
| 5595 | |
| 5596 CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector, | |
| 5597 MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue): | |
| 5598 _collector(collector), | |
| 5599 _span(span), | |
| 5600 _bit_map(bit_map), | |
| 5601 _work_queue(work_queue), | |
| 5602 _mark_and_push(collector, span, bit_map, work_queue), | |
| 5603 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4), | |
| 5604 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))) | |
| 5605 { } | |
| 5606 | |
| 5607 // . see if we can share work_queues with ParNew? XXX | |
| 5608 void CMSRefProcTaskProxy::do_work_steal(int i, | |
| 5609 CMSParDrainMarkingStackClosure* drain, | |
| 5610 CMSParKeepAliveClosure* keep_alive, | |
| 5611 int* seed) { | |
| 5612 OopTaskQueue* work_q = work_queue(i); | |
| 5613 NOT_PRODUCT(int num_steals = 0;) | |
| 5614 oop obj_to_scan; | |
| 5615 size_t num_from_overflow_list = | |
| 5616 MIN2((size_t)work_q->max_elems()/4, | |
| 5617 (size_t)ParGCDesiredObjsFromOverflowList); | |
| 5618 | |
| 5619 while (true) { | |
| 5620 // Completely finish any left over work from (an) earlier round(s) | |
| 5621 drain->trim_queue(0); | |
| 5622 // Now check if there's any work in the overflow list | |
| 5623 if (_collector->par_take_from_overflow_list(num_from_overflow_list, | |
| 5624 work_q)) { | |
| 5625 // Found something in global overflow list; | |
| 5626 // not yet ready to go stealing work from others. | |
| 5627 // We'd like to assert(work_q->size() != 0, ...) | |
| 5628 // because we just took work from the overflow list, | |
| 5629 // but of course we can't, since all of that might have | |
| 5630 // been already stolen from us. | |
| 5631 continue; | |
| 5632 } | |
| 5633 // Verify that we have no work before we resort to stealing | |
| 5634 assert(work_q->size() == 0, "Have work, shouldn't steal"); | |
| 5635 // Try to steal from other queues that have work | |
| 5636 if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 5637 NOT_PRODUCT(num_steals++;) | |
| 5638 assert(obj_to_scan->is_oop(), "Oops, not an oop!"); | |
| 5639 assert(_mark_bit_map->isMarked((HeapWord*)obj_to_scan), "Stole an unmarked oop?"); | |
| 5640 // Do scanning work | |
| 5641 obj_to_scan->oop_iterate(keep_alive); | |
| 5642 // Loop around, finish this work, and try to steal some more | |
| 5643 } else if (terminator()->offer_termination()) { | |
| 5644 break; // nirvana from the infinite cycle | |
| 5645 } | |
| 5646 } | |
| 5647 NOT_PRODUCT( | |
| 5648 if (PrintCMSStatistics != 0) { | |
| 5649 gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); | |
| 5650 } | |
| 5651 ) | |
| 5652 } | |
| 5653 | |
| 5654 void CMSRefProcTaskExecutor::execute(ProcessTask& task) | |
| 5655 { | |
| 5656 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5657 WorkGang* workers = gch->workers(); | |
| 5658 assert(workers != NULL, "Need parallel worker threads."); | |
| 5659 int n_workers = workers->total_workers(); | |
| 5660 CMSRefProcTaskProxy rp_task(task, &_collector, | |
| 5661 _collector.ref_processor()->span(), | |
| 5662 _collector.markBitMap(), | |
| 5663 n_workers, _collector.task_queues()); | |
| 5664 workers->run_task(&rp_task); | |
| 5665 } | |
| 5666 | |
| 5667 void CMSRefProcTaskExecutor::execute(EnqueueTask& task) | |
| 5668 { | |
| 5669 | |
| 5670 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5671 WorkGang* workers = gch->workers(); | |
| 5672 assert(workers != NULL, "Need parallel worker threads."); | |
| 5673 CMSRefEnqueueTaskProxy enq_task(task); | |
| 5674 workers->run_task(&enq_task); | |
| 5675 } | |
| 5676 | |
| 5677 void CMSCollector::refProcessingWork(bool asynch, bool clear_all_soft_refs) { | |
| 5678 | |
| 5679 ResourceMark rm; | |
| 5680 HandleMark hm; | |
| 5681 | |
| 5682 ReferenceProcessor* rp = ref_processor(); | |
| 5683 assert(rp->span().equals(_span), "Spans should be equal"); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5684 assert(!rp->enqueuing_is_done(), "Enqueuing should not be complete"); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5685 // Process weak references. |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5686 rp->snap_policy(clear_all_soft_refs); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5687 verify_work_stacks_empty(); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5688 |
| 0 | 5689 CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap, |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
5690 &_markStack, false /* !preclean */); |
| 0 | 5691 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this, |
| 5692 _span, &_markBitMap, &_markStack, | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
5693 &cmsKeepAliveClosure, false /* !preclean */); |
| 0 | 5694 { |
| 5695 TraceTime t("weak refs processing", PrintGCDetails, false, gclog_or_tty); | |
| 5696 if (rp->processing_is_mt()) { | |
| 5697 CMSRefProcTaskExecutor task_executor(*this); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5698 rp->process_discovered_references(&_is_alive_closure, |
| 0 | 5699 &cmsKeepAliveClosure, |
| 5700 &cmsDrainMarkingStackClosure, | |
| 5701 &task_executor); | |
| 5702 } else { | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5703 rp->process_discovered_references(&_is_alive_closure, |
| 0 | 5704 &cmsKeepAliveClosure, |
| 5705 &cmsDrainMarkingStackClosure, | |
| 5706 NULL); | |
| 5707 } | |
| 5708 verify_work_stacks_empty(); | |
| 5709 } | |
| 5710 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
5711 if (should_unload_classes()) { |
| 0 | 5712 { |
| 5713 TraceTime t("class unloading", PrintGCDetails, false, gclog_or_tty); | |
| 5714 | |
| 5715 // Follow SystemDictionary roots and unload classes | |
| 5716 bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure); | |
| 5717 | |
| 5718 // Follow CodeCache roots and unload any methods marked for unloading | |
| 5719 CodeCache::do_unloading(&_is_alive_closure, | |
| 5720 &cmsKeepAliveClosure, | |
| 5721 purged_class); | |
| 5722 | |
| 5723 cmsDrainMarkingStackClosure.do_void(); | |
| 5724 verify_work_stacks_empty(); | |
| 5725 | |
| 5726 // Update subklass/sibling/implementor links in KlassKlass descendants | |
| 5727 assert(!_revisitStack.isEmpty(), "revisit stack should not be empty"); | |
| 5728 oop k; | |
| 5729 while ((k = _revisitStack.pop()) != NULL) { | |
| 5730 ((Klass*)(oopDesc*)k)->follow_weak_klass_links( | |
| 5731 &_is_alive_closure, | |
| 5732 &cmsKeepAliveClosure); | |
| 5733 } | |
| 5734 assert(!ClassUnloading || | |
| 5735 (_markStack.isEmpty() && overflow_list_is_empty()), | |
| 5736 "Should not have found new reachable objects"); | |
| 5737 assert(_revisitStack.isEmpty(), "revisit stack should have been drained"); | |
| 5738 cmsDrainMarkingStackClosure.do_void(); | |
| 5739 verify_work_stacks_empty(); | |
| 5740 } | |
| 5741 | |
| 5742 { | |
| 5743 TraceTime t("scrub symbol & string tables", PrintGCDetails, false, gclog_or_tty); | |
| 5744 // Now clean up stale oops in SymbolTable and StringTable | |
| 5745 SymbolTable::unlink(&_is_alive_closure); | |
| 5746 StringTable::unlink(&_is_alive_closure); | |
| 5747 } | |
| 5748 } | |
| 5749 | |
| 5750 verify_work_stacks_empty(); | |
| 5751 // Restore any preserved marks as a result of mark stack or | |
| 5752 // work queue overflow | |
| 5753 restore_preserved_marks_if_any(); // done single-threaded for now | |
| 5754 | |
| 5755 rp->set_enqueuing_is_done(true); | |
| 5756 if (rp->processing_is_mt()) { | |
| 5757 CMSRefProcTaskExecutor task_executor(*this); | |
| 5758 rp->enqueue_discovered_references(&task_executor); | |
| 5759 } else { | |
| 5760 rp->enqueue_discovered_references(NULL); | |
| 5761 } | |
| 5762 rp->verify_no_references_recorded(); | |
| 5763 assert(!rp->discovery_enabled(), "should have been disabled"); | |
| 5764 | |
| 5765 // JVMTI object tagging is based on JNI weak refs. If any of these | |
| 5766 // refs were cleared then JVMTI needs to update its maps and | |
| 5767 // maybe post ObjectFrees to agents. | |
| 5768 JvmtiExport::cms_ref_processing_epilogue(); | |
| 5769 } | |
| 5770 | |
| 5771 #ifndef PRODUCT | |
| 5772 void CMSCollector::check_correct_thread_executing() { | |
| 5773 Thread* t = Thread::current(); | |
| 5774 // Only the VM thread or the CMS thread should be here. | |
| 5775 assert(t->is_ConcurrentGC_thread() || t->is_VM_thread(), | |
| 5776 "Unexpected thread type"); | |
| 5777 // If this is the vm thread, the foreground process | |
| 5778 // should not be waiting. Note that _foregroundGCIsActive is | |
| 5779 // true while the foreground collector is waiting. | |
| 5780 if (_foregroundGCShouldWait) { | |
| 5781 // We cannot be the VM thread | |
| 5782 assert(t->is_ConcurrentGC_thread(), | |
| 5783 "Should be CMS thread"); | |
| 5784 } else { | |
| 5785 // We can be the CMS thread only if we are in a stop-world | |
| 5786 // phase of CMS collection. | |
| 5787 if (t->is_ConcurrentGC_thread()) { | |
| 5788 assert(_collectorState == InitialMarking || | |
| 5789 _collectorState == FinalMarking, | |
| 5790 "Should be a stop-world phase"); | |
| 5791 // The CMS thread should be holding the CMS_token. | |
| 5792 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 5793 "Potential interference with concurrently " | |
| 5794 "executing VM thread"); | |
| 5795 } | |
| 5796 } | |
| 5797 } | |
| 5798 #endif | |
| 5799 | |
| 5800 void CMSCollector::sweep(bool asynch) { | |
| 5801 assert(_collectorState == Sweeping, "just checking"); | |
| 5802 check_correct_thread_executing(); | |
| 5803 verify_work_stacks_empty(); | |
| 5804 verify_overflow_empty(); | |
| 5805 incrementSweepCount(); | |
| 5806 _sweep_timer.stop(); | |
| 5807 _sweep_estimate.sample(_sweep_timer.seconds()); | |
| 5808 size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free()); | |
| 5809 | |
| 5810 // PermGen verification support: If perm gen sweeping is disabled in | |
| 5811 // this cycle, we preserve the perm gen object "deadness" information | |
| 5812 // in the perm_gen_verify_bit_map. In order to do that we traverse | |
| 5813 // all blocks in perm gen and mark all dead objects. | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
5814 if (verifying() && !should_unload_classes()) { |
| 0 | 5815 assert(perm_gen_verify_bit_map()->sizeInBits() != 0, |
| 5816 "Should have already been allocated"); | |
| 5817 MarkDeadObjectsClosure mdo(this, _permGen->cmsSpace(), | |
| 5818 markBitMap(), perm_gen_verify_bit_map()); | |
|
7
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5819 if (asynch) { |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5820 CMSTokenSyncWithLocks ts(true, _permGen->freelistLock(), |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5821 bitMapLock()); |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5822 _permGen->cmsSpace()->blk_iterate(&mdo); |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5823 } else { |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5824 // In the case of synchronous sweep, we already have |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5825 // the requisite locks/tokens. |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5826 _permGen->cmsSpace()->blk_iterate(&mdo); |
|
2faf283ce688
6621144: CMS: assertion failure "is_cms_thread == Thread::current()->is_ConcurrentGC_thread()"
ysr
parents:
0
diff
changeset
|
5827 } |
| 0 | 5828 } |
| 5829 | |
| 5830 if (asynch) { | |
| 5831 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 5832 CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails); | |
| 5833 // First sweep the old gen then the perm gen | |
| 5834 { | |
| 5835 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(), | |
| 5836 bitMapLock()); | |
| 5837 sweepWork(_cmsGen, asynch); | |
| 5838 } | |
| 5839 | |
| 5840 // Now repeat for perm gen | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
5841 if (should_unload_classes()) { |
| 0 | 5842 CMSTokenSyncWithLocks ts(true, _permGen->freelistLock(), |
| 5843 bitMapLock()); | |
| 5844 sweepWork(_permGen, asynch); | |
| 5845 } | |
| 5846 | |
| 5847 // Update Universe::_heap_*_at_gc figures. | |
| 5848 // We need all the free list locks to make the abstract state | |
| 5849 // transition from Sweeping to Resetting. See detailed note | |
| 5850 // further below. | |
| 5851 { | |
| 5852 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(), | |
| 5853 _permGen->freelistLock()); | |
| 5854 // Update heap occupancy information which is used as | |
| 5855 // input to soft ref clearing policy at the next gc. | |
| 5856 Universe::update_heap_info_at_gc(); | |
| 5857 _collectorState = Resizing; | |
| 5858 } | |
| 5859 } else { | |
| 5860 // already have needed locks | |
| 5861 sweepWork(_cmsGen, asynch); | |
| 5862 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
5863 if (should_unload_classes()) { |
| 0 | 5864 sweepWork(_permGen, asynch); |
| 5865 } | |
| 5866 // Update heap occupancy information which is used as | |
| 5867 // input to soft ref clearing policy at the next gc. | |
| 5868 Universe::update_heap_info_at_gc(); | |
| 5869 _collectorState = Resizing; | |
| 5870 } | |
| 5871 verify_work_stacks_empty(); | |
| 5872 verify_overflow_empty(); | |
| 5873 | |
| 5874 _sweep_timer.reset(); | |
| 5875 _sweep_timer.start(); | |
| 5876 | |
| 5877 update_time_of_last_gc(os::javaTimeMillis()); | |
| 5878 | |
| 5879 // NOTE on abstract state transitions: | |
| 5880 // Mutators allocate-live and/or mark the mod-union table dirty | |
| 5881 // based on the state of the collection. The former is done in | |
| 5882 // the interval [Marking, Sweeping] and the latter in the interval | |
| 5883 // [Marking, Sweeping). Thus the transitions into the Marking state | |
| 5884 // and out of the Sweeping state must be synchronously visible | |
| 5885 // globally to the mutators. | |
| 5886 // The transition into the Marking state happens with the world | |
| 5887 // stopped so the mutators will globally see it. Sweeping is | |
| 5888 // done asynchronously by the background collector so the transition | |
| 5889 // from the Sweeping state to the Resizing state must be done | |
| 5890 // under the freelistLock (as is the check for whether to | |
| 5891 // allocate-live and whether to dirty the mod-union table). | |
| 5892 assert(_collectorState == Resizing, "Change of collector state to" | |
| 5893 " Resizing must be done under the freelistLocks (plural)"); | |
| 5894 | |
| 5895 // Now that sweeping has been completed, if the GCH's | |
| 5896 // incremental_collection_will_fail flag is set, clear it, | |
| 5897 // thus inviting a younger gen collection to promote into | |
| 5898 // this generation. If such a promotion may still fail, | |
| 5899 // the flag will be set again when a young collection is | |
| 5900 // attempted. | |
| 5901 // I think the incremental_collection_will_fail flag's use | |
| 5902 // is specific to a 2 generation collection policy, so i'll | |
| 5903 // assert that that's the configuration we are operating within. | |
| 5904 // The use of the flag can and should be generalized appropriately | |
| 5905 // in the future to deal with a general n-generation system. | |
| 5906 | |
| 5907 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5908 assert(gch->collector_policy()->is_two_generation_policy(), | |
| 5909 "Resetting of incremental_collection_will_fail flag" | |
| 5910 " may be incorrect otherwise"); | |
| 5911 gch->clear_incremental_collection_will_fail(); | |
| 5912 gch->update_full_collections_completed(_collection_count_start); | |
| 5913 } | |
| 5914 | |
| 5915 // FIX ME!!! Looks like this belongs in CFLSpace, with | |
| 5916 // CMSGen merely delegating to it. | |
| 5917 void ConcurrentMarkSweepGeneration::setNearLargestChunk() { | |
| 5918 double nearLargestPercent = 0.999; | |
| 5919 HeapWord* minAddr = _cmsSpace->bottom(); | |
| 5920 HeapWord* largestAddr = | |
| 5921 (HeapWord*) _cmsSpace->dictionary()->findLargestDict(); | |
| 5922 if (largestAddr == 0) { | |
| 5923 // The dictionary appears to be empty. In this case | |
| 5924 // try to coalesce at the end of the heap. | |
| 5925 largestAddr = _cmsSpace->end(); | |
| 5926 } | |
| 5927 size_t largestOffset = pointer_delta(largestAddr, minAddr); | |
| 5928 size_t nearLargestOffset = | |
| 5929 (size_t)((double)largestOffset * nearLargestPercent) - MinChunkSize; | |
| 5930 _cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset); | |
| 5931 } | |
| 5932 | |
| 5933 bool ConcurrentMarkSweepGeneration::isNearLargestChunk(HeapWord* addr) { | |
| 5934 return addr >= _cmsSpace->nearLargestChunk(); | |
| 5935 } | |
| 5936 | |
| 5937 FreeChunk* ConcurrentMarkSweepGeneration::find_chunk_at_end() { | |
| 5938 return _cmsSpace->find_chunk_at_end(); | |
| 5939 } | |
| 5940 | |
| 5941 void ConcurrentMarkSweepGeneration::update_gc_stats(int current_level, | |
| 5942 bool full) { | |
| 5943 // The next lower level has been collected. Gather any statistics | |
| 5944 // that are of interest at this point. | |
| 5945 if (!full && (current_level + 1) == level()) { | |
| 5946 // Gather statistics on the young generation collection. | |
| 5947 collector()->stats().record_gc0_end(used()); | |
| 5948 } | |
| 5949 } | |
| 5950 | |
| 5951 CMSAdaptiveSizePolicy* ConcurrentMarkSweepGeneration::size_policy() { | |
| 5952 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5953 assert(gch->kind() == CollectedHeap::GenCollectedHeap, | |
| 5954 "Wrong type of heap"); | |
| 5955 CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*) | |
| 5956 gch->gen_policy()->size_policy(); | |
| 5957 assert(sp->is_gc_cms_adaptive_size_policy(), | |
| 5958 "Wrong type of size policy"); | |
| 5959 return sp; | |
| 5960 } | |
| 5961 | |
| 5962 void ConcurrentMarkSweepGeneration::rotate_debug_collection_type() { | |
| 5963 if (PrintGCDetails && Verbose) { | |
| 5964 gclog_or_tty->print("Rotate from %d ", _debug_collection_type); | |
| 5965 } | |
| 5966 _debug_collection_type = (CollectionTypes) (_debug_collection_type + 1); | |
| 5967 _debug_collection_type = | |
| 5968 (CollectionTypes) (_debug_collection_type % Unknown_collection_type); | |
| 5969 if (PrintGCDetails && Verbose) { | |
| 5970 gclog_or_tty->print_cr("to %d ", _debug_collection_type); | |
| 5971 } | |
| 5972 } | |
| 5973 | |
| 5974 void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* gen, | |
| 5975 bool asynch) { | |
| 5976 // We iterate over the space(s) underlying this generation, | |
| 5977 // checking the mark bit map to see if the bits corresponding | |
| 5978 // to specific blocks are marked or not. Blocks that are | |
| 5979 // marked are live and are not swept up. All remaining blocks | |
| 5980 // are swept up, with coalescing on-the-fly as we sweep up | |
| 5981 // contiguous free and/or garbage blocks: | |
| 5982 // We need to ensure that the sweeper synchronizes with allocators | |
| 5983 // and stop-the-world collectors. In particular, the following | |
| 5984 // locks are used: | |
| 5985 // . CMS token: if this is held, a stop the world collection cannot occur | |
| 5986 // . freelistLock: if this is held no allocation can occur from this | |
| 5987 // generation by another thread | |
| 5988 // . bitMapLock: if this is held, no other thread can access or update | |
| 5989 // | |
| 5990 | |
| 5991 // Note that we need to hold the freelistLock if we use | |
| 5992 // block iterate below; else the iterator might go awry if | |
| 5993 // a mutator (or promotion) causes block contents to change | |
| 5994 // (for instance if the allocator divvies up a block). | |
| 5995 // If we hold the free list lock, for all practical purposes | |
| 5996 // young generation GC's can't occur (they'll usually need to | |
| 5997 // promote), so we might as well prevent all young generation | |
| 5998 // GC's while we do a sweeping step. For the same reason, we might | |
| 5999 // as well take the bit map lock for the entire duration | |
| 6000 | |
| 6001 // check that we hold the requisite locks | |
| 6002 assert(have_cms_token(), "Should hold cms token"); | |
| 6003 assert( (asynch && ConcurrentMarkSweepThread::cms_thread_has_cms_token()) | |
| 6004 || (!asynch && ConcurrentMarkSweepThread::vm_thread_has_cms_token()), | |
| 6005 "Should possess CMS token to sweep"); | |
| 6006 assert_lock_strong(gen->freelistLock()); | |
| 6007 assert_lock_strong(bitMapLock()); | |
| 6008 | |
| 6009 assert(!_sweep_timer.is_active(), "Was switched off in an outer context"); | |
| 6010 gen->cmsSpace()->beginSweepFLCensus((float)(_sweep_timer.seconds()), | |
| 6011 _sweep_estimate.padded_average()); | |
| 6012 gen->setNearLargestChunk(); | |
| 6013 | |
| 6014 { | |
| 6015 SweepClosure sweepClosure(this, gen, &_markBitMap, | |
| 6016 CMSYield && asynch); | |
| 6017 gen->cmsSpace()->blk_iterate_careful(&sweepClosure); | |
| 6018 // We need to free-up/coalesce garbage/blocks from a | |
| 6019 // co-terminal free run. This is done in the SweepClosure | |
| 6020 // destructor; so, do not remove this scope, else the | |
| 6021 // end-of-sweep-census below will be off by a little bit. | |
| 6022 } | |
| 6023 gen->cmsSpace()->sweep_completed(); | |
| 6024 gen->cmsSpace()->endSweepFLCensus(sweepCount()); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6025 if (should_unload_classes()) { // unloaded classes this cycle, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6026 _concurrent_cycles_since_last_unload = 0; // ... reset count |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6027 } else { // did not unload classes, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6028 _concurrent_cycles_since_last_unload++; // ... increment count |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6029 } |
| 0 | 6030 } |
| 6031 | |
| 6032 // Reset CMS data structures (for now just the marking bit map) | |
| 6033 // preparatory for the next cycle. | |
| 6034 void CMSCollector::reset(bool asynch) { | |
| 6035 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 6036 CMSAdaptiveSizePolicy* sp = size_policy(); | |
| 6037 AdaptiveSizePolicyOutput(sp, gch->total_collections()); | |
| 6038 if (asynch) { | |
| 6039 CMSTokenSyncWithLocks ts(true, bitMapLock()); | |
| 6040 | |
| 6041 // If the state is not "Resetting", the foreground thread | |
| 6042 // has done a collection and the resetting. | |
| 6043 if (_collectorState != Resetting) { | |
| 6044 assert(_collectorState == Idling, "The state should only change" | |
| 6045 " because the foreground collector has finished the collection"); | |
| 6046 return; | |
| 6047 } | |
| 6048 | |
| 6049 // Clear the mark bitmap (no grey objects to start with) | |
| 6050 // for the next cycle. | |
| 6051 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 6052 CMSPhaseAccounting cmspa(this, "reset", !PrintGCDetails); | |
| 6053 | |
| 6054 HeapWord* curAddr = _markBitMap.startWord(); | |
| 6055 while (curAddr < _markBitMap.endWord()) { | |
| 6056 size_t remaining = pointer_delta(_markBitMap.endWord(), curAddr); | |
| 6057 MemRegion chunk(curAddr, MIN2(CMSBitMapYieldQuantum, remaining)); | |
| 6058 _markBitMap.clear_large_range(chunk); | |
| 6059 if (ConcurrentMarkSweepThread::should_yield() && | |
| 6060 !foregroundGCIsActive() && | |
| 6061 CMSYield) { | |
| 6062 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6063 "CMS thread should hold CMS token"); | |
| 6064 assert_lock_strong(bitMapLock()); | |
| 6065 bitMapLock()->unlock(); | |
| 6066 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6067 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6068 stopTimer(); | |
| 6069 if (PrintCMSStatistics != 0) { | |
| 6070 incrementYields(); | |
| 6071 } | |
| 6072 icms_wait(); | |
| 6073 | |
| 6074 // See the comment in coordinator_yield() | |
| 6075 for (unsigned i = 0; i < CMSYieldSleepCount && | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6076 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6077 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 6078 os::sleep(Thread::current(), 1, false); |
| 6079 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6080 } | |
| 6081 | |
| 6082 ConcurrentMarkSweepThread::synchronize(true); | |
| 6083 bitMapLock()->lock_without_safepoint_check(); | |
| 6084 startTimer(); | |
| 6085 } | |
| 6086 curAddr = chunk.end(); | |
| 6087 } | |
| 6088 _collectorState = Idling; | |
| 6089 } else { | |
| 6090 // already have the lock | |
| 6091 assert(_collectorState == Resetting, "just checking"); | |
| 6092 assert_lock_strong(bitMapLock()); | |
| 6093 _markBitMap.clear_all(); | |
| 6094 _collectorState = Idling; | |
| 6095 } | |
| 6096 | |
| 6097 // Stop incremental mode after a cycle completes, so that any future cycles | |
| 6098 // are triggered by allocation. | |
| 6099 stop_icms(); | |
| 6100 | |
| 6101 NOT_PRODUCT( | |
| 6102 if (RotateCMSCollectionTypes) { | |
| 6103 _cmsGen->rotate_debug_collection_type(); | |
| 6104 } | |
| 6105 ) | |
| 6106 } | |
| 6107 | |
| 6108 void CMSCollector::do_CMS_operation(CMS_op_type op) { | |
| 6109 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); | |
| 6110 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 6111 TraceTime t("GC", PrintGC, !PrintGCDetails, gclog_or_tty); | |
| 6112 TraceCollectorStats tcs(counters()); | |
| 6113 | |
| 6114 switch (op) { | |
| 6115 case CMS_op_checkpointRootsInitial: { | |
| 6116 checkpointRootsInitial(true); // asynch | |
| 6117 if (PrintGC) { | |
| 6118 _cmsGen->printOccupancy("initial-mark"); | |
| 6119 } | |
| 6120 break; | |
| 6121 } | |
| 6122 case CMS_op_checkpointRootsFinal: { | |
| 6123 checkpointRootsFinal(true, // asynch | |
| 6124 false, // !clear_all_soft_refs | |
| 6125 false); // !init_mark_was_synchronous | |
| 6126 if (PrintGC) { | |
| 6127 _cmsGen->printOccupancy("remark"); | |
| 6128 } | |
| 6129 break; | |
| 6130 } | |
| 6131 default: | |
| 6132 fatal("No such CMS_op"); | |
| 6133 } | |
| 6134 } | |
| 6135 | |
| 6136 #ifndef PRODUCT | |
| 6137 size_t const CMSCollector::skip_header_HeapWords() { | |
| 6138 return FreeChunk::header_size(); | |
| 6139 } | |
| 6140 | |
| 6141 // Try and collect here conditions that should hold when | |
| 6142 // CMS thread is exiting. The idea is that the foreground GC | |
| 6143 // thread should not be blocked if it wants to terminate | |
| 6144 // the CMS thread and yet continue to run the VM for a while | |
| 6145 // after that. | |
| 6146 void CMSCollector::verify_ok_to_terminate() const { | |
| 6147 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 6148 "should be called by CMS thread"); | |
| 6149 assert(!_foregroundGCShouldWait, "should be false"); | |
| 6150 // We could check here that all the various low-level locks | |
| 6151 // are not held by the CMS thread, but that is overkill; see | |
| 6152 // also CMSThread::verify_ok_to_terminate() where the CGC_lock | |
| 6153 // is checked. | |
| 6154 } | |
| 6155 #endif | |
| 6156 | |
| 6157 size_t CMSCollector::block_size_using_printezis_bits(HeapWord* addr) const { | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
6158 assert(_markBitMap.isMarked(addr) && _markBitMap.isMarked(addr + 1), |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
6159 "missing Printezis mark?"); |
| 0 | 6160 HeapWord* nextOneAddr = _markBitMap.getNextMarkedWordAddress(addr + 2); |
| 6161 size_t size = pointer_delta(nextOneAddr + 1, addr); | |
| 6162 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6163 "alignment problem"); | |
| 6164 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6165 return size; | |
| 6166 } | |
| 6167 | |
| 6168 // A variant of the above (block_size_using_printezis_bits()) except | |
| 6169 // that we return 0 if the P-bits are not yet set. | |
| 6170 size_t CMSCollector::block_size_if_printezis_bits(HeapWord* addr) const { | |
| 6171 if (_markBitMap.isMarked(addr)) { | |
| 6172 assert(_markBitMap.isMarked(addr + 1), "Missing Printezis bit?"); | |
| 6173 HeapWord* nextOneAddr = _markBitMap.getNextMarkedWordAddress(addr + 2); | |
| 6174 size_t size = pointer_delta(nextOneAddr + 1, addr); | |
| 6175 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6176 "alignment problem"); | |
| 6177 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6178 return size; | |
| 6179 } else { | |
| 6180 assert(!_markBitMap.isMarked(addr + 1), "Bit map inconsistency?"); | |
| 6181 return 0; | |
| 6182 } | |
| 6183 } | |
| 6184 | |
| 6185 HeapWord* CMSCollector::next_card_start_after_block(HeapWord* addr) const { | |
| 6186 size_t sz = 0; | |
| 6187 oop p = (oop)addr; | |
| 187 | 6188 if (p->klass_or_null() != NULL && p->is_parsable()) { |
| 0 | 6189 sz = CompactibleFreeListSpace::adjustObjectSize(p->size()); |
| 6190 } else { | |
| 6191 sz = block_size_using_printezis_bits(addr); | |
| 6192 } | |
| 6193 assert(sz > 0, "size must be nonzero"); | |
| 6194 HeapWord* next_block = addr + sz; | |
| 6195 HeapWord* next_card = (HeapWord*)round_to((uintptr_t)next_block, | |
| 6196 CardTableModRefBS::card_size); | |
| 6197 assert(round_down((uintptr_t)addr, CardTableModRefBS::card_size) < | |
| 6198 round_down((uintptr_t)next_card, CardTableModRefBS::card_size), | |
| 6199 "must be different cards"); | |
| 6200 return next_card; | |
| 6201 } | |
| 6202 | |
| 6203 | |
| 6204 // CMS Bit Map Wrapper ///////////////////////////////////////// | |
| 6205 | |
| 6206 // Construct a CMS bit map infrastructure, but don't create the | |
| 6207 // bit vector itself. That is done by a separate call CMSBitMap::allocate() | |
| 6208 // further below. | |
| 6209 CMSBitMap::CMSBitMap(int shifter, int mutex_rank, const char* mutex_name): | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6210 _bm(), |
| 0 | 6211 _shifter(shifter), |
| 6212 _lock(mutex_rank >= 0 ? new Mutex(mutex_rank, mutex_name, true) : NULL) | |
| 6213 { | |
| 6214 _bmStartWord = 0; | |
| 6215 _bmWordSize = 0; | |
| 6216 } | |
| 6217 | |
| 6218 bool CMSBitMap::allocate(MemRegion mr) { | |
| 6219 _bmStartWord = mr.start(); | |
| 6220 _bmWordSize = mr.word_size(); | |
| 6221 ReservedSpace brs(ReservedSpace::allocation_align_size_up( | |
| 6222 (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1)); | |
| 6223 if (!brs.is_reserved()) { | |
| 6224 warning("CMS bit map allocation failure"); | |
| 6225 return false; | |
| 6226 } | |
| 6227 // For now we'll just commit all of the bit map up fromt. | |
| 6228 // Later on we'll try to be more parsimonious with swap. | |
| 6229 if (!_virtual_space.initialize(brs, brs.size())) { | |
| 6230 warning("CMS bit map backing store failure"); | |
| 6231 return false; | |
| 6232 } | |
| 6233 assert(_virtual_space.committed_size() == brs.size(), | |
| 6234 "didn't reserve backing store for all of CMS bit map?"); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6235 _bm.set_map((BitMap::bm_word_t*)_virtual_space.low()); |
| 0 | 6236 assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >= |
| 6237 _bmWordSize, "inconsistency in bit map sizing"); | |
| 6238 _bm.set_size(_bmWordSize >> _shifter); | |
| 6239 | |
| 6240 // bm.clear(); // can we rely on getting zero'd memory? verify below | |
| 6241 assert(isAllClear(), | |
| 6242 "Expected zero'd memory from ReservedSpace constructor"); | |
| 6243 assert(_bm.size() == heapWordDiffToOffsetDiff(sizeInWords()), | |
| 6244 "consistency check"); | |
| 6245 return true; | |
| 6246 } | |
| 6247 | |
| 6248 void CMSBitMap::dirty_range_iterate_clear(MemRegion mr, MemRegionClosure* cl) { | |
| 6249 HeapWord *next_addr, *end_addr, *last_addr; | |
| 6250 assert_locked(); | |
| 6251 assert(covers(mr), "out-of-range error"); | |
| 6252 // XXX assert that start and end are appropriately aligned | |
| 6253 for (next_addr = mr.start(), end_addr = mr.end(); | |
| 6254 next_addr < end_addr; next_addr = last_addr) { | |
| 6255 MemRegion dirty_region = getAndClearMarkedRegion(next_addr, end_addr); | |
| 6256 last_addr = dirty_region.end(); | |
| 6257 if (!dirty_region.is_empty()) { | |
| 6258 cl->do_MemRegion(dirty_region); | |
| 6259 } else { | |
| 6260 assert(last_addr == end_addr, "program logic"); | |
| 6261 return; | |
| 6262 } | |
| 6263 } | |
| 6264 } | |
| 6265 | |
| 6266 #ifndef PRODUCT | |
| 6267 void CMSBitMap::assert_locked() const { | |
| 6268 CMSLockVerifier::assert_locked(lock()); | |
| 6269 } | |
| 6270 | |
| 6271 bool CMSBitMap::covers(MemRegion mr) const { | |
| 6272 // assert(_bm.map() == _virtual_space.low(), "map inconsistency"); | |
| 6273 assert((size_t)_bm.size() == (_bmWordSize >> _shifter), | |
| 6274 "size inconsistency"); | |
| 6275 return (mr.start() >= _bmStartWord) && | |
| 6276 (mr.end() <= endWord()); | |
| 6277 } | |
| 6278 | |
| 6279 bool CMSBitMap::covers(HeapWord* start, size_t size) const { | |
| 6280 return (start >= _bmStartWord && (start + size) <= endWord()); | |
| 6281 } | |
| 6282 | |
| 6283 void CMSBitMap::verifyNoOneBitsInRange(HeapWord* left, HeapWord* right) { | |
| 6284 // verify that there are no 1 bits in the interval [left, right) | |
| 6285 FalseBitMapClosure falseBitMapClosure; | |
| 6286 iterate(&falseBitMapClosure, left, right); | |
| 6287 } | |
| 6288 | |
| 6289 void CMSBitMap::region_invariant(MemRegion mr) | |
| 6290 { | |
| 6291 assert_locked(); | |
| 6292 // mr = mr.intersection(MemRegion(_bmStartWord, _bmWordSize)); | |
| 6293 assert(!mr.is_empty(), "unexpected empty region"); | |
| 6294 assert(covers(mr), "mr should be covered by bit map"); | |
| 6295 // convert address range into offset range | |
| 6296 size_t start_ofs = heapWordToOffset(mr.start()); | |
| 6297 // Make sure that end() is appropriately aligned | |
| 6298 assert(mr.end() == (HeapWord*)round_to((intptr_t)mr.end(), | |
| 6299 (1 << (_shifter+LogHeapWordSize))), | |
| 6300 "Misaligned mr.end()"); | |
| 6301 size_t end_ofs = heapWordToOffset(mr.end()); | |
| 6302 assert(end_ofs > start_ofs, "Should mark at least one bit"); | |
| 6303 } | |
| 6304 | |
| 6305 #endif | |
| 6306 | |
| 6307 bool CMSMarkStack::allocate(size_t size) { | |
| 6308 // allocate a stack of the requisite depth | |
| 6309 ReservedSpace rs(ReservedSpace::allocation_align_size_up( | |
| 6310 size * sizeof(oop))); | |
| 6311 if (!rs.is_reserved()) { | |
| 6312 warning("CMSMarkStack allocation failure"); | |
| 6313 return false; | |
| 6314 } | |
| 6315 if (!_virtual_space.initialize(rs, rs.size())) { | |
| 6316 warning("CMSMarkStack backing store failure"); | |
| 6317 return false; | |
| 6318 } | |
| 6319 assert(_virtual_space.committed_size() == rs.size(), | |
| 6320 "didn't reserve backing store for all of CMS stack?"); | |
| 6321 _base = (oop*)(_virtual_space.low()); | |
| 6322 _index = 0; | |
| 6323 _capacity = size; | |
| 6324 NOT_PRODUCT(_max_depth = 0); | |
| 6325 return true; | |
| 6326 } | |
| 6327 | |
| 6328 // XXX FIX ME !!! In the MT case we come in here holding a | |
| 6329 // leaf lock. For printing we need to take a further lock | |
| 6330 // which has lower rank. We need to recallibrate the two | |
| 6331 // lock-ranks involved in order to be able to rpint the | |
| 6332 // messages below. (Or defer the printing to the caller. | |
| 6333 // For now we take the expedient path of just disabling the | |
| 6334 // messages for the problematic case.) | |
| 6335 void CMSMarkStack::expand() { | |
| 6336 assert(_capacity <= CMSMarkStackSizeMax, "stack bigger than permitted"); | |
| 6337 if (_capacity == CMSMarkStackSizeMax) { | |
| 6338 if (_hit_limit++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { | |
| 6339 // We print a warning message only once per CMS cycle. | |
| 6340 gclog_or_tty->print_cr(" (benign) Hit CMSMarkStack max size limit"); | |
| 6341 } | |
| 6342 return; | |
| 6343 } | |
| 6344 // Double capacity if possible | |
| 6345 size_t new_capacity = MIN2(_capacity*2, CMSMarkStackSizeMax); | |
| 6346 // Do not give up existing stack until we have managed to | |
| 6347 // get the double capacity that we desired. | |
| 6348 ReservedSpace rs(ReservedSpace::allocation_align_size_up( | |
| 6349 new_capacity * sizeof(oop))); | |
| 6350 if (rs.is_reserved()) { | |
| 6351 // Release the backing store associated with old stack | |
| 6352 _virtual_space.release(); | |
| 6353 // Reinitialize virtual space for new stack | |
| 6354 if (!_virtual_space.initialize(rs, rs.size())) { | |
| 6355 fatal("Not enough swap for expanded marking stack"); | |
| 6356 } | |
| 6357 _base = (oop*)(_virtual_space.low()); | |
| 6358 _index = 0; | |
| 6359 _capacity = new_capacity; | |
| 6360 } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { | |
| 6361 // Failed to double capacity, continue; | |
| 6362 // we print a detail message only once per CMS cycle. | |
| 6363 gclog_or_tty->print(" (benign) Failed to expand marking stack from "SIZE_FORMAT"K to " | |
| 6364 SIZE_FORMAT"K", | |
| 6365 _capacity / K, new_capacity / K); | |
| 6366 } | |
| 6367 } | |
| 6368 | |
| 6369 | |
| 6370 // Closures | |
| 6371 // XXX: there seems to be a lot of code duplication here; | |
| 6372 // should refactor and consolidate common code. | |
| 6373 | |
| 6374 // This closure is used to mark refs into the CMS generation in | |
| 6375 // the CMS bit map. Called at the first checkpoint. This closure | |
| 6376 // assumes that we do not need to re-mark dirty cards; if the CMS | |
| 6377 // generation on which this is used is not an oldest (modulo perm gen) | |
| 6378 // generation then this will lose younger_gen cards! | |
| 6379 | |
| 6380 MarkRefsIntoClosure::MarkRefsIntoClosure( | |
| 6381 MemRegion span, CMSBitMap* bitMap, bool should_do_nmethods): | |
| 6382 _span(span), | |
| 6383 _bitMap(bitMap), | |
| 6384 _should_do_nmethods(should_do_nmethods) | |
| 6385 { | |
| 6386 assert(_ref_processor == NULL, "deliberately left NULL"); | |
| 6387 assert(_bitMap->covers(_span), "_bitMap/_span mismatch"); | |
| 6388 } | |
| 6389 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6390 void MarkRefsIntoClosure::do_oop(oop obj) { |
| 0 | 6391 // if p points into _span, then mark corresponding bit in _markBitMap |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6392 assert(obj->is_oop(), "expected an oop"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6393 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6394 if (_span.contains(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6395 // this should be made more efficient |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6396 _bitMap->mark(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6397 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6398 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6399 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6400 void MarkRefsIntoClosure::do_oop(oop* p) { MarkRefsIntoClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6401 void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); } |
| 0 | 6402 |
| 6403 // A variant of the above, used for CMS marking verification. | |
| 6404 MarkRefsIntoVerifyClosure::MarkRefsIntoVerifyClosure( | |
| 6405 MemRegion span, CMSBitMap* verification_bm, CMSBitMap* cms_bm, | |
| 6406 bool should_do_nmethods): | |
| 6407 _span(span), | |
| 6408 _verification_bm(verification_bm), | |
| 6409 _cms_bm(cms_bm), | |
| 6410 _should_do_nmethods(should_do_nmethods) { | |
| 6411 assert(_ref_processor == NULL, "deliberately left NULL"); | |
| 6412 assert(_verification_bm->covers(_span), "_verification_bm/_span mismatch"); | |
| 6413 } | |
| 6414 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6415 void MarkRefsIntoVerifyClosure::do_oop(oop obj) { |
| 0 | 6416 // if p points into _span, then mark corresponding bit in _markBitMap |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6417 assert(obj->is_oop(), "expected an oop"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6418 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6419 if (_span.contains(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6420 _verification_bm->mark(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6421 if (!_cms_bm->isMarked(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6422 oop(addr)->print(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6423 gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6424 fatal("... aborting"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6425 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6426 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6427 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6428 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6429 void MarkRefsIntoVerifyClosure::do_oop(oop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6430 void MarkRefsIntoVerifyClosure::do_oop(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); } |
| 0 | 6431 |
| 6432 ////////////////////////////////////////////////// | |
| 6433 // MarkRefsIntoAndScanClosure | |
| 6434 ////////////////////////////////////////////////// | |
| 6435 | |
| 6436 MarkRefsIntoAndScanClosure::MarkRefsIntoAndScanClosure(MemRegion span, | |
| 6437 ReferenceProcessor* rp, | |
| 6438 CMSBitMap* bit_map, | |
| 6439 CMSBitMap* mod_union_table, | |
| 6440 CMSMarkStack* mark_stack, | |
| 6441 CMSMarkStack* revisit_stack, | |
| 6442 CMSCollector* collector, | |
| 6443 bool should_yield, | |
| 6444 bool concurrent_precleaning): | |
| 6445 _collector(collector), | |
| 6446 _span(span), | |
| 6447 _bit_map(bit_map), | |
| 6448 _mark_stack(mark_stack), | |
| 6449 _pushAndMarkClosure(collector, span, rp, bit_map, mod_union_table, | |
| 6450 mark_stack, revisit_stack, concurrent_precleaning), | |
| 6451 _yield(should_yield), | |
| 6452 _concurrent_precleaning(concurrent_precleaning), | |
| 6453 _freelistLock(NULL) | |
| 6454 { | |
| 6455 _ref_processor = rp; | |
| 6456 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 6457 } | |
| 6458 | |
| 6459 // This closure is used to mark refs into the CMS generation at the | |
| 6460 // second (final) checkpoint, and to scan and transitively follow | |
| 6461 // the unmarked oops. It is also used during the concurrent precleaning | |
| 6462 // phase while scanning objects on dirty cards in the CMS generation. | |
| 6463 // The marks are made in the marking bit map and the marking stack is | |
| 6464 // used for keeping the (newly) grey objects during the scan. | |
| 6465 // The parallel version (Par_...) appears further below. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6466 void MarkRefsIntoAndScanClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6467 if (obj != NULL) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6468 assert(obj->is_oop(), "expected an oop"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6469 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6470 assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6471 assert(_collector->overflow_list_is_empty(), |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6472 "overflow list should be empty"); |
| 0 | 6473 if (_span.contains(addr) && |
| 6474 !_bit_map->isMarked(addr)) { | |
| 6475 // mark bit map (object is now grey) | |
| 6476 _bit_map->mark(addr); | |
| 6477 // push on marking stack (stack should be empty), and drain the | |
| 6478 // stack by applying this closure to the oops in the oops popped | |
| 6479 // from the stack (i.e. blacken the grey objects) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6480 bool res = _mark_stack->push(obj); |
| 0 | 6481 assert(res, "Should have space to push on empty stack"); |
| 6482 do { | |
| 6483 oop new_oop = _mark_stack->pop(); | |
| 6484 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 6485 assert(new_oop->is_parsable(), "Found unparsable oop"); | |
| 6486 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 6487 "only grey objects on this stack"); | |
| 6488 // iterate over the oops in this oop, marking and pushing | |
| 6489 // the ones in CMS heap (i.e. in _span). | |
| 6490 new_oop->oop_iterate(&_pushAndMarkClosure); | |
| 6491 // check if it's time to yield | |
| 6492 do_yield_check(); | |
| 6493 } while (!_mark_stack->isEmpty() || | |
| 6494 (!_concurrent_precleaning && take_from_overflow_list())); | |
| 6495 // if marking stack is empty, and we are not doing this | |
| 6496 // during precleaning, then check the overflow list | |
| 6497 } | |
| 6498 assert(_mark_stack->isEmpty(), "post-condition (eager drainage)"); | |
| 6499 assert(_collector->overflow_list_is_empty(), | |
| 6500 "overflow list was drained above"); | |
| 6501 // We could restore evacuated mark words, if any, used for | |
| 6502 // overflow list links here because the overflow list is | |
| 6503 // provably empty here. That would reduce the maximum | |
| 6504 // size requirements for preserved_{oop,mark}_stack. | |
| 6505 // But we'll just postpone it until we are all done | |
| 6506 // so we can just stream through. | |
| 6507 if (!_concurrent_precleaning && CMSOverflowEarlyRestoration) { | |
| 6508 _collector->restore_preserved_marks_if_any(); | |
| 6509 assert(_collector->no_preserved_marks(), "No preserved marks"); | |
| 6510 } | |
| 6511 assert(!CMSOverflowEarlyRestoration || _collector->no_preserved_marks(), | |
| 6512 "All preserved marks should have been restored above"); | |
| 6513 } | |
| 6514 } | |
| 6515 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6516 void MarkRefsIntoAndScanClosure::do_oop(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6517 void MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6518 |
| 0 | 6519 void MarkRefsIntoAndScanClosure::do_yield_work() { |
| 6520 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6521 "CMS thread should hold CMS token"); | |
| 6522 assert_lock_strong(_freelistLock); | |
| 6523 assert_lock_strong(_bit_map->lock()); | |
| 6524 // relinquish the free_list_lock and bitMaplock() | |
| 6525 _bit_map->lock()->unlock(); | |
| 6526 _freelistLock->unlock(); | |
| 6527 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6528 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6529 _collector->stopTimer(); | |
| 6530 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6531 if (PrintCMSStatistics != 0) { | |
| 6532 _collector->incrementYields(); | |
| 6533 } | |
| 6534 _collector->icms_wait(); | |
| 6535 | |
| 6536 // See the comment in coordinator_yield() | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6537 for (unsigned i = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6538 i < CMSYieldSleepCount && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6539 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6540 !CMSCollector::foregroundGCIsActive(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6541 ++i) { |
| 0 | 6542 os::sleep(Thread::current(), 1, false); |
| 6543 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6544 } | |
| 6545 | |
| 6546 ConcurrentMarkSweepThread::synchronize(true); | |
| 6547 _freelistLock->lock_without_safepoint_check(); | |
| 6548 _bit_map->lock()->lock_without_safepoint_check(); | |
| 6549 _collector->startTimer(); | |
| 6550 } | |
| 6551 | |
| 6552 /////////////////////////////////////////////////////////// | |
| 6553 // Par_MarkRefsIntoAndScanClosure: a parallel version of | |
| 6554 // MarkRefsIntoAndScanClosure | |
| 6555 /////////////////////////////////////////////////////////// | |
| 6556 Par_MarkRefsIntoAndScanClosure::Par_MarkRefsIntoAndScanClosure( | |
| 6557 CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, | |
| 6558 CMSBitMap* bit_map, OopTaskQueue* work_queue, CMSMarkStack* revisit_stack): | |
| 6559 _span(span), | |
| 6560 _bit_map(bit_map), | |
| 6561 _work_queue(work_queue), | |
| 6562 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4), | |
| 6563 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))), | |
| 6564 _par_pushAndMarkClosure(collector, span, rp, bit_map, work_queue, | |
| 6565 revisit_stack) | |
| 6566 { | |
| 6567 _ref_processor = rp; | |
| 6568 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 6569 } | |
| 6570 | |
| 6571 // This closure is used to mark refs into the CMS generation at the | |
| 6572 // second (final) checkpoint, and to scan and transitively follow | |
| 6573 // the unmarked oops. The marks are made in the marking bit map and | |
| 6574 // the work_queue is used for keeping the (newly) grey objects during | |
| 6575 // the scan phase whence they are also available for stealing by parallel | |
| 6576 // threads. Since the marking bit map is shared, updates are | |
| 6577 // synchronized (via CAS). | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6578 void Par_MarkRefsIntoAndScanClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6579 if (obj != NULL) { |
| 0 | 6580 // Ignore mark word because this could be an already marked oop |
| 6581 // that may be chained at the end of the overflow list. | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
6582 assert(obj->is_oop(true), "expected an oop"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6583 HeapWord* addr = (HeapWord*)obj; |
| 0 | 6584 if (_span.contains(addr) && |
| 6585 !_bit_map->isMarked(addr)) { | |
| 6586 // mark bit map (object will become grey): | |
| 6587 // It is possible for several threads to be | |
| 6588 // trying to "claim" this object concurrently; | |
| 6589 // the unique thread that succeeds in marking the | |
| 6590 // object first will do the subsequent push on | |
| 6591 // to the work queue (or overflow list). | |
| 6592 if (_bit_map->par_mark(addr)) { | |
| 6593 // push on work_queue (which may not be empty), and trim the | |
| 6594 // queue to an appropriate length by applying this closure to | |
| 6595 // the oops in the oops popped from the stack (i.e. blacken the | |
| 6596 // grey objects) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6597 bool res = _work_queue->push(obj); |
| 0 | 6598 assert(res, "Low water mark should be less than capacity?"); |
| 6599 trim_queue(_low_water_mark); | |
| 6600 } // Else, another thread claimed the object | |
| 6601 } | |
| 6602 } | |
| 6603 } | |
| 6604 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6605 void Par_MarkRefsIntoAndScanClosure::do_oop(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6606 void Par_MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6607 |
| 0 | 6608 // This closure is used to rescan the marked objects on the dirty cards |
| 6609 // in the mod union table and the card table proper. | |
| 6610 size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m( | |
| 6611 oop p, MemRegion mr) { | |
| 6612 | |
| 6613 size_t size = 0; | |
| 6614 HeapWord* addr = (HeapWord*)p; | |
| 6615 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 6616 assert(_span.contains(addr), "we are scanning the CMS generation"); | |
| 6617 // check if it's time to yield | |
| 6618 if (do_yield_check()) { | |
| 6619 // We yielded for some foreground stop-world work, | |
| 6620 // and we have been asked to abort this ongoing preclean cycle. | |
| 6621 return 0; | |
| 6622 } | |
| 6623 if (_bitMap->isMarked(addr)) { | |
| 6624 // it's marked; is it potentially uninitialized? | |
| 187 | 6625 if (p->klass_or_null() != NULL) { |
| 0 | 6626 if (CMSPermGenPrecleaningEnabled && !p->is_parsable()) { |
| 6627 // Signal precleaning to redirty the card since | |
| 6628 // the klass pointer is already installed. | |
| 6629 assert(size == 0, "Initial value"); | |
| 6630 } else { | |
| 6631 assert(p->is_parsable(), "must be parsable."); | |
| 6632 // an initialized object; ignore mark word in verification below | |
| 6633 // since we are running concurrent with mutators | |
| 6634 assert(p->is_oop(true), "should be an oop"); | |
| 6635 if (p->is_objArray()) { | |
| 6636 // objArrays are precisely marked; restrict scanning | |
| 6637 // to dirty cards only. | |
| 187 | 6638 size = CompactibleFreeListSpace::adjustObjectSize( |
| 6639 p->oop_iterate(_scanningClosure, mr)); | |
| 0 | 6640 } else { |
| 6641 // A non-array may have been imprecisely marked; we need | |
| 6642 // to scan object in its entirety. | |
| 6643 size = CompactibleFreeListSpace::adjustObjectSize( | |
| 6644 p->oop_iterate(_scanningClosure)); | |
| 6645 } | |
| 6646 #ifdef DEBUG | |
| 6647 size_t direct_size = | |
| 6648 CompactibleFreeListSpace::adjustObjectSize(p->size()); | |
| 6649 assert(size == direct_size, "Inconsistency in size"); | |
| 6650 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6651 if (!_bitMap->isMarked(addr+1)) { | |
| 6652 _bitMap->verifyNoOneBitsInRange(addr+2, addr+size); | |
| 6653 } else { | |
| 6654 _bitMap->verifyNoOneBitsInRange(addr+2, addr+size-1); | |
| 6655 assert(_bitMap->isMarked(addr+size-1), | |
| 6656 "inconsistent Printezis mark"); | |
| 6657 } | |
| 6658 #endif // DEBUG | |
| 6659 } | |
| 6660 } else { | |
| 6661 // an unitialized object | |
| 6662 assert(_bitMap->isMarked(addr+1), "missing Printezis mark?"); | |
| 6663 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2); | |
| 6664 size = pointer_delta(nextOneAddr + 1, addr); | |
| 6665 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6666 "alignment problem"); | |
| 6667 // Note that pre-cleaning needn't redirty the card. OopDesc::set_klass() | |
| 6668 // will dirty the card when the klass pointer is installed in the | |
| 6669 // object (signalling the completion of initialization). | |
| 6670 } | |
| 6671 } else { | |
| 6672 // Either a not yet marked object or an uninitialized object | |
| 187 | 6673 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
| 0 | 6674 // An uninitialized object, skip to the next card, since |
| 6675 // we may not be able to read its P-bits yet. | |
| 6676 assert(size == 0, "Initial value"); | |
| 6677 } else { | |
| 6678 // An object not (yet) reached by marking: we merely need to | |
| 6679 // compute its size so as to go look at the next block. | |
| 6680 assert(p->is_oop(true), "should be an oop"); | |
| 6681 size = CompactibleFreeListSpace::adjustObjectSize(p->size()); | |
| 6682 } | |
| 6683 } | |
| 6684 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 6685 return size; | |
| 6686 } | |
| 6687 | |
| 6688 void ScanMarkedObjectsAgainCarefullyClosure::do_yield_work() { | |
| 6689 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6690 "CMS thread should hold CMS token"); | |
| 6691 assert_lock_strong(_freelistLock); | |
| 6692 assert_lock_strong(_bitMap->lock()); | |
| 6693 // relinquish the free_list_lock and bitMaplock() | |
| 6694 _bitMap->lock()->unlock(); | |
| 6695 _freelistLock->unlock(); | |
| 6696 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6697 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6698 _collector->stopTimer(); | |
| 6699 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6700 if (PrintCMSStatistics != 0) { | |
| 6701 _collector->incrementYields(); | |
| 6702 } | |
| 6703 _collector->icms_wait(); | |
| 6704 | |
| 6705 // See the comment in coordinator_yield() | |
| 6706 for (unsigned i = 0; i < CMSYieldSleepCount && | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6707 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6708 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 6709 os::sleep(Thread::current(), 1, false); |
| 6710 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6711 } | |
| 6712 | |
| 6713 ConcurrentMarkSweepThread::synchronize(true); | |
| 6714 _freelistLock->lock_without_safepoint_check(); | |
| 6715 _bitMap->lock()->lock_without_safepoint_check(); | |
| 6716 _collector->startTimer(); | |
| 6717 } | |
| 6718 | |
| 6719 | |
| 6720 ////////////////////////////////////////////////////////////////// | |
| 6721 // SurvivorSpacePrecleanClosure | |
| 6722 ////////////////////////////////////////////////////////////////// | |
| 6723 // This (single-threaded) closure is used to preclean the oops in | |
| 6724 // the survivor spaces. | |
| 6725 size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) { | |
| 6726 | |
| 6727 HeapWord* addr = (HeapWord*)p; | |
| 6728 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 6729 assert(!_span.contains(addr), "we are scanning the survivor spaces"); | |
| 187 | 6730 assert(p->klass_or_null() != NULL, "object should be initializd"); |
| 0 | 6731 assert(p->is_parsable(), "must be parsable."); |
| 6732 // an initialized object; ignore mark word in verification below | |
| 6733 // since we are running concurrent with mutators | |
| 6734 assert(p->is_oop(true), "should be an oop"); | |
| 6735 // Note that we do not yield while we iterate over | |
| 6736 // the interior oops of p, pushing the relevant ones | |
| 6737 // on our marking stack. | |
| 6738 size_t size = p->oop_iterate(_scanning_closure); | |
| 6739 do_yield_check(); | |
| 6740 // Observe that below, we do not abandon the preclean | |
| 6741 // phase as soon as we should; rather we empty the | |
| 6742 // marking stack before returning. This is to satisfy | |
| 6743 // some existing assertions. In general, it may be a | |
| 6744 // good idea to abort immediately and complete the marking | |
| 6745 // from the grey objects at a later time. | |
| 6746 while (!_mark_stack->isEmpty()) { | |
| 6747 oop new_oop = _mark_stack->pop(); | |
| 6748 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 6749 assert(new_oop->is_parsable(), "Found unparsable oop"); | |
| 6750 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 6751 "only grey objects on this stack"); | |
| 6752 // iterate over the oops in this oop, marking and pushing | |
| 6753 // the ones in CMS heap (i.e. in _span). | |
| 6754 new_oop->oop_iterate(_scanning_closure); | |
| 6755 // check if it's time to yield | |
| 6756 do_yield_check(); | |
| 6757 } | |
| 6758 unsigned int after_count = | |
| 6759 GenCollectedHeap::heap()->total_collections(); | |
| 6760 bool abort = (_before_count != after_count) || | |
| 6761 _collector->should_abort_preclean(); | |
| 6762 return abort ? 0 : size; | |
| 6763 } | |
| 6764 | |
| 6765 void SurvivorSpacePrecleanClosure::do_yield_work() { | |
| 6766 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6767 "CMS thread should hold CMS token"); | |
| 6768 assert_lock_strong(_bit_map->lock()); | |
| 6769 // Relinquish the bit map lock | |
| 6770 _bit_map->lock()->unlock(); | |
| 6771 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6772 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6773 _collector->stopTimer(); | |
| 6774 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6775 if (PrintCMSStatistics != 0) { | |
| 6776 _collector->incrementYields(); | |
| 6777 } | |
| 6778 _collector->icms_wait(); | |
| 6779 | |
| 6780 // See the comment in coordinator_yield() | |
| 6781 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 6782 ConcurrentMarkSweepThread::should_yield() && | |
| 6783 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 6784 os::sleep(Thread::current(), 1, false); | |
| 6785 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6786 } | |
| 6787 | |
| 6788 ConcurrentMarkSweepThread::synchronize(true); | |
| 6789 _bit_map->lock()->lock_without_safepoint_check(); | |
| 6790 _collector->startTimer(); | |
| 6791 } | |
| 6792 | |
| 6793 // This closure is used to rescan the marked objects on the dirty cards | |
| 6794 // in the mod union table and the card table proper. In the parallel | |
| 6795 // case, although the bitMap is shared, we do a single read so the | |
| 6796 // isMarked() query is "safe". | |
| 6797 bool ScanMarkedObjectsAgainClosure::do_object_bm(oop p, MemRegion mr) { | |
| 6798 // Ignore mark word because we are running concurrent with mutators | |
| 6799 assert(p->is_oop_or_null(true), "expected an oop or null"); | |
| 6800 HeapWord* addr = (HeapWord*)p; | |
| 6801 assert(_span.contains(addr), "we are scanning the CMS generation"); | |
| 6802 bool is_obj_array = false; | |
| 6803 #ifdef DEBUG | |
| 6804 if (!_parallel) { | |
| 6805 assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)"); | |
| 6806 assert(_collector->overflow_list_is_empty(), | |
| 6807 "overflow list should be empty"); | |
| 6808 | |
| 6809 } | |
| 6810 #endif // DEBUG | |
| 6811 if (_bit_map->isMarked(addr)) { | |
| 6812 // Obj arrays are precisely marked, non-arrays are not; | |
| 6813 // so we scan objArrays precisely and non-arrays in their | |
| 6814 // entirety. | |
| 6815 if (p->is_objArray()) { | |
| 6816 is_obj_array = true; | |
| 6817 if (_parallel) { | |
| 6818 p->oop_iterate(_par_scan_closure, mr); | |
| 6819 } else { | |
| 6820 p->oop_iterate(_scan_closure, mr); | |
| 6821 } | |
| 6822 } else { | |
| 6823 if (_parallel) { | |
| 6824 p->oop_iterate(_par_scan_closure); | |
| 6825 } else { | |
| 6826 p->oop_iterate(_scan_closure); | |
| 6827 } | |
| 6828 } | |
| 6829 } | |
| 6830 #ifdef DEBUG | |
| 6831 if (!_parallel) { | |
| 6832 assert(_mark_stack->isEmpty(), "post-condition (eager drainage)"); | |
| 6833 assert(_collector->overflow_list_is_empty(), | |
| 6834 "overflow list should be empty"); | |
| 6835 | |
| 6836 } | |
| 6837 #endif // DEBUG | |
| 6838 return is_obj_array; | |
| 6839 } | |
| 6840 | |
| 6841 MarkFromRootsClosure::MarkFromRootsClosure(CMSCollector* collector, | |
| 6842 MemRegion span, | |
| 6843 CMSBitMap* bitMap, CMSMarkStack* markStack, | |
| 6844 CMSMarkStack* revisitStack, | |
| 6845 bool should_yield, bool verifying): | |
| 6846 _collector(collector), | |
| 6847 _span(span), | |
| 6848 _bitMap(bitMap), | |
| 6849 _mut(&collector->_modUnionTable), | |
| 6850 _markStack(markStack), | |
| 6851 _revisitStack(revisitStack), | |
| 6852 _yield(should_yield), | |
| 6853 _skipBits(0) | |
| 6854 { | |
| 6855 assert(_markStack->isEmpty(), "stack should be empty"); | |
| 6856 _finger = _bitMap->startWord(); | |
| 6857 _threshold = _finger; | |
| 6858 assert(_collector->_restart_addr == NULL, "Sanity check"); | |
| 6859 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 6860 DEBUG_ONLY(_verifying = verifying;) | |
| 6861 } | |
| 6862 | |
| 6863 void MarkFromRootsClosure::reset(HeapWord* addr) { | |
| 6864 assert(_markStack->isEmpty(), "would cause duplicates on stack"); | |
| 6865 assert(_span.contains(addr), "Out of bounds _finger?"); | |
| 6866 _finger = addr; | |
| 6867 _threshold = (HeapWord*)round_to( | |
| 6868 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 6869 } | |
| 6870 | |
| 6871 // Should revisit to see if this should be restructured for | |
| 6872 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6873 bool MarkFromRootsClosure::do_bit(size_t offset) { |
| 0 | 6874 if (_skipBits > 0) { |
| 6875 _skipBits--; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6876 return true; |
| 0 | 6877 } |
| 6878 // convert offset into a HeapWord* | |
| 6879 HeapWord* addr = _bitMap->startWord() + offset; | |
| 6880 assert(_bitMap->endWord() && addr < _bitMap->endWord(), | |
| 6881 "address out of range"); | |
| 6882 assert(_bitMap->isMarked(addr), "tautology"); | |
| 6883 if (_bitMap->isMarked(addr+1)) { | |
| 6884 // this is an allocated but not yet initialized object | |
| 6885 assert(_skipBits == 0, "tautology"); | |
| 6886 _skipBits = 2; // skip next two marked bits ("Printezis-marks") | |
| 6887 oop p = oop(addr); | |
| 187 | 6888 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
| 0 | 6889 DEBUG_ONLY(if (!_verifying) {) |
| 6890 // We re-dirty the cards on which this object lies and increase | |
| 6891 // the _threshold so that we'll come back to scan this object | |
| 6892 // during the preclean or remark phase. (CMSCleanOnEnter) | |
| 6893 if (CMSCleanOnEnter) { | |
| 6894 size_t sz = _collector->block_size_using_printezis_bits(addr); | |
| 6895 HeapWord* end_card_addr = (HeapWord*)round_to( | |
| 6896 (intptr_t)(addr+sz), CardTableModRefBS::card_size); | |
|
283
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
6897 MemRegion redirty_range = MemRegion(addr, end_card_addr); |
| 0 | 6898 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
| 6899 // Bump _threshold to end_card_addr; note that | |
| 6900 // _threshold cannot possibly exceed end_card_addr, anyhow. | |
| 6901 // This prevents future clearing of the card as the scan proceeds | |
| 6902 // to the right. | |
| 6903 assert(_threshold <= end_card_addr, | |
| 6904 "Because we are just scanning into this object"); | |
| 6905 if (_threshold < end_card_addr) { | |
| 6906 _threshold = end_card_addr; | |
| 6907 } | |
| 187 | 6908 if (p->klass_or_null() != NULL) { |
| 0 | 6909 // Redirty the range of cards... |
| 6910 _mut->mark_range(redirty_range); | |
| 6911 } // ...else the setting of klass will dirty the card anyway. | |
| 6912 } | |
| 6913 DEBUG_ONLY(}) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6914 return true; |
| 0 | 6915 } |
| 6916 } | |
| 6917 scanOopsInOop(addr); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
6918 return true; |
| 0 | 6919 } |
| 6920 | |
| 6921 // We take a break if we've been at this for a while, | |
| 6922 // so as to avoid monopolizing the locks involved. | |
| 6923 void MarkFromRootsClosure::do_yield_work() { | |
| 6924 // First give up the locks, then yield, then re-lock | |
| 6925 // We should probably use a constructor/destructor idiom to | |
| 6926 // do this unlock/lock or modify the MutexUnlocker class to | |
| 6927 // serve our purpose. XXX | |
| 6928 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6929 "CMS thread should hold CMS token"); | |
| 6930 assert_lock_strong(_bitMap->lock()); | |
| 6931 _bitMap->lock()->unlock(); | |
| 6932 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6933 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6934 _collector->stopTimer(); | |
| 6935 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6936 if (PrintCMSStatistics != 0) { | |
| 6937 _collector->incrementYields(); | |
| 6938 } | |
| 6939 _collector->icms_wait(); | |
| 6940 | |
| 6941 // See the comment in coordinator_yield() | |
| 6942 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 6943 ConcurrentMarkSweepThread::should_yield() && | |
| 6944 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 6945 os::sleep(Thread::current(), 1, false); | |
| 6946 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6947 } | |
| 6948 | |
| 6949 ConcurrentMarkSweepThread::synchronize(true); | |
| 6950 _bitMap->lock()->lock_without_safepoint_check(); | |
| 6951 _collector->startTimer(); | |
| 6952 } | |
| 6953 | |
| 6954 void MarkFromRootsClosure::scanOopsInOop(HeapWord* ptr) { | |
| 6955 assert(_bitMap->isMarked(ptr), "expected bit to be set"); | |
| 6956 assert(_markStack->isEmpty(), | |
| 6957 "should drain stack to limit stack usage"); | |
| 6958 // convert ptr to an oop preparatory to scanning | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6959 oop obj = oop(ptr); |
| 0 | 6960 // Ignore mark word in verification below, since we |
| 6961 // may be running concurrent with mutators. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6962 assert(obj->is_oop(true), "should be an oop"); |
| 0 | 6963 assert(_finger <= ptr, "_finger runneth ahead"); |
| 6964 // advance the finger to right end of this object | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6965 _finger = ptr + obj->size(); |
| 0 | 6966 assert(_finger > ptr, "we just incremented it above"); |
| 6967 // On large heaps, it may take us some time to get through | |
| 6968 // the marking phase (especially if running iCMS). During | |
| 6969 // this time it's possible that a lot of mutations have | |
| 6970 // accumulated in the card table and the mod union table -- | |
| 6971 // these mutation records are redundant until we have | |
| 6972 // actually traced into the corresponding card. | |
| 6973 // Here, we check whether advancing the finger would make | |
| 6974 // us cross into a new card, and if so clear corresponding | |
| 6975 // cards in the MUT (preclean them in the card-table in the | |
| 6976 // future). | |
| 6977 | |
| 6978 DEBUG_ONLY(if (!_verifying) {) | |
| 6979 // The clean-on-enter optimization is disabled by default, | |
| 6980 // until we fix 6178663. | |
| 6981 if (CMSCleanOnEnter && (_finger > _threshold)) { | |
| 6982 // [_threshold, _finger) represents the interval | |
| 6983 // of cards to be cleared in MUT (or precleaned in card table). | |
| 6984 // The set of cards to be cleared is all those that overlap | |
| 6985 // with the interval [_threshold, _finger); note that | |
| 6986 // _threshold is always kept card-aligned but _finger isn't | |
| 6987 // always card-aligned. | |
| 6988 HeapWord* old_threshold = _threshold; | |
| 6989 assert(old_threshold == (HeapWord*)round_to( | |
| 6990 (intptr_t)old_threshold, CardTableModRefBS::card_size), | |
| 6991 "_threshold should always be card-aligned"); | |
| 6992 _threshold = (HeapWord*)round_to( | |
| 6993 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 6994 MemRegion mr(old_threshold, _threshold); | |
| 6995 assert(!mr.is_empty(), "Control point invariant"); | |
| 6996 assert(_span.contains(mr), "Should clear within span"); | |
| 6997 // XXX When _finger crosses from old gen into perm gen | |
| 6998 // we may be doing unnecessary cleaning; do better in the | |
| 6999 // future by detecting that condition and clearing fewer | |
| 7000 // MUT/CT entries. | |
| 7001 _mut->clear_range(mr); | |
| 7002 } | |
| 7003 DEBUG_ONLY(}) | |
| 7004 | |
| 7005 // Note: the finger doesn't advance while we drain | |
| 7006 // the stack below. | |
| 7007 PushOrMarkClosure pushOrMarkClosure(_collector, | |
| 7008 _span, _bitMap, _markStack, | |
| 7009 _revisitStack, | |
| 7010 _finger, this); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7011 bool res = _markStack->push(obj); |
| 0 | 7012 assert(res, "Empty non-zero size stack should have space for single push"); |
| 7013 while (!_markStack->isEmpty()) { | |
| 7014 oop new_oop = _markStack->pop(); | |
| 7015 // Skip verifying header mark word below because we are | |
| 7016 // running concurrent with mutators. | |
| 7017 assert(new_oop->is_oop(true), "Oops! expected to pop an oop"); | |
| 7018 // now scan this oop's oops | |
| 7019 new_oop->oop_iterate(&pushOrMarkClosure); | |
| 7020 do_yield_check(); | |
| 7021 } | |
| 7022 assert(_markStack->isEmpty(), "tautology, emphasizing post-condition"); | |
| 7023 } | |
| 7024 | |
| 7025 Par_MarkFromRootsClosure::Par_MarkFromRootsClosure(CMSConcMarkingTask* task, | |
| 7026 CMSCollector* collector, MemRegion span, | |
| 7027 CMSBitMap* bit_map, | |
| 7028 OopTaskQueue* work_queue, | |
| 7029 CMSMarkStack* overflow_stack, | |
| 7030 CMSMarkStack* revisit_stack, | |
| 7031 bool should_yield): | |
| 7032 _collector(collector), | |
| 7033 _whole_span(collector->_span), | |
| 7034 _span(span), | |
| 7035 _bit_map(bit_map), | |
| 7036 _mut(&collector->_modUnionTable), | |
| 7037 _work_queue(work_queue), | |
| 7038 _overflow_stack(overflow_stack), | |
| 7039 _revisit_stack(revisit_stack), | |
| 7040 _yield(should_yield), | |
| 7041 _skip_bits(0), | |
| 7042 _task(task) | |
| 7043 { | |
| 7044 assert(_work_queue->size() == 0, "work_queue should be empty"); | |
| 7045 _finger = span.start(); | |
| 7046 _threshold = _finger; // XXX Defer clear-on-enter optimization for now | |
| 7047 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 7048 } | |
| 7049 | |
| 7050 // Should revisit to see if this should be restructured for | |
| 7051 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7052 bool Par_MarkFromRootsClosure::do_bit(size_t offset) { |
| 0 | 7053 if (_skip_bits > 0) { |
| 7054 _skip_bits--; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7055 return true; |
| 0 | 7056 } |
| 7057 // convert offset into a HeapWord* | |
| 7058 HeapWord* addr = _bit_map->startWord() + offset; | |
| 7059 assert(_bit_map->endWord() && addr < _bit_map->endWord(), | |
| 7060 "address out of range"); | |
| 7061 assert(_bit_map->isMarked(addr), "tautology"); | |
| 7062 if (_bit_map->isMarked(addr+1)) { | |
| 7063 // this is an allocated object that might not yet be initialized | |
| 7064 assert(_skip_bits == 0, "tautology"); | |
| 7065 _skip_bits = 2; // skip next two marked bits ("Printezis-marks") | |
| 7066 oop p = oop(addr); | |
| 187 | 7067 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
| 0 | 7068 // in the case of Clean-on-Enter optimization, redirty card |
| 7069 // and avoid clearing card by increasing the threshold. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7070 return true; |
| 0 | 7071 } |
| 7072 } | |
| 7073 scan_oops_in_oop(addr); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7074 return true; |
| 0 | 7075 } |
| 7076 | |
| 7077 void Par_MarkFromRootsClosure::scan_oops_in_oop(HeapWord* ptr) { | |
| 7078 assert(_bit_map->isMarked(ptr), "expected bit to be set"); | |
| 7079 // Should we assert that our work queue is empty or | |
| 7080 // below some drain limit? | |
| 7081 assert(_work_queue->size() == 0, | |
| 7082 "should drain stack to limit stack usage"); | |
| 7083 // convert ptr to an oop preparatory to scanning | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7084 oop obj = oop(ptr); |
| 0 | 7085 // Ignore mark word in verification below, since we |
| 7086 // may be running concurrent with mutators. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7087 assert(obj->is_oop(true), "should be an oop"); |
| 0 | 7088 assert(_finger <= ptr, "_finger runneth ahead"); |
| 7089 // advance the finger to right end of this object | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7090 _finger = ptr + obj->size(); |
| 0 | 7091 assert(_finger > ptr, "we just incremented it above"); |
| 7092 // On large heaps, it may take us some time to get through | |
| 7093 // the marking phase (especially if running iCMS). During | |
| 7094 // this time it's possible that a lot of mutations have | |
| 7095 // accumulated in the card table and the mod union table -- | |
| 7096 // these mutation records are redundant until we have | |
| 7097 // actually traced into the corresponding card. | |
| 7098 // Here, we check whether advancing the finger would make | |
| 7099 // us cross into a new card, and if so clear corresponding | |
| 7100 // cards in the MUT (preclean them in the card-table in the | |
| 7101 // future). | |
| 7102 | |
| 7103 // The clean-on-enter optimization is disabled by default, | |
| 7104 // until we fix 6178663. | |
| 7105 if (CMSCleanOnEnter && (_finger > _threshold)) { | |
| 7106 // [_threshold, _finger) represents the interval | |
| 7107 // of cards to be cleared in MUT (or precleaned in card table). | |
| 7108 // The set of cards to be cleared is all those that overlap | |
| 7109 // with the interval [_threshold, _finger); note that | |
| 7110 // _threshold is always kept card-aligned but _finger isn't | |
| 7111 // always card-aligned. | |
| 7112 HeapWord* old_threshold = _threshold; | |
| 7113 assert(old_threshold == (HeapWord*)round_to( | |
| 7114 (intptr_t)old_threshold, CardTableModRefBS::card_size), | |
| 7115 "_threshold should always be card-aligned"); | |
| 7116 _threshold = (HeapWord*)round_to( | |
| 7117 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 7118 MemRegion mr(old_threshold, _threshold); | |
| 7119 assert(!mr.is_empty(), "Control point invariant"); | |
| 7120 assert(_span.contains(mr), "Should clear within span"); // _whole_span ?? | |
| 7121 // XXX When _finger crosses from old gen into perm gen | |
| 7122 // we may be doing unnecessary cleaning; do better in the | |
| 7123 // future by detecting that condition and clearing fewer | |
| 7124 // MUT/CT entries. | |
| 7125 _mut->clear_range(mr); | |
| 7126 } | |
| 7127 | |
| 7128 // Note: the local finger doesn't advance while we drain | |
| 7129 // the stack below, but the global finger sure can and will. | |
| 7130 HeapWord** gfa = _task->global_finger_addr(); | |
| 7131 Par_PushOrMarkClosure pushOrMarkClosure(_collector, | |
| 7132 _span, _bit_map, | |
| 7133 _work_queue, | |
| 7134 _overflow_stack, | |
| 7135 _revisit_stack, | |
| 7136 _finger, | |
| 7137 gfa, this); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7138 bool res = _work_queue->push(obj); // overflow could occur here |
| 0 | 7139 assert(res, "Will hold once we use workqueues"); |
| 7140 while (true) { | |
| 7141 oop new_oop; | |
| 7142 if (!_work_queue->pop_local(new_oop)) { | |
| 7143 // We emptied our work_queue; check if there's stuff that can | |
| 7144 // be gotten from the overflow stack. | |
| 7145 if (CMSConcMarkingTask::get_work_from_overflow_stack( | |
| 7146 _overflow_stack, _work_queue)) { | |
| 7147 do_yield_check(); | |
| 7148 continue; | |
| 7149 } else { // done | |
| 7150 break; | |
| 7151 } | |
| 7152 } | |
| 7153 // Skip verifying header mark word below because we are | |
| 7154 // running concurrent with mutators. | |
| 7155 assert(new_oop->is_oop(true), "Oops! expected to pop an oop"); | |
| 7156 // now scan this oop's oops | |
| 7157 new_oop->oop_iterate(&pushOrMarkClosure); | |
| 7158 do_yield_check(); | |
| 7159 } | |
| 7160 assert(_work_queue->size() == 0, "tautology, emphasizing post-condition"); | |
| 7161 } | |
| 7162 | |
| 7163 // Yield in response to a request from VM Thread or | |
| 7164 // from mutators. | |
| 7165 void Par_MarkFromRootsClosure::do_yield_work() { | |
| 7166 assert(_task != NULL, "sanity"); | |
| 7167 _task->yield(); | |
| 7168 } | |
| 7169 | |
| 7170 // A variant of the above used for verifying CMS marking work. | |
| 7171 MarkFromRootsVerifyClosure::MarkFromRootsVerifyClosure(CMSCollector* collector, | |
| 7172 MemRegion span, | |
| 7173 CMSBitMap* verification_bm, CMSBitMap* cms_bm, | |
| 7174 CMSMarkStack* mark_stack): | |
| 7175 _collector(collector), | |
| 7176 _span(span), | |
| 7177 _verification_bm(verification_bm), | |
| 7178 _cms_bm(cms_bm), | |
| 7179 _mark_stack(mark_stack), | |
| 7180 _pam_verify_closure(collector, span, verification_bm, cms_bm, | |
| 7181 mark_stack) | |
| 7182 { | |
| 7183 assert(_mark_stack->isEmpty(), "stack should be empty"); | |
| 7184 _finger = _verification_bm->startWord(); | |
| 7185 assert(_collector->_restart_addr == NULL, "Sanity check"); | |
| 7186 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 7187 } | |
| 7188 | |
| 7189 void MarkFromRootsVerifyClosure::reset(HeapWord* addr) { | |
| 7190 assert(_mark_stack->isEmpty(), "would cause duplicates on stack"); | |
| 7191 assert(_span.contains(addr), "Out of bounds _finger?"); | |
| 7192 _finger = addr; | |
| 7193 } | |
| 7194 | |
| 7195 // Should revisit to see if this should be restructured for | |
| 7196 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7197 bool MarkFromRootsVerifyClosure::do_bit(size_t offset) { |
| 0 | 7198 // convert offset into a HeapWord* |
| 7199 HeapWord* addr = _verification_bm->startWord() + offset; | |
| 7200 assert(_verification_bm->endWord() && addr < _verification_bm->endWord(), | |
| 7201 "address out of range"); | |
| 7202 assert(_verification_bm->isMarked(addr), "tautology"); | |
| 7203 assert(_cms_bm->isMarked(addr), "tautology"); | |
| 7204 | |
| 7205 assert(_mark_stack->isEmpty(), | |
| 7206 "should drain stack to limit stack usage"); | |
| 7207 // convert addr to an oop preparatory to scanning | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7208 oop obj = oop(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7209 assert(obj->is_oop(), "should be an oop"); |
| 0 | 7210 assert(_finger <= addr, "_finger runneth ahead"); |
| 7211 // advance the finger to right end of this object | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7212 _finger = addr + obj->size(); |
| 0 | 7213 assert(_finger > addr, "we just incremented it above"); |
| 7214 // Note: the finger doesn't advance while we drain | |
| 7215 // the stack below. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7216 bool res = _mark_stack->push(obj); |
| 0 | 7217 assert(res, "Empty non-zero size stack should have space for single push"); |
| 7218 while (!_mark_stack->isEmpty()) { | |
| 7219 oop new_oop = _mark_stack->pop(); | |
| 7220 assert(new_oop->is_oop(), "Oops! expected to pop an oop"); | |
| 7221 // now scan this oop's oops | |
| 7222 new_oop->oop_iterate(&_pam_verify_closure); | |
| 7223 } | |
| 7224 assert(_mark_stack->isEmpty(), "tautology, emphasizing post-condition"); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7225 return true; |
| 0 | 7226 } |
| 7227 | |
| 7228 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure( | |
| 7229 CMSCollector* collector, MemRegion span, | |
| 7230 CMSBitMap* verification_bm, CMSBitMap* cms_bm, | |
| 7231 CMSMarkStack* mark_stack): | |
| 7232 OopClosure(collector->ref_processor()), | |
| 7233 _collector(collector), | |
| 7234 _span(span), | |
| 7235 _verification_bm(verification_bm), | |
| 7236 _cms_bm(cms_bm), | |
| 7237 _mark_stack(mark_stack) | |
| 7238 { } | |
| 7239 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7240 void PushAndMarkVerifyClosure::do_oop(oop* p) { PushAndMarkVerifyClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7241 void PushAndMarkVerifyClosure::do_oop(narrowOop* p) { PushAndMarkVerifyClosure::do_oop_work(p); } |
| 0 | 7242 |
| 7243 // Upon stack overflow, we discard (part of) the stack, | |
| 7244 // remembering the least address amongst those discarded | |
| 7245 // in CMSCollector's _restart_address. | |
| 7246 void PushAndMarkVerifyClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7247 // Remember the least grey address discarded | |
| 7248 HeapWord* ra = (HeapWord*)_mark_stack->least_value(lost); | |
| 7249 _collector->lower_restart_addr(ra); | |
| 7250 _mark_stack->reset(); // discard stack contents | |
| 7251 _mark_stack->expand(); // expand the stack if possible | |
| 7252 } | |
| 7253 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7254 void PushAndMarkVerifyClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7255 assert(obj->is_oop_or_null(), "expected an oop or NULL"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7256 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7257 if (_span.contains(addr) && !_verification_bm->isMarked(addr)) { |
| 7258 // Oop lies in _span and isn't yet grey or black | |
| 7259 _verification_bm->mark(addr); // now grey | |
| 7260 if (!_cms_bm->isMarked(addr)) { | |
| 7261 oop(addr)->print(); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7262 gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7263 addr); |
| 0 | 7264 fatal("... aborting"); |
| 7265 } | |
| 7266 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7267 if (!_mark_stack->push(obj)) { // stack overflow |
| 0 | 7268 if (PrintCMSStatistics != 0) { |
| 7269 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7270 SIZE_FORMAT, _mark_stack->capacity()); | |
| 7271 } | |
| 7272 assert(_mark_stack->isFull(), "Else push should have succeeded"); | |
| 7273 handle_stack_overflow(addr); | |
| 7274 } | |
| 7275 // anything including and to the right of _finger | |
| 7276 // will be scanned as we iterate over the remainder of the | |
| 7277 // bit map | |
| 7278 } | |
| 7279 } | |
| 7280 | |
| 7281 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector, | |
| 7282 MemRegion span, | |
| 7283 CMSBitMap* bitMap, CMSMarkStack* markStack, | |
| 7284 CMSMarkStack* revisitStack, | |
| 7285 HeapWord* finger, MarkFromRootsClosure* parent) : | |
| 7286 OopClosure(collector->ref_processor()), | |
| 7287 _collector(collector), | |
| 7288 _span(span), | |
| 7289 _bitMap(bitMap), | |
| 7290 _markStack(markStack), | |
| 7291 _revisitStack(revisitStack), | |
| 7292 _finger(finger), | |
| 7293 _parent(parent), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
7294 _should_remember_klasses(collector->should_unload_classes()) |
| 0 | 7295 { } |
| 7296 | |
| 7297 Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector, | |
| 7298 MemRegion span, | |
| 7299 CMSBitMap* bit_map, | |
| 7300 OopTaskQueue* work_queue, | |
| 7301 CMSMarkStack* overflow_stack, | |
| 7302 CMSMarkStack* revisit_stack, | |
| 7303 HeapWord* finger, | |
| 7304 HeapWord** global_finger_addr, | |
| 7305 Par_MarkFromRootsClosure* parent) : | |
| 7306 OopClosure(collector->ref_processor()), | |
| 7307 _collector(collector), | |
| 7308 _whole_span(collector->_span), | |
| 7309 _span(span), | |
| 7310 _bit_map(bit_map), | |
| 7311 _work_queue(work_queue), | |
| 7312 _overflow_stack(overflow_stack), | |
| 7313 _revisit_stack(revisit_stack), | |
| 7314 _finger(finger), | |
| 7315 _global_finger_addr(global_finger_addr), | |
| 7316 _parent(parent), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
7317 _should_remember_klasses(collector->should_unload_classes()) |
| 0 | 7318 { } |
| 7319 | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
7320 // Assumes thread-safe access by callers, who are |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
7321 // responsible for mutual exclusion. |
| 0 | 7322 void CMSCollector::lower_restart_addr(HeapWord* low) { |
| 7323 assert(_span.contains(low), "Out of bounds addr"); | |
| 7324 if (_restart_addr == NULL) { | |
| 7325 _restart_addr = low; | |
| 7326 } else { | |
| 7327 _restart_addr = MIN2(_restart_addr, low); | |
| 7328 } | |
| 7329 } | |
| 7330 | |
| 7331 // Upon stack overflow, we discard (part of) the stack, | |
| 7332 // remembering the least address amongst those discarded | |
| 7333 // in CMSCollector's _restart_address. | |
| 7334 void PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7335 // Remember the least grey address discarded | |
| 7336 HeapWord* ra = (HeapWord*)_markStack->least_value(lost); | |
| 7337 _collector->lower_restart_addr(ra); | |
| 7338 _markStack->reset(); // discard stack contents | |
| 7339 _markStack->expand(); // expand the stack if possible | |
| 7340 } | |
| 7341 | |
| 7342 // Upon stack overflow, we discard (part of) the stack, | |
| 7343 // remembering the least address amongst those discarded | |
| 7344 // in CMSCollector's _restart_address. | |
| 7345 void Par_PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7346 // We need to do this under a mutex to prevent other | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
7347 // workers from interfering with the work done below. |
| 0 | 7348 MutexLockerEx ml(_overflow_stack->par_lock(), |
| 7349 Mutex::_no_safepoint_check_flag); | |
| 7350 // Remember the least grey address discarded | |
| 7351 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost); | |
| 7352 _collector->lower_restart_addr(ra); | |
| 7353 _overflow_stack->reset(); // discard stack contents | |
| 7354 _overflow_stack->expand(); // expand the stack if possible | |
| 7355 } | |
| 7356 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7357 void PushOrMarkClosure::do_oop(oop obj) { |
| 0 | 7358 // Ignore mark word because we are running concurrent with mutators. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7359 assert(obj->is_oop_or_null(true), "expected an oop or NULL"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7360 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7361 if (_span.contains(addr) && !_bitMap->isMarked(addr)) { |
| 7362 // Oop lies in _span and isn't yet grey or black | |
| 7363 _bitMap->mark(addr); // now grey | |
| 7364 if (addr < _finger) { | |
| 7365 // the bit map iteration has already either passed, or | |
| 7366 // sampled, this bit in the bit map; we'll need to | |
| 7367 // use the marking stack to scan this oop's oops. | |
| 7368 bool simulate_overflow = false; | |
| 7369 NOT_PRODUCT( | |
| 7370 if (CMSMarkStackOverflowALot && | |
| 7371 _collector->simulate_overflow()) { | |
| 7372 // simulate a stack overflow | |
| 7373 simulate_overflow = true; | |
| 7374 } | |
| 7375 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7376 if (simulate_overflow || !_markStack->push(obj)) { // stack overflow |
| 0 | 7377 if (PrintCMSStatistics != 0) { |
| 7378 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7379 SIZE_FORMAT, _markStack->capacity()); | |
| 7380 } | |
| 7381 assert(simulate_overflow || _markStack->isFull(), "Else push should have succeeded"); | |
| 7382 handle_stack_overflow(addr); | |
| 7383 } | |
| 7384 } | |
| 7385 // anything including and to the right of _finger | |
| 7386 // will be scanned as we iterate over the remainder of the | |
| 7387 // bit map | |
| 7388 do_yield_check(); | |
| 7389 } | |
| 7390 } | |
| 7391 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7392 void PushOrMarkClosure::do_oop(oop* p) { PushOrMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7393 void PushOrMarkClosure::do_oop(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7394 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7395 void Par_PushOrMarkClosure::do_oop(oop obj) { |
| 0 | 7396 // Ignore mark word because we are running concurrent with mutators. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7397 assert(obj->is_oop_or_null(true), "expected an oop or NULL"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7398 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7399 if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) { |
| 7400 // Oop lies in _span and isn't yet grey or black | |
| 7401 // We read the global_finger (volatile read) strictly after marking oop | |
| 7402 bool res = _bit_map->par_mark(addr); // now grey | |
| 7403 volatile HeapWord** gfa = (volatile HeapWord**)_global_finger_addr; | |
| 7404 // Should we push this marked oop on our stack? | |
| 7405 // -- if someone else marked it, nothing to do | |
| 7406 // -- if target oop is above global finger nothing to do | |
| 7407 // -- if target oop is in chunk and above local finger | |
| 7408 // then nothing to do | |
| 7409 // -- else push on work queue | |
| 7410 if ( !res // someone else marked it, they will deal with it | |
| 7411 || (addr >= *gfa) // will be scanned in a later task | |
| 7412 || (_span.contains(addr) && addr >= _finger)) { // later in this chunk | |
| 7413 return; | |
| 7414 } | |
| 7415 // the bit map iteration has already either passed, or | |
| 7416 // sampled, this bit in the bit map; we'll need to | |
| 7417 // use the marking stack to scan this oop's oops. | |
| 7418 bool simulate_overflow = false; | |
| 7419 NOT_PRODUCT( | |
| 7420 if (CMSMarkStackOverflowALot && | |
| 7421 _collector->simulate_overflow()) { | |
| 7422 // simulate a stack overflow | |
| 7423 simulate_overflow = true; | |
| 7424 } | |
| 7425 ) | |
| 7426 if (simulate_overflow || | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7427 !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { |
| 0 | 7428 // stack overflow |
| 7429 if (PrintCMSStatistics != 0) { | |
| 7430 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7431 SIZE_FORMAT, _overflow_stack->capacity()); | |
| 7432 } | |
| 7433 // We cannot assert that the overflow stack is full because | |
| 7434 // it may have been emptied since. | |
| 7435 assert(simulate_overflow || | |
| 7436 _work_queue->size() == _work_queue->max_elems(), | |
| 7437 "Else push should have succeeded"); | |
| 7438 handle_stack_overflow(addr); | |
| 7439 } | |
| 7440 do_yield_check(); | |
| 7441 } | |
| 7442 } | |
| 7443 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7444 void Par_PushOrMarkClosure::do_oop(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7445 void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
| 0 | 7446 |
| 7447 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector, | |
| 7448 MemRegion span, | |
| 7449 ReferenceProcessor* rp, | |
| 7450 CMSBitMap* bit_map, | |
| 7451 CMSBitMap* mod_union_table, | |
| 7452 CMSMarkStack* mark_stack, | |
| 7453 CMSMarkStack* revisit_stack, | |
| 7454 bool concurrent_precleaning): | |
| 7455 OopClosure(rp), | |
| 7456 _collector(collector), | |
| 7457 _span(span), | |
| 7458 _bit_map(bit_map), | |
| 7459 _mod_union_table(mod_union_table), | |
| 7460 _mark_stack(mark_stack), | |
| 7461 _revisit_stack(revisit_stack), | |
| 7462 _concurrent_precleaning(concurrent_precleaning), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
7463 _should_remember_klasses(collector->should_unload_classes()) |
| 0 | 7464 { |
| 7465 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 7466 } | |
| 7467 | |
| 7468 // Grey object rescan during pre-cleaning and second checkpoint phases -- | |
| 7469 // the non-parallel version (the parallel version appears further below.) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7470 void PushAndMarkClosure::do_oop(oop obj) { |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7471 // Ignore mark word verification. If during concurrent precleaning, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7472 // the object monitor may be locked. If during the checkpoint |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7473 // phases, the object may already have been reached by a different |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7474 // path and may be at the end of the global overflow list (so |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7475 // the mark word may be NULL). |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7476 assert(obj->is_oop_or_null(true /* ignore mark word */), |
| 0 | 7477 "expected an oop or NULL"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7478 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7479 // Check if oop points into the CMS generation |
| 7480 // and is not marked | |
| 7481 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 7482 // a white object ... | |
| 7483 _bit_map->mark(addr); // ... now grey | |
| 7484 // push on the marking stack (grey set) | |
| 7485 bool simulate_overflow = false; | |
| 7486 NOT_PRODUCT( | |
| 7487 if (CMSMarkStackOverflowALot && | |
| 7488 _collector->simulate_overflow()) { | |
| 7489 // simulate a stack overflow | |
| 7490 simulate_overflow = true; | |
| 7491 } | |
| 7492 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7493 if (simulate_overflow || !_mark_stack->push(obj)) { |
| 0 | 7494 if (_concurrent_precleaning) { |
|
283
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7495 // During precleaning we can just dirty the appropriate card(s) |
| 0 | 7496 // in the mod union table, thus ensuring that the object remains |
|
283
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7497 // in the grey set and continue. In the case of object arrays |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7498 // we need to dirty all of the cards that the object spans, |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7499 // since the rescan of object arrays will be limited to the |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7500 // dirty cards. |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7501 // Note that no one can be intefering with us in this action |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7502 // of dirtying the mod union table, so no locking or atomics |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7503 // are required. |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7504 if (obj->is_objArray()) { |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7505 size_t sz = obj->size(); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7506 HeapWord* end_card_addr = (HeapWord*)round_to( |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7507 (intptr_t)(addr+sz), CardTableModRefBS::card_size); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7508 MemRegion redirty_range = MemRegion(addr, end_card_addr); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7509 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7510 _mod_union_table->mark_range(redirty_range); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7511 } else { |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7512 _mod_union_table->mark(addr); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7513 } |
| 0 | 7514 _collector->_ser_pmc_preclean_ovflw++; |
| 7515 } else { | |
| 7516 // During the remark phase, we need to remember this oop | |
| 7517 // in the overflow list. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7518 _collector->push_on_overflow_list(obj); |
| 0 | 7519 _collector->_ser_pmc_remark_ovflw++; |
| 7520 } | |
| 7521 } | |
| 7522 } | |
| 7523 } | |
| 7524 | |
| 7525 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector, | |
| 7526 MemRegion span, | |
| 7527 ReferenceProcessor* rp, | |
| 7528 CMSBitMap* bit_map, | |
| 7529 OopTaskQueue* work_queue, | |
| 7530 CMSMarkStack* revisit_stack): | |
| 7531 OopClosure(rp), | |
| 7532 _collector(collector), | |
| 7533 _span(span), | |
| 7534 _bit_map(bit_map), | |
| 7535 _work_queue(work_queue), | |
| 7536 _revisit_stack(revisit_stack), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
7537 _should_remember_klasses(collector->should_unload_classes()) |
| 0 | 7538 { |
| 7539 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 7540 } | |
| 7541 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7542 void PushAndMarkClosure::do_oop(oop* p) { PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7543 void PushAndMarkClosure::do_oop(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7544 |
| 0 | 7545 // Grey object rescan during second checkpoint phase -- |
| 7546 // the parallel version. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7547 void Par_PushAndMarkClosure::do_oop(oop obj) { |
| 0 | 7548 // In the assert below, we ignore the mark word because |
| 7549 // this oop may point to an already visited object that is | |
| 7550 // on the overflow stack (in which case the mark word has | |
| 7551 // been hijacked for chaining into the overflow stack -- | |
| 7552 // if this is the last object in the overflow stack then | |
| 7553 // its mark word will be NULL). Because this object may | |
| 7554 // have been subsequently popped off the global overflow | |
| 7555 // stack, and the mark word possibly restored to the prototypical | |
| 7556 // value, by the time we get to examined this failing assert in | |
| 7557 // the debugger, is_oop_or_null(false) may subsequently start | |
| 7558 // to hold. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7559 assert(obj->is_oop_or_null(true), |
| 0 | 7560 "expected an oop or NULL"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7561 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7562 // Check if oop points into the CMS generation |
| 7563 // and is not marked | |
| 7564 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 7565 // a white object ... | |
| 7566 // If we manage to "claim" the object, by being the | |
| 7567 // first thread to mark it, then we push it on our | |
| 7568 // marking stack | |
| 7569 if (_bit_map->par_mark(addr)) { // ... now grey | |
| 7570 // push on work queue (grey set) | |
| 7571 bool simulate_overflow = false; | |
| 7572 NOT_PRODUCT( | |
| 7573 if (CMSMarkStackOverflowALot && | |
| 7574 _collector->par_simulate_overflow()) { | |
| 7575 // simulate a stack overflow | |
| 7576 simulate_overflow = true; | |
| 7577 } | |
| 7578 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7579 if (simulate_overflow || !_work_queue->push(obj)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7580 _collector->par_push_on_overflow_list(obj); |
| 0 | 7581 _collector->_par_pmc_remark_ovflw++; // imprecise OK: no need to CAS |
| 7582 } | |
| 7583 } // Else, some other thread got there first | |
| 7584 } | |
| 7585 } | |
| 7586 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7587 void Par_PushAndMarkClosure::do_oop(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7588 void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7589 |
| 0 | 7590 void PushAndMarkClosure::remember_klass(Klass* k) { |
| 7591 if (!_revisit_stack->push(oop(k))) { | |
| 7592 fatal("Revisit stack overflowed in PushAndMarkClosure"); | |
| 7593 } | |
| 7594 } | |
| 7595 | |
| 7596 void Par_PushAndMarkClosure::remember_klass(Klass* k) { | |
| 7597 if (!_revisit_stack->par_push(oop(k))) { | |
| 7598 fatal("Revist stack overflowed in Par_PushAndMarkClosure"); | |
| 7599 } | |
| 7600 } | |
| 7601 | |
| 7602 void CMSPrecleanRefsYieldClosure::do_yield_work() { | |
| 7603 Mutex* bml = _collector->bitMapLock(); | |
| 7604 assert_lock_strong(bml); | |
| 7605 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 7606 "CMS thread should hold CMS token"); | |
| 7607 | |
| 7608 bml->unlock(); | |
| 7609 ConcurrentMarkSweepThread::desynchronize(true); | |
| 7610 | |
| 7611 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7612 | |
| 7613 _collector->stopTimer(); | |
| 7614 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 7615 if (PrintCMSStatistics != 0) { | |
| 7616 _collector->incrementYields(); | |
| 7617 } | |
| 7618 _collector->icms_wait(); | |
| 7619 | |
| 7620 // See the comment in coordinator_yield() | |
| 7621 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 7622 ConcurrentMarkSweepThread::should_yield() && | |
| 7623 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 7624 os::sleep(Thread::current(), 1, false); | |
| 7625 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7626 } | |
| 7627 | |
| 7628 ConcurrentMarkSweepThread::synchronize(true); | |
| 7629 bml->lock(); | |
| 7630 | |
| 7631 _collector->startTimer(); | |
| 7632 } | |
| 7633 | |
| 7634 bool CMSPrecleanRefsYieldClosure::should_return() { | |
| 7635 if (ConcurrentMarkSweepThread::should_yield()) { | |
| 7636 do_yield_work(); | |
| 7637 } | |
| 7638 return _collector->foregroundGCIsActive(); | |
| 7639 } | |
| 7640 | |
| 7641 void MarkFromDirtyCardsClosure::do_MemRegion(MemRegion mr) { | |
| 7642 assert(((size_t)mr.start())%CardTableModRefBS::card_size_in_words == 0, | |
| 7643 "mr should be aligned to start at a card boundary"); | |
| 7644 // We'd like to assert: | |
| 7645 // assert(mr.word_size()%CardTableModRefBS::card_size_in_words == 0, | |
| 7646 // "mr should be a range of cards"); | |
| 7647 // However, that would be too strong in one case -- the last | |
| 7648 // partition ends at _unallocated_block which, in general, can be | |
| 7649 // an arbitrary boundary, not necessarily card aligned. | |
| 7650 if (PrintCMSStatistics != 0) { | |
| 7651 _num_dirty_cards += | |
| 7652 mr.word_size()/CardTableModRefBS::card_size_in_words; | |
| 7653 } | |
| 7654 _space->object_iterate_mem(mr, &_scan_cl); | |
| 7655 } | |
| 7656 | |
| 7657 SweepClosure::SweepClosure(CMSCollector* collector, | |
| 7658 ConcurrentMarkSweepGeneration* g, | |
| 7659 CMSBitMap* bitMap, bool should_yield) : | |
| 7660 _collector(collector), | |
| 7661 _g(g), | |
| 7662 _sp(g->cmsSpace()), | |
| 7663 _limit(_sp->sweep_limit()), | |
| 7664 _freelistLock(_sp->freelistLock()), | |
| 7665 _bitMap(bitMap), | |
| 7666 _yield(should_yield), | |
| 7667 _inFreeRange(false), // No free range at beginning of sweep | |
| 7668 _freeRangeInFreeLists(false), // No free range at beginning of sweep | |
| 7669 _lastFreeRangeCoalesced(false), | |
| 7670 _freeFinger(g->used_region().start()) | |
| 7671 { | |
| 7672 NOT_PRODUCT( | |
| 7673 _numObjectsFreed = 0; | |
| 7674 _numWordsFreed = 0; | |
| 7675 _numObjectsLive = 0; | |
| 7676 _numWordsLive = 0; | |
| 7677 _numObjectsAlreadyFree = 0; | |
| 7678 _numWordsAlreadyFree = 0; | |
| 7679 _last_fc = NULL; | |
| 7680 | |
| 7681 _sp->initializeIndexedFreeListArrayReturnedBytes(); | |
| 7682 _sp->dictionary()->initializeDictReturnedBytes(); | |
| 7683 ) | |
| 7684 assert(_limit >= _sp->bottom() && _limit <= _sp->end(), | |
| 7685 "sweep _limit out of bounds"); | |
| 7686 if (CMSTraceSweeper) { | |
| 7687 gclog_or_tty->print("\n====================\nStarting new sweep\n"); | |
| 7688 } | |
| 7689 } | |
| 7690 | |
| 7691 // We need this destructor to reclaim any space at the end | |
| 7692 // of the space, which do_blk below may not have added back to | |
| 7693 // the free lists. [basically dealing with the "fringe effect"] | |
| 7694 SweepClosure::~SweepClosure() { | |
| 7695 assert_lock_strong(_freelistLock); | |
| 7696 // this should be treated as the end of a free run if any | |
| 7697 // The current free range should be returned to the free lists | |
| 7698 // as one coalesced chunk. | |
| 7699 if (inFreeRange()) { | |
| 7700 flushCurFreeChunk(freeFinger(), | |
| 7701 pointer_delta(_limit, freeFinger())); | |
| 7702 assert(freeFinger() < _limit, "the finger pointeth off base"); | |
| 7703 if (CMSTraceSweeper) { | |
| 7704 gclog_or_tty->print("destructor:"); | |
| 7705 gclog_or_tty->print("Sweep:put_free_blk 0x%x ("SIZE_FORMAT") " | |
| 7706 "[coalesced:"SIZE_FORMAT"]\n", | |
| 7707 freeFinger(), pointer_delta(_limit, freeFinger()), | |
| 7708 lastFreeRangeCoalesced()); | |
| 7709 } | |
| 7710 } | |
| 7711 NOT_PRODUCT( | |
| 7712 if (Verbose && PrintGC) { | |
| 7713 gclog_or_tty->print("Collected "SIZE_FORMAT" objects, " | |
| 7714 SIZE_FORMAT " bytes", | |
| 7715 _numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); | |
| 7716 gclog_or_tty->print_cr("\nLive "SIZE_FORMAT" objects, " | |
| 7717 SIZE_FORMAT" bytes " | |
| 7718 "Already free "SIZE_FORMAT" objects, "SIZE_FORMAT" bytes", | |
| 7719 _numObjectsLive, _numWordsLive*sizeof(HeapWord), | |
| 7720 _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); | |
| 7721 size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) * | |
| 7722 sizeof(HeapWord); | |
| 7723 gclog_or_tty->print_cr("Total sweep: "SIZE_FORMAT" bytes", totalBytes); | |
| 7724 | |
| 7725 if (PrintCMSStatistics && CMSVerifyReturnedBytes) { | |
| 7726 size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); | |
| 7727 size_t dictReturnedBytes = _sp->dictionary()->sumDictReturnedBytes(); | |
| 7728 size_t returnedBytes = indexListReturnedBytes + dictReturnedBytes; | |
| 7729 gclog_or_tty->print("Returned "SIZE_FORMAT" bytes", returnedBytes); | |
| 7730 gclog_or_tty->print(" Indexed List Returned "SIZE_FORMAT" bytes", | |
| 7731 indexListReturnedBytes); | |
| 7732 gclog_or_tty->print_cr(" Dictionary Returned "SIZE_FORMAT" bytes", | |
| 7733 dictReturnedBytes); | |
| 7734 } | |
| 7735 } | |
| 7736 ) | |
| 7737 // Now, in debug mode, just null out the sweep_limit | |
| 7738 NOT_PRODUCT(_sp->clear_sweep_limit();) | |
| 7739 if (CMSTraceSweeper) { | |
| 7740 gclog_or_tty->print("end of sweep\n================\n"); | |
| 7741 } | |
| 7742 } | |
| 7743 | |
| 7744 void SweepClosure::initialize_free_range(HeapWord* freeFinger, | |
| 7745 bool freeRangeInFreeLists) { | |
| 7746 if (CMSTraceSweeper) { | |
| 7747 gclog_or_tty->print("---- Start free range 0x%x with free block [%d] (%d)\n", | |
| 7748 freeFinger, _sp->block_size(freeFinger), | |
| 7749 freeRangeInFreeLists); | |
| 7750 } | |
| 7751 assert(!inFreeRange(), "Trampling existing free range"); | |
| 7752 set_inFreeRange(true); | |
| 7753 set_lastFreeRangeCoalesced(false); | |
| 7754 | |
| 7755 set_freeFinger(freeFinger); | |
| 7756 set_freeRangeInFreeLists(freeRangeInFreeLists); | |
| 7757 if (CMSTestInFreeList) { | |
| 7758 if (freeRangeInFreeLists) { | |
| 7759 FreeChunk* fc = (FreeChunk*) freeFinger; | |
| 7760 assert(fc->isFree(), "A chunk on the free list should be free."); | |
| 7761 assert(fc->size() > 0, "Free range should have a size"); | |
| 7762 assert(_sp->verifyChunkInFreeLists(fc), "Chunk is not in free lists"); | |
| 7763 } | |
| 7764 } | |
| 7765 } | |
| 7766 | |
| 7767 // Note that the sweeper runs concurrently with mutators. Thus, | |
| 7768 // it is possible for direct allocation in this generation to happen | |
| 7769 // in the middle of the sweep. Note that the sweeper also coalesces | |
| 7770 // contiguous free blocks. Thus, unless the sweeper and the allocator | |
| 7771 // synchronize appropriately freshly allocated blocks may get swept up. | |
| 7772 // This is accomplished by the sweeper locking the free lists while | |
| 7773 // it is sweeping. Thus blocks that are determined to be free are | |
| 7774 // indeed free. There is however one additional complication: | |
| 7775 // blocks that have been allocated since the final checkpoint and | |
| 7776 // mark, will not have been marked and so would be treated as | |
| 7777 // unreachable and swept up. To prevent this, the allocator marks | |
| 7778 // the bit map when allocating during the sweep phase. This leads, | |
| 7779 // however, to a further complication -- objects may have been allocated | |
| 7780 // but not yet initialized -- in the sense that the header isn't yet | |
| 7781 // installed. The sweeper can not then determine the size of the block | |
| 7782 // in order to skip over it. To deal with this case, we use a technique | |
| 7783 // (due to Printezis) to encode such uninitialized block sizes in the | |
| 7784 // bit map. Since the bit map uses a bit per every HeapWord, but the | |
| 7785 // CMS generation has a minimum object size of 3 HeapWords, it follows | |
| 7786 // that "normal marks" won't be adjacent in the bit map (there will | |
| 7787 // always be at least two 0 bits between successive 1 bits). We make use | |
| 7788 // of these "unused" bits to represent uninitialized blocks -- the bit | |
| 7789 // corresponding to the start of the uninitialized object and the next | |
| 7790 // bit are both set. Finally, a 1 bit marks the end of the object that | |
| 7791 // started with the two consecutive 1 bits to indicate its potentially | |
| 7792 // uninitialized state. | |
| 7793 | |
| 7794 size_t SweepClosure::do_blk_careful(HeapWord* addr) { | |
| 7795 FreeChunk* fc = (FreeChunk*)addr; | |
| 7796 size_t res; | |
| 7797 | |
| 7798 // check if we are done sweepinrg | |
| 7799 if (addr == _limit) { // we have swept up to the limit, do nothing more | |
| 7800 assert(_limit >= _sp->bottom() && _limit <= _sp->end(), | |
| 7801 "sweep _limit out of bounds"); | |
| 7802 // help the closure application finish | |
| 7803 return pointer_delta(_sp->end(), _limit); | |
| 7804 } | |
| 7805 assert(addr <= _limit, "sweep invariant"); | |
| 7806 | |
| 7807 // check if we should yield | |
| 7808 do_yield_check(addr); | |
| 7809 if (fc->isFree()) { | |
| 7810 // Chunk that is already free | |
| 7811 res = fc->size(); | |
| 7812 doAlreadyFreeChunk(fc); | |
| 7813 debug_only(_sp->verifyFreeLists()); | |
| 7814 assert(res == fc->size(), "Don't expect the size to change"); | |
| 7815 NOT_PRODUCT( | |
| 7816 _numObjectsAlreadyFree++; | |
| 7817 _numWordsAlreadyFree += res; | |
| 7818 ) | |
| 7819 NOT_PRODUCT(_last_fc = fc;) | |
| 7820 } else if (!_bitMap->isMarked(addr)) { | |
| 7821 // Chunk is fresh garbage | |
| 7822 res = doGarbageChunk(fc); | |
| 7823 debug_only(_sp->verifyFreeLists()); | |
| 7824 NOT_PRODUCT( | |
| 7825 _numObjectsFreed++; | |
| 7826 _numWordsFreed += res; | |
| 7827 ) | |
| 7828 } else { | |
| 7829 // Chunk that is alive. | |
| 7830 res = doLiveChunk(fc); | |
| 7831 debug_only(_sp->verifyFreeLists()); | |
| 7832 NOT_PRODUCT( | |
| 7833 _numObjectsLive++; | |
| 7834 _numWordsLive += res; | |
| 7835 ) | |
| 7836 } | |
| 7837 return res; | |
| 7838 } | |
| 7839 | |
| 7840 // For the smart allocation, record following | |
| 7841 // split deaths - a free chunk is removed from its free list because | |
| 7842 // it is being split into two or more chunks. | |
| 7843 // split birth - a free chunk is being added to its free list because | |
| 7844 // a larger free chunk has been split and resulted in this free chunk. | |
| 7845 // coal death - a free chunk is being removed from its free list because | |
| 7846 // it is being coalesced into a large free chunk. | |
| 7847 // coal birth - a free chunk is being added to its free list because | |
| 7848 // it was created when two or more free chunks where coalesced into | |
| 7849 // this free chunk. | |
| 7850 // | |
| 7851 // These statistics are used to determine the desired number of free | |
| 7852 // chunks of a given size. The desired number is chosen to be relative | |
| 7853 // to the end of a CMS sweep. The desired number at the end of a sweep | |
| 7854 // is the | |
| 7855 // count-at-end-of-previous-sweep (an amount that was enough) | |
| 7856 // - count-at-beginning-of-current-sweep (the excess) | |
| 7857 // + split-births (gains in this size during interval) | |
| 7858 // - split-deaths (demands on this size during interval) | |
| 7859 // where the interval is from the end of one sweep to the end of the | |
| 7860 // next. | |
| 7861 // | |
| 7862 // When sweeping the sweeper maintains an accumulated chunk which is | |
| 7863 // the chunk that is made up of chunks that have been coalesced. That | |
| 7864 // will be termed the left-hand chunk. A new chunk of garbage that | |
| 7865 // is being considered for coalescing will be referred to as the | |
| 7866 // right-hand chunk. | |
| 7867 // | |
| 7868 // When making a decision on whether to coalesce a right-hand chunk with | |
| 7869 // the current left-hand chunk, the current count vs. the desired count | |
| 7870 // of the left-hand chunk is considered. Also if the right-hand chunk | |
| 7871 // is near the large chunk at the end of the heap (see | |
| 7872 // ConcurrentMarkSweepGeneration::isNearLargestChunk()), then the | |
| 7873 // left-hand chunk is coalesced. | |
| 7874 // | |
| 7875 // When making a decision about whether to split a chunk, the desired count | |
| 7876 // vs. the current count of the candidate to be split is also considered. | |
| 7877 // If the candidate is underpopulated (currently fewer chunks than desired) | |
| 7878 // a chunk of an overpopulated (currently more chunks than desired) size may | |
| 7879 // be chosen. The "hint" associated with a free list, if non-null, points | |
| 7880 // to a free list which may be overpopulated. | |
| 7881 // | |
| 7882 | |
| 7883 void SweepClosure::doAlreadyFreeChunk(FreeChunk* fc) { | |
| 7884 size_t size = fc->size(); | |
| 7885 // Chunks that cannot be coalesced are not in the | |
| 7886 // free lists. | |
| 7887 if (CMSTestInFreeList && !fc->cantCoalesce()) { | |
| 7888 assert(_sp->verifyChunkInFreeLists(fc), | |
| 7889 "free chunk should be in free lists"); | |
| 7890 } | |
| 7891 // a chunk that is already free, should not have been | |
| 7892 // marked in the bit map | |
| 7893 HeapWord* addr = (HeapWord*) fc; | |
| 7894 assert(!_bitMap->isMarked(addr), "free chunk should be unmarked"); | |
| 7895 // Verify that the bit map has no bits marked between | |
| 7896 // addr and purported end of this block. | |
| 7897 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 7898 | |
| 7899 // Some chunks cannot be coalesced in under any circumstances. | |
| 7900 // See the definition of cantCoalesce(). | |
| 7901 if (!fc->cantCoalesce()) { | |
| 7902 // This chunk can potentially be coalesced. | |
| 7903 if (_sp->adaptive_freelists()) { | |
| 7904 // All the work is done in | |
| 7905 doPostIsFreeOrGarbageChunk(fc, size); | |
| 7906 } else { // Not adaptive free lists | |
| 7907 // this is a free chunk that can potentially be coalesced by the sweeper; | |
| 7908 if (!inFreeRange()) { | |
| 7909 // if the next chunk is a free block that can't be coalesced | |
| 7910 // it doesn't make sense to remove this chunk from the free lists | |
| 7911 FreeChunk* nextChunk = (FreeChunk*)(addr + size); | |
| 7912 assert((HeapWord*)nextChunk <= _limit, "sweep invariant"); | |
| 7913 if ((HeapWord*)nextChunk < _limit && // there's a next chunk... | |
| 7914 nextChunk->isFree() && // which is free... | |
| 7915 nextChunk->cantCoalesce()) { // ... but cant be coalesced | |
| 7916 // nothing to do | |
| 7917 } else { | |
| 7918 // Potentially the start of a new free range: | |
| 7919 // Don't eagerly remove it from the free lists. | |
| 7920 // No need to remove it if it will just be put | |
| 7921 // back again. (Also from a pragmatic point of view | |
| 7922 // if it is a free block in a region that is beyond | |
| 7923 // any allocated blocks, an assertion will fail) | |
| 7924 // Remember the start of a free run. | |
| 7925 initialize_free_range(addr, true); | |
| 7926 // end - can coalesce with next chunk | |
| 7927 } | |
| 7928 } else { | |
| 7929 // the midst of a free range, we are coalescing | |
| 7930 debug_only(record_free_block_coalesced(fc);) | |
| 7931 if (CMSTraceSweeper) { | |
| 7932 gclog_or_tty->print(" -- pick up free block 0x%x (%d)\n", fc, size); | |
| 7933 } | |
| 7934 // remove it from the free lists | |
| 7935 _sp->removeFreeChunkFromFreeLists(fc); | |
| 7936 set_lastFreeRangeCoalesced(true); | |
| 7937 // If the chunk is being coalesced and the current free range is | |
| 7938 // in the free lists, remove the current free range so that it | |
| 7939 // will be returned to the free lists in its entirety - all | |
| 7940 // the coalesced pieces included. | |
| 7941 if (freeRangeInFreeLists()) { | |
| 7942 FreeChunk* ffc = (FreeChunk*) freeFinger(); | |
| 7943 assert(ffc->size() == pointer_delta(addr, freeFinger()), | |
| 7944 "Size of free range is inconsistent with chunk size."); | |
| 7945 if (CMSTestInFreeList) { | |
| 7946 assert(_sp->verifyChunkInFreeLists(ffc), | |
| 7947 "free range is not in free lists"); | |
| 7948 } | |
| 7949 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 7950 set_freeRangeInFreeLists(false); | |
| 7951 } | |
| 7952 } | |
| 7953 } | |
| 7954 } else { | |
| 7955 // Code path common to both original and adaptive free lists. | |
| 7956 | |
| 7957 // cant coalesce with previous block; this should be treated | |
| 7958 // as the end of a free run if any | |
| 7959 if (inFreeRange()) { | |
| 7960 // we kicked some butt; time to pick up the garbage | |
| 7961 assert(freeFinger() < addr, "the finger pointeth off base"); | |
| 7962 flushCurFreeChunk(freeFinger(), pointer_delta(addr, freeFinger())); | |
| 7963 } | |
| 7964 // else, nothing to do, just continue | |
| 7965 } | |
| 7966 } | |
| 7967 | |
| 7968 size_t SweepClosure::doGarbageChunk(FreeChunk* fc) { | |
| 7969 // This is a chunk of garbage. It is not in any free list. | |
| 7970 // Add it to a free list or let it possibly be coalesced into | |
| 7971 // a larger chunk. | |
| 7972 HeapWord* addr = (HeapWord*) fc; | |
| 7973 size_t size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()); | |
| 7974 | |
| 7975 if (_sp->adaptive_freelists()) { | |
| 7976 // Verify that the bit map has no bits marked between | |
| 7977 // addr and purported end of just dead object. | |
| 7978 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 7979 | |
| 7980 doPostIsFreeOrGarbageChunk(fc, size); | |
| 7981 } else { | |
| 7982 if (!inFreeRange()) { | |
| 7983 // start of a new free range | |
| 7984 assert(size > 0, "A free range should have a size"); | |
| 7985 initialize_free_range(addr, false); | |
| 7986 | |
| 7987 } else { | |
| 7988 // this will be swept up when we hit the end of the | |
| 7989 // free range | |
| 7990 if (CMSTraceSweeper) { | |
| 7991 gclog_or_tty->print(" -- pick up garbage 0x%x (%d) \n", fc, size); | |
| 7992 } | |
| 7993 // If the chunk is being coalesced and the current free range is | |
| 7994 // in the free lists, remove the current free range so that it | |
| 7995 // will be returned to the free lists in its entirety - all | |
| 7996 // the coalesced pieces included. | |
| 7997 if (freeRangeInFreeLists()) { | |
| 7998 FreeChunk* ffc = (FreeChunk*)freeFinger(); | |
| 7999 assert(ffc->size() == pointer_delta(addr, freeFinger()), | |
| 8000 "Size of free range is inconsistent with chunk size."); | |
| 8001 if (CMSTestInFreeList) { | |
| 8002 assert(_sp->verifyChunkInFreeLists(ffc), | |
| 8003 "free range is not in free lists"); | |
| 8004 } | |
| 8005 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 8006 set_freeRangeInFreeLists(false); | |
| 8007 } | |
| 8008 set_lastFreeRangeCoalesced(true); | |
| 8009 } | |
| 8010 // this will be swept up when we hit the end of the free range | |
| 8011 | |
| 8012 // Verify that the bit map has no bits marked between | |
| 8013 // addr and purported end of just dead object. | |
| 8014 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 8015 } | |
| 8016 return size; | |
| 8017 } | |
| 8018 | |
| 8019 size_t SweepClosure::doLiveChunk(FreeChunk* fc) { | |
| 8020 HeapWord* addr = (HeapWord*) fc; | |
| 8021 // The sweeper has just found a live object. Return any accumulated | |
| 8022 // left hand chunk to the free lists. | |
| 8023 if (inFreeRange()) { | |
| 8024 if (_sp->adaptive_freelists()) { | |
| 8025 flushCurFreeChunk(freeFinger(), | |
| 8026 pointer_delta(addr, freeFinger())); | |
| 8027 } else { // not adaptive freelists | |
| 8028 set_inFreeRange(false); | |
| 8029 // Add the free range back to the free list if it is not already | |
| 8030 // there. | |
| 8031 if (!freeRangeInFreeLists()) { | |
| 8032 assert(freeFinger() < addr, "the finger pointeth off base"); | |
| 8033 if (CMSTraceSweeper) { | |
| 8034 gclog_or_tty->print("Sweep:put_free_blk 0x%x (%d) " | |
| 8035 "[coalesced:%d]\n", | |
| 8036 freeFinger(), pointer_delta(addr, freeFinger()), | |
| 8037 lastFreeRangeCoalesced()); | |
| 8038 } | |
| 8039 _sp->addChunkAndRepairOffsetTable(freeFinger(), | |
| 8040 pointer_delta(addr, freeFinger()), lastFreeRangeCoalesced()); | |
| 8041 } | |
| 8042 } | |
| 8043 } | |
| 8044 | |
| 8045 // Common code path for original and adaptive free lists. | |
| 8046 | |
| 8047 // this object is live: we'd normally expect this to be | |
| 8048 // an oop, and like to assert the following: | |
| 8049 // assert(oop(addr)->is_oop(), "live block should be an oop"); | |
| 8050 // However, as we commented above, this may be an object whose | |
| 8051 // header hasn't yet been initialized. | |
| 8052 size_t size; | |
| 8053 assert(_bitMap->isMarked(addr), "Tautology for this control point"); | |
| 8054 if (_bitMap->isMarked(addr + 1)) { | |
| 8055 // Determine the size from the bit map, rather than trying to | |
| 8056 // compute it from the object header. | |
| 8057 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2); | |
| 8058 size = pointer_delta(nextOneAddr + 1, addr); | |
| 8059 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 8060 "alignment problem"); | |
| 8061 | |
| 8062 #ifdef DEBUG | |
| 187 | 8063 if (oop(addr)->klass_or_null() != NULL && |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
8064 ( !_collector->should_unload_classes() |
| 0 | 8065 || oop(addr)->is_parsable())) { |
| 8066 // Ignore mark word because we are running concurrent with mutators | |
| 8067 assert(oop(addr)->is_oop(true), "live block should be an oop"); | |
| 8068 assert(size == | |
| 8069 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()), | |
| 8070 "P-mark and computed size do not agree"); | |
| 8071 } | |
| 8072 #endif | |
| 8073 | |
| 8074 } else { | |
| 8075 // This should be an initialized object that's alive. | |
| 187 | 8076 assert(oop(addr)->klass_or_null() != NULL && |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
8077 (!_collector->should_unload_classes() |
| 0 | 8078 || oop(addr)->is_parsable()), |
| 8079 "Should be an initialized object"); | |
| 8080 // Ignore mark word because we are running concurrent with mutators | |
| 8081 assert(oop(addr)->is_oop(true), "live block should be an oop"); | |
| 8082 // Verify that the bit map has no bits marked between | |
| 8083 // addr and purported end of this block. | |
| 8084 size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()); | |
| 8085 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 8086 assert(!_bitMap->isMarked(addr+1), "Tautology for this control point"); | |
| 8087 DEBUG_ONLY(_bitMap->verifyNoOneBitsInRange(addr+2, addr+size);) | |
| 8088 } | |
| 8089 return size; | |
| 8090 } | |
| 8091 | |
| 8092 void SweepClosure::doPostIsFreeOrGarbageChunk(FreeChunk* fc, | |
| 8093 size_t chunkSize) { | |
| 8094 // doPostIsFreeOrGarbageChunk() should only be called in the smart allocation | |
| 8095 // scheme. | |
| 8096 bool fcInFreeLists = fc->isFree(); | |
| 8097 assert(_sp->adaptive_freelists(), "Should only be used in this case."); | |
| 8098 assert((HeapWord*)fc <= _limit, "sweep invariant"); | |
| 8099 if (CMSTestInFreeList && fcInFreeLists) { | |
| 8100 assert(_sp->verifyChunkInFreeLists(fc), | |
| 8101 "free chunk is not in free lists"); | |
| 8102 } | |
| 8103 | |
| 8104 | |
| 8105 if (CMSTraceSweeper) { | |
| 8106 gclog_or_tty->print_cr(" -- pick up another chunk at 0x%x (%d)", fc, chunkSize); | |
| 8107 } | |
| 8108 | |
| 8109 HeapWord* addr = (HeapWord*) fc; | |
| 8110 | |
| 8111 bool coalesce; | |
| 8112 size_t left = pointer_delta(addr, freeFinger()); | |
| 8113 size_t right = chunkSize; | |
| 8114 switch (FLSCoalescePolicy) { | |
| 8115 // numeric value forms a coalition aggressiveness metric | |
| 8116 case 0: { // never coalesce | |
| 8117 coalesce = false; | |
| 8118 break; | |
| 8119 } | |
| 8120 case 1: { // coalesce if left & right chunks on overpopulated lists | |
| 8121 coalesce = _sp->coalOverPopulated(left) && | |
| 8122 _sp->coalOverPopulated(right); | |
| 8123 break; | |
| 8124 } | |
| 8125 case 2: { // coalesce if left chunk on overpopulated list (default) | |
| 8126 coalesce = _sp->coalOverPopulated(left); | |
| 8127 break; | |
| 8128 } | |
| 8129 case 3: { // coalesce if left OR right chunk on overpopulated list | |
| 8130 coalesce = _sp->coalOverPopulated(left) || | |
| 8131 _sp->coalOverPopulated(right); | |
| 8132 break; | |
| 8133 } | |
| 8134 case 4: { // always coalesce | |
| 8135 coalesce = true; | |
| 8136 break; | |
| 8137 } | |
| 8138 default: | |
| 8139 ShouldNotReachHere(); | |
| 8140 } | |
| 8141 | |
| 8142 // Should the current free range be coalesced? | |
| 8143 // If the chunk is in a free range and either we decided to coalesce above | |
| 8144 // or the chunk is near the large block at the end of the heap | |
| 8145 // (isNearLargestChunk() returns true), then coalesce this chunk. | |
| 8146 bool doCoalesce = inFreeRange() && | |
| 8147 (coalesce || _g->isNearLargestChunk((HeapWord*)fc)); | |
| 8148 if (doCoalesce) { | |
| 8149 // Coalesce the current free range on the left with the new | |
| 8150 // chunk on the right. If either is on a free list, | |
| 8151 // it must be removed from the list and stashed in the closure. | |
| 8152 if (freeRangeInFreeLists()) { | |
| 8153 FreeChunk* ffc = (FreeChunk*)freeFinger(); | |
| 8154 assert(ffc->size() == pointer_delta(addr, freeFinger()), | |
| 8155 "Size of free range is inconsistent with chunk size."); | |
| 8156 if (CMSTestInFreeList) { | |
| 8157 assert(_sp->verifyChunkInFreeLists(ffc), | |
| 8158 "Chunk is not in free lists"); | |
| 8159 } | |
| 8160 _sp->coalDeath(ffc->size()); | |
| 8161 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 8162 set_freeRangeInFreeLists(false); | |
| 8163 } | |
| 8164 if (fcInFreeLists) { | |
| 8165 _sp->coalDeath(chunkSize); | |
| 8166 assert(fc->size() == chunkSize, | |
| 8167 "The chunk has the wrong size or is not in the free lists"); | |
| 8168 _sp->removeFreeChunkFromFreeLists(fc); | |
| 8169 } | |
| 8170 set_lastFreeRangeCoalesced(true); | |
| 8171 } else { // not in a free range and/or should not coalesce | |
| 8172 // Return the current free range and start a new one. | |
| 8173 if (inFreeRange()) { | |
| 8174 // In a free range but cannot coalesce with the right hand chunk. | |
| 8175 // Put the current free range into the free lists. | |
| 8176 flushCurFreeChunk(freeFinger(), | |
| 8177 pointer_delta(addr, freeFinger())); | |
| 8178 } | |
| 8179 // Set up for new free range. Pass along whether the right hand | |
| 8180 // chunk is in the free lists. | |
| 8181 initialize_free_range((HeapWord*)fc, fcInFreeLists); | |
| 8182 } | |
| 8183 } | |
| 8184 void SweepClosure::flushCurFreeChunk(HeapWord* chunk, size_t size) { | |
| 8185 assert(inFreeRange(), "Should only be called if currently in a free range."); | |
| 8186 assert(size > 0, | |
| 8187 "A zero sized chunk cannot be added to the free lists."); | |
| 8188 if (!freeRangeInFreeLists()) { | |
| 8189 if(CMSTestInFreeList) { | |
| 8190 FreeChunk* fc = (FreeChunk*) chunk; | |
| 8191 fc->setSize(size); | |
| 8192 assert(!_sp->verifyChunkInFreeLists(fc), | |
| 8193 "chunk should not be in free lists yet"); | |
| 8194 } | |
| 8195 if (CMSTraceSweeper) { | |
| 8196 gclog_or_tty->print_cr(" -- add free block 0x%x (%d) to free lists", | |
| 8197 chunk, size); | |
| 8198 } | |
| 8199 // A new free range is going to be starting. The current | |
| 8200 // free range has not been added to the free lists yet or | |
| 8201 // was removed so add it back. | |
| 8202 // If the current free range was coalesced, then the death | |
| 8203 // of the free range was recorded. Record a birth now. | |
| 8204 if (lastFreeRangeCoalesced()) { | |
| 8205 _sp->coalBirth(size); | |
| 8206 } | |
| 8207 _sp->addChunkAndRepairOffsetTable(chunk, size, | |
| 8208 lastFreeRangeCoalesced()); | |
| 8209 } | |
| 8210 set_inFreeRange(false); | |
| 8211 set_freeRangeInFreeLists(false); | |
| 8212 } | |
| 8213 | |
| 8214 // We take a break if we've been at this for a while, | |
| 8215 // so as to avoid monopolizing the locks involved. | |
| 8216 void SweepClosure::do_yield_work(HeapWord* addr) { | |
| 8217 // Return current free chunk being used for coalescing (if any) | |
| 8218 // to the appropriate freelist. After yielding, the next | |
| 8219 // free block encountered will start a coalescing range of | |
| 8220 // free blocks. If the next free block is adjacent to the | |
| 8221 // chunk just flushed, they will need to wait for the next | |
| 8222 // sweep to be coalesced. | |
| 8223 if (inFreeRange()) { | |
| 8224 flushCurFreeChunk(freeFinger(), pointer_delta(addr, freeFinger())); | |
| 8225 } | |
| 8226 | |
| 8227 // First give up the locks, then yield, then re-lock. | |
| 8228 // We should probably use a constructor/destructor idiom to | |
| 8229 // do this unlock/lock or modify the MutexUnlocker class to | |
| 8230 // serve our purpose. XXX | |
| 8231 assert_lock_strong(_bitMap->lock()); | |
| 8232 assert_lock_strong(_freelistLock); | |
| 8233 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 8234 "CMS thread should hold CMS token"); | |
| 8235 _bitMap->lock()->unlock(); | |
| 8236 _freelistLock->unlock(); | |
| 8237 ConcurrentMarkSweepThread::desynchronize(true); | |
| 8238 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 8239 _collector->stopTimer(); | |
| 8240 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 8241 if (PrintCMSStatistics != 0) { | |
| 8242 _collector->incrementYields(); | |
| 8243 } | |
| 8244 _collector->icms_wait(); | |
| 8245 | |
| 8246 // See the comment in coordinator_yield() | |
| 8247 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 8248 ConcurrentMarkSweepThread::should_yield() && | |
| 8249 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 8250 os::sleep(Thread::current(), 1, false); | |
| 8251 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 8252 } | |
| 8253 | |
| 8254 ConcurrentMarkSweepThread::synchronize(true); | |
| 8255 _freelistLock->lock(); | |
| 8256 _bitMap->lock()->lock_without_safepoint_check(); | |
| 8257 _collector->startTimer(); | |
| 8258 } | |
| 8259 | |
| 8260 #ifndef PRODUCT | |
| 8261 // This is actually very useful in a product build if it can | |
| 8262 // be called from the debugger. Compile it into the product | |
| 8263 // as needed. | |
| 8264 bool debug_verifyChunkInFreeLists(FreeChunk* fc) { | |
| 8265 return debug_cms_space->verifyChunkInFreeLists(fc); | |
| 8266 } | |
| 8267 | |
| 8268 void SweepClosure::record_free_block_coalesced(FreeChunk* fc) const { | |
| 8269 if (CMSTraceSweeper) { | |
| 8270 gclog_or_tty->print("Sweep:coal_free_blk 0x%x (%d)\n", fc, fc->size()); | |
| 8271 } | |
| 8272 } | |
| 8273 #endif | |
| 8274 | |
| 8275 // CMSIsAliveClosure | |
| 8276 bool CMSIsAliveClosure::do_object_b(oop obj) { | |
| 8277 HeapWord* addr = (HeapWord*)obj; | |
| 8278 return addr != NULL && | |
| 8279 (!_span.contains(addr) || _bit_map->isMarked(addr)); | |
| 8280 } | |
| 8281 | |
| 8282 // CMSKeepAliveClosure: the serial version | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8283 void CMSKeepAliveClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8284 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8285 if (_span.contains(addr) && |
| 8286 !_bit_map->isMarked(addr)) { | |
| 8287 _bit_map->mark(addr); | |
| 8288 bool simulate_overflow = false; | |
| 8289 NOT_PRODUCT( | |
| 8290 if (CMSMarkStackOverflowALot && | |
| 8291 _collector->simulate_overflow()) { | |
| 8292 // simulate a stack overflow | |
| 8293 simulate_overflow = true; | |
| 8294 } | |
| 8295 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8296 if (simulate_overflow || !_mark_stack->push(obj)) { |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8297 if (_concurrent_precleaning) { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8298 // We dirty the overflown object and let the remark |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8299 // phase deal with it. |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8300 assert(_collector->overflow_list_is_empty(), "Error"); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8301 // In the case of object arrays, we need to dirty all of |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8302 // the cards that the object spans. No locking or atomics |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8303 // are needed since no one else can be mutating the mod union |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8304 // table. |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8305 if (obj->is_objArray()) { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8306 size_t sz = obj->size(); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8307 HeapWord* end_card_addr = |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8308 (HeapWord*)round_to((intptr_t)(addr+sz), CardTableModRefBS::card_size); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8309 MemRegion redirty_range = MemRegion(addr, end_card_addr); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8310 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8311 _collector->_modUnionTable.mark_range(redirty_range); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8312 } else { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8313 _collector->_modUnionTable.mark(addr); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8314 } |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8315 _collector->_ser_kac_preclean_ovflw++; |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8316 } else { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8317 _collector->push_on_overflow_list(obj); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8318 _collector->_ser_kac_ovflw++; |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8319 } |
| 0 | 8320 } |
| 8321 } | |
| 8322 } | |
| 8323 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8324 void CMSKeepAliveClosure::do_oop(oop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8325 void CMSKeepAliveClosure::do_oop(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8326 |
| 0 | 8327 // CMSParKeepAliveClosure: a parallel version of the above. |
| 8328 // The work queues are private to each closure (thread), | |
| 8329 // but (may be) available for stealing by other threads. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8330 void CMSParKeepAliveClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8331 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8332 if (_span.contains(addr) && |
| 8333 !_bit_map->isMarked(addr)) { | |
| 8334 // In general, during recursive tracing, several threads | |
| 8335 // may be concurrently getting here; the first one to | |
| 8336 // "tag" it, claims it. | |
| 8337 if (_bit_map->par_mark(addr)) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8338 bool res = _work_queue->push(obj); |
| 0 | 8339 assert(res, "Low water mark should be much less than capacity"); |
| 8340 // Do a recursive trim in the hope that this will keep | |
| 8341 // stack usage lower, but leave some oops for potential stealers | |
| 8342 trim_queue(_low_water_mark); | |
| 8343 } // Else, another thread got there first | |
| 8344 } | |
| 8345 } | |
| 8346 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8347 void CMSParKeepAliveClosure::do_oop(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8348 void CMSParKeepAliveClosure::do_oop(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8349 |
| 0 | 8350 void CMSParKeepAliveClosure::trim_queue(uint max) { |
| 8351 while (_work_queue->size() > max) { | |
| 8352 oop new_oop; | |
| 8353 if (_work_queue->pop_local(new_oop)) { | |
| 8354 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 8355 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 8356 "no white objects on this stack!"); | |
| 8357 assert(_span.contains((HeapWord*)new_oop), "Out of bounds oop"); | |
| 8358 // iterate over the oops in this oop, marking and pushing | |
| 8359 // the ones in CMS heap (i.e. in _span). | |
| 8360 new_oop->oop_iterate(&_mark_and_push); | |
| 8361 } | |
| 8362 } | |
| 8363 } | |
| 8364 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8365 void CMSInnerParMarkAndPushClosure::do_oop(oop obj) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8366 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8367 if (_span.contains(addr) && |
| 8368 !_bit_map->isMarked(addr)) { | |
| 8369 if (_bit_map->par_mark(addr)) { | |
| 8370 bool simulate_overflow = false; | |
| 8371 NOT_PRODUCT( | |
| 8372 if (CMSMarkStackOverflowALot && | |
| 8373 _collector->par_simulate_overflow()) { | |
| 8374 // simulate a stack overflow | |
| 8375 simulate_overflow = true; | |
| 8376 } | |
| 8377 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8378 if (simulate_overflow || !_work_queue->push(obj)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8379 _collector->par_push_on_overflow_list(obj); |
| 0 | 8380 _collector->_par_kac_ovflw++; |
| 8381 } | |
| 8382 } // Else another thread got there already | |
| 8383 } | |
| 8384 } | |
| 8385 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8386 void CMSInnerParMarkAndPushClosure::do_oop(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8387 void CMSInnerParMarkAndPushClosure::do_oop(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8388 |
| 0 | 8389 ////////////////////////////////////////////////////////////////// |
| 8390 // CMSExpansionCause ///////////////////////////// | |
| 8391 ////////////////////////////////////////////////////////////////// | |
| 8392 const char* CMSExpansionCause::to_string(CMSExpansionCause::Cause cause) { | |
| 8393 switch (cause) { | |
| 8394 case _no_expansion: | |
| 8395 return "No expansion"; | |
| 8396 case _satisfy_free_ratio: | |
| 8397 return "Free ratio"; | |
| 8398 case _satisfy_promotion: | |
| 8399 return "Satisfy promotion"; | |
| 8400 case _satisfy_allocation: | |
| 8401 return "allocation"; | |
| 8402 case _allocate_par_lab: | |
| 8403 return "Par LAB"; | |
| 8404 case _allocate_par_spooling_space: | |
| 8405 return "Par Spooling Space"; | |
| 8406 case _adaptive_size_policy: | |
| 8407 return "Ergonomics"; | |
| 8408 default: | |
| 8409 return "unknown"; | |
| 8410 } | |
| 8411 } | |
| 8412 | |
| 8413 void CMSDrainMarkingStackClosure::do_void() { | |
| 8414 // the max number to take from overflow list at a time | |
| 8415 const size_t num = _mark_stack->capacity()/4; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8416 assert(!_concurrent_precleaning || _collector->overflow_list_is_empty(), |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8417 "Overflow list should be NULL during concurrent phases"); |
| 0 | 8418 while (!_mark_stack->isEmpty() || |
| 8419 // if stack is empty, check the overflow list | |
| 8420 _collector->take_from_overflow_list(num, _mark_stack)) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8421 oop obj = _mark_stack->pop(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8422 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8423 assert(_span.contains(addr), "Should be within span"); |
| 8424 assert(_bit_map->isMarked(addr), "Should be marked"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8425 assert(obj->is_oop(), "Should be an oop"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8426 obj->oop_iterate(_keep_alive); |
| 0 | 8427 } |
| 8428 } | |
| 8429 | |
| 8430 void CMSParDrainMarkingStackClosure::do_void() { | |
| 8431 // drain queue | |
| 8432 trim_queue(0); | |
| 8433 } | |
| 8434 | |
| 8435 // Trim our work_queue so its length is below max at return | |
| 8436 void CMSParDrainMarkingStackClosure::trim_queue(uint max) { | |
| 8437 while (_work_queue->size() > max) { | |
| 8438 oop new_oop; | |
| 8439 if (_work_queue->pop_local(new_oop)) { | |
| 8440 assert(new_oop->is_oop(), "Expected an oop"); | |
| 8441 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 8442 "no white objects on this stack!"); | |
| 8443 assert(_span.contains((HeapWord*)new_oop), "Out of bounds oop"); | |
| 8444 // iterate over the oops in this oop, marking and pushing | |
| 8445 // the ones in CMS heap (i.e. in _span). | |
| 8446 new_oop->oop_iterate(&_mark_and_push); | |
| 8447 } | |
| 8448 } | |
| 8449 } | |
| 8450 | |
| 8451 //////////////////////////////////////////////////////////////////// | |
| 8452 // Support for Marking Stack Overflow list handling and related code | |
| 8453 //////////////////////////////////////////////////////////////////// | |
| 8454 // Much of the following code is similar in shape and spirit to the | |
| 8455 // code used in ParNewGC. We should try and share that code | |
| 8456 // as much as possible in the future. | |
| 8457 | |
| 8458 #ifndef PRODUCT | |
| 8459 // Debugging support for CMSStackOverflowALot | |
| 8460 | |
| 8461 // It's OK to call this multi-threaded; the worst thing | |
| 8462 // that can happen is that we'll get a bunch of closely | |
| 8463 // spaced simulated oveflows, but that's OK, in fact | |
| 8464 // probably good as it would exercise the overflow code | |
| 8465 // under contention. | |
| 8466 bool CMSCollector::simulate_overflow() { | |
| 8467 if (_overflow_counter-- <= 0) { // just being defensive | |
| 8468 _overflow_counter = CMSMarkStackOverflowInterval; | |
| 8469 return true; | |
| 8470 } else { | |
| 8471 return false; | |
| 8472 } | |
| 8473 } | |
| 8474 | |
| 8475 bool CMSCollector::par_simulate_overflow() { | |
| 8476 return simulate_overflow(); | |
| 8477 } | |
| 8478 #endif | |
| 8479 | |
| 8480 // Single-threaded | |
| 8481 bool CMSCollector::take_from_overflow_list(size_t num, CMSMarkStack* stack) { | |
| 8482 assert(stack->isEmpty(), "Expected precondition"); | |
| 8483 assert(stack->capacity() > num, "Shouldn't bite more than can chew"); | |
| 8484 size_t i = num; | |
| 8485 oop cur = _overflow_list; | |
| 8486 const markOop proto = markOopDesc::prototype(); | |
| 8487 NOT_PRODUCT(size_t n = 0;) | |
| 8488 for (oop next; i > 0 && cur != NULL; cur = next, i--) { | |
| 8489 next = oop(cur->mark()); | |
| 8490 cur->set_mark(proto); // until proven otherwise | |
| 8491 assert(cur->is_oop(), "Should be an oop"); | |
| 8492 bool res = stack->push(cur); | |
| 8493 assert(res, "Bit off more than can chew?"); | |
| 8494 NOT_PRODUCT(n++;) | |
| 8495 } | |
| 8496 _overflow_list = cur; | |
| 8497 #ifndef PRODUCT | |
| 8498 assert(_num_par_pushes >= n, "Too many pops?"); | |
| 8499 _num_par_pushes -=n; | |
| 8500 #endif | |
| 8501 return !stack->isEmpty(); | |
| 8502 } | |
| 8503 | |
| 8504 // Multi-threaded; use CAS to break off a prefix | |
| 8505 bool CMSCollector::par_take_from_overflow_list(size_t num, | |
| 8506 OopTaskQueue* work_q) { | |
| 8507 assert(work_q->size() == 0, "That's the current policy"); | |
| 8508 assert(num < work_q->max_elems(), "Can't bite more than we can chew"); | |
| 8509 if (_overflow_list == NULL) { | |
| 8510 return false; | |
| 8511 } | |
| 8512 // Grab the entire list; we'll put back a suffix | |
| 8513 oop prefix = (oop)Atomic::xchg_ptr(NULL, &_overflow_list); | |
| 8514 if (prefix == NULL) { // someone grabbed it before we did ... | |
| 8515 // ... we could spin for a short while, but for now we don't | |
| 8516 return false; | |
| 8517 } | |
| 8518 size_t i = num; | |
| 8519 oop cur = prefix; | |
| 8520 for (; i > 1 && cur->mark() != NULL; cur = oop(cur->mark()), i--); | |
| 8521 if (cur->mark() != NULL) { | |
| 8522 oop suffix_head = cur->mark(); // suffix will be put back on global list | |
| 8523 cur->set_mark(NULL); // break off suffix | |
| 8524 // Find tail of suffix so we can prepend suffix to global list | |
| 8525 for (cur = suffix_head; cur->mark() != NULL; cur = (oop)(cur->mark())); | |
| 8526 oop suffix_tail = cur; | |
| 8527 assert(suffix_tail != NULL && suffix_tail->mark() == NULL, | |
| 8528 "Tautology"); | |
| 8529 oop observed_overflow_list = _overflow_list; | |
| 8530 do { | |
| 8531 cur = observed_overflow_list; | |
| 8532 suffix_tail->set_mark(markOop(cur)); | |
| 8533 observed_overflow_list = | |
| 8534 (oop) Atomic::cmpxchg_ptr(suffix_head, &_overflow_list, cur); | |
| 8535 } while (cur != observed_overflow_list); | |
| 8536 } | |
| 8537 | |
| 8538 // Push the prefix elements on work_q | |
| 8539 assert(prefix != NULL, "control point invariant"); | |
| 8540 const markOop proto = markOopDesc::prototype(); | |
| 8541 oop next; | |
| 8542 NOT_PRODUCT(size_t n = 0;) | |
| 8543 for (cur = prefix; cur != NULL; cur = next) { | |
| 8544 next = oop(cur->mark()); | |
| 8545 cur->set_mark(proto); // until proven otherwise | |
| 8546 assert(cur->is_oop(), "Should be an oop"); | |
| 8547 bool res = work_q->push(cur); | |
| 8548 assert(res, "Bit off more than we can chew?"); | |
| 8549 NOT_PRODUCT(n++;) | |
| 8550 } | |
| 8551 #ifndef PRODUCT | |
| 8552 assert(_num_par_pushes >= n, "Too many pops?"); | |
| 8553 Atomic::add_ptr(-(intptr_t)n, &_num_par_pushes); | |
| 8554 #endif | |
| 8555 return true; | |
| 8556 } | |
| 8557 | |
| 8558 // Single-threaded | |
| 8559 void CMSCollector::push_on_overflow_list(oop p) { | |
| 8560 NOT_PRODUCT(_num_par_pushes++;) | |
| 8561 assert(p->is_oop(), "Not an oop"); | |
| 8562 preserve_mark_if_necessary(p); | |
| 8563 p->set_mark((markOop)_overflow_list); | |
| 8564 _overflow_list = p; | |
| 8565 } | |
| 8566 | |
| 8567 // Multi-threaded; use CAS to prepend to overflow list | |
| 8568 void CMSCollector::par_push_on_overflow_list(oop p) { | |
| 8569 NOT_PRODUCT(Atomic::inc_ptr(&_num_par_pushes);) | |
| 8570 assert(p->is_oop(), "Not an oop"); | |
| 8571 par_preserve_mark_if_necessary(p); | |
| 8572 oop observed_overflow_list = _overflow_list; | |
| 8573 oop cur_overflow_list; | |
| 8574 do { | |
| 8575 cur_overflow_list = observed_overflow_list; | |
| 8576 p->set_mark(markOop(cur_overflow_list)); | |
| 8577 observed_overflow_list = | |
| 8578 (oop) Atomic::cmpxchg_ptr(p, &_overflow_list, cur_overflow_list); | |
| 8579 } while (cur_overflow_list != observed_overflow_list); | |
| 8580 } | |
| 8581 | |
| 8582 // Single threaded | |
| 8583 // General Note on GrowableArray: pushes may silently fail | |
| 8584 // because we are (temporarily) out of C-heap for expanding | |
| 8585 // the stack. The problem is quite ubiquitous and affects | |
| 8586 // a lot of code in the JVM. The prudent thing for GrowableArray | |
| 8587 // to do (for now) is to exit with an error. However, that may | |
| 8588 // be too draconian in some cases because the caller may be | |
| 8589 // able to recover without much harm. For suych cases, we | |
| 8590 // should probably introduce a "soft_push" method which returns | |
| 8591 // an indication of success or failure with the assumption that | |
| 8592 // the caller may be able to recover from a failure; code in | |
| 8593 // the VM can then be changed, incrementally, to deal with such | |
| 8594 // failures where possible, thus, incrementally hardening the VM | |
| 8595 // in such low resource situations. | |
| 8596 void CMSCollector::preserve_mark_work(oop p, markOop m) { | |
| 8597 int PreserveMarkStackSize = 128; | |
| 8598 | |
| 8599 if (_preserved_oop_stack == NULL) { | |
| 8600 assert(_preserved_mark_stack == NULL, | |
| 8601 "bijection with preserved_oop_stack"); | |
| 8602 // Allocate the stacks | |
| 8603 _preserved_oop_stack = new (ResourceObj::C_HEAP) | |
| 8604 GrowableArray<oop>(PreserveMarkStackSize, true); | |
| 8605 _preserved_mark_stack = new (ResourceObj::C_HEAP) | |
| 8606 GrowableArray<markOop>(PreserveMarkStackSize, true); | |
| 8607 if (_preserved_oop_stack == NULL || _preserved_mark_stack == NULL) { | |
| 8608 vm_exit_out_of_memory(2* PreserveMarkStackSize * sizeof(oop) /* punt */, | |
| 8609 "Preserved Mark/Oop Stack for CMS (C-heap)"); | |
| 8610 } | |
| 8611 } | |
| 8612 _preserved_oop_stack->push(p); | |
| 8613 _preserved_mark_stack->push(m); | |
| 8614 assert(m == p->mark(), "Mark word changed"); | |
| 8615 assert(_preserved_oop_stack->length() == _preserved_mark_stack->length(), | |
| 8616 "bijection"); | |
| 8617 } | |
| 8618 | |
| 8619 // Single threaded | |
| 8620 void CMSCollector::preserve_mark_if_necessary(oop p) { | |
| 8621 markOop m = p->mark(); | |
| 8622 if (m->must_be_preserved(p)) { | |
| 8623 preserve_mark_work(p, m); | |
| 8624 } | |
| 8625 } | |
| 8626 | |
| 8627 void CMSCollector::par_preserve_mark_if_necessary(oop p) { | |
| 8628 markOop m = p->mark(); | |
| 8629 if (m->must_be_preserved(p)) { | |
| 8630 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); | |
| 8631 // Even though we read the mark word without holding | |
| 8632 // the lock, we are assured that it will not change | |
| 8633 // because we "own" this oop, so no other thread can | |
| 8634 // be trying to push it on the overflow list; see | |
| 8635 // the assertion in preserve_mark_work() that checks | |
| 8636 // that m == p->mark(). | |
| 8637 preserve_mark_work(p, m); | |
| 8638 } | |
| 8639 } | |
| 8640 | |
| 8641 // We should be able to do this multi-threaded, | |
| 8642 // a chunk of stack being a task (this is | |
| 8643 // correct because each oop only ever appears | |
| 8644 // once in the overflow list. However, it's | |
| 8645 // not very easy to completely overlap this with | |
| 8646 // other operations, so will generally not be done | |
| 8647 // until all work's been completed. Because we | |
| 8648 // expect the preserved oop stack (set) to be small, | |
| 8649 // it's probably fine to do this single-threaded. | |
| 8650 // We can explore cleverer concurrent/overlapped/parallel | |
| 8651 // processing of preserved marks if we feel the | |
| 8652 // need for this in the future. Stack overflow should | |
| 8653 // be so rare in practice and, when it happens, its | |
| 8654 // effect on performance so great that this will | |
| 8655 // likely just be in the noise anyway. | |
| 8656 void CMSCollector::restore_preserved_marks_if_any() { | |
| 8657 if (_preserved_oop_stack == NULL) { | |
| 8658 assert(_preserved_mark_stack == NULL, | |
| 8659 "bijection with preserved_oop_stack"); | |
| 8660 return; | |
| 8661 } | |
| 8662 | |
| 8663 assert(SafepointSynchronize::is_at_safepoint(), | |
| 8664 "world should be stopped"); | |
| 8665 assert(Thread::current()->is_ConcurrentGC_thread() || | |
| 8666 Thread::current()->is_VM_thread(), | |
| 8667 "should be single-threaded"); | |
| 8668 | |
| 8669 int length = _preserved_oop_stack->length(); | |
| 8670 assert(_preserved_mark_stack->length() == length, "bijection"); | |
| 8671 for (int i = 0; i < length; i++) { | |
| 8672 oop p = _preserved_oop_stack->at(i); | |
| 8673 assert(p->is_oop(), "Should be an oop"); | |
| 8674 assert(_span.contains(p), "oop should be in _span"); | |
| 8675 assert(p->mark() == markOopDesc::prototype(), | |
| 8676 "Set when taken from overflow list"); | |
| 8677 markOop m = _preserved_mark_stack->at(i); | |
| 8678 p->set_mark(m); | |
| 8679 } | |
| 8680 _preserved_mark_stack->clear(); | |
| 8681 _preserved_oop_stack->clear(); | |
| 8682 assert(_preserved_mark_stack->is_empty() && | |
| 8683 _preserved_oop_stack->is_empty(), | |
| 8684 "stacks were cleared above"); | |
| 8685 } | |
| 8686 | |
| 8687 #ifndef PRODUCT | |
| 8688 bool CMSCollector::no_preserved_marks() const { | |
| 8689 return ( ( _preserved_mark_stack == NULL | |
| 8690 && _preserved_oop_stack == NULL) | |
| 8691 || ( _preserved_mark_stack->is_empty() | |
| 8692 && _preserved_oop_stack->is_empty())); | |
| 8693 } | |
| 8694 #endif | |
| 8695 | |
| 8696 CMSAdaptiveSizePolicy* ASConcurrentMarkSweepGeneration::cms_size_policy() const | |
| 8697 { | |
| 8698 GenCollectedHeap* gch = (GenCollectedHeap*) GenCollectedHeap::heap(); | |
| 8699 CMSAdaptiveSizePolicy* size_policy = | |
| 8700 (CMSAdaptiveSizePolicy*) gch->gen_policy()->size_policy(); | |
| 8701 assert(size_policy->is_gc_cms_adaptive_size_policy(), | |
| 8702 "Wrong type for size policy"); | |
| 8703 return size_policy; | |
| 8704 } | |
| 8705 | |
| 8706 void ASConcurrentMarkSweepGeneration::resize(size_t cur_promo_size, | |
| 8707 size_t desired_promo_size) { | |
| 8708 if (cur_promo_size < desired_promo_size) { | |
| 8709 size_t expand_bytes = desired_promo_size - cur_promo_size; | |
| 8710 if (PrintAdaptiveSizePolicy && Verbose) { | |
| 8711 gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize " | |
| 8712 "Expanding tenured generation by " SIZE_FORMAT " (bytes)", | |
| 8713 expand_bytes); | |
| 8714 } | |
| 8715 expand(expand_bytes, | |
| 8716 MinHeapDeltaBytes, | |
| 8717 CMSExpansionCause::_adaptive_size_policy); | |
| 8718 } else if (desired_promo_size < cur_promo_size) { | |
| 8719 size_t shrink_bytes = cur_promo_size - desired_promo_size; | |
| 8720 if (PrintAdaptiveSizePolicy && Verbose) { | |
| 8721 gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize " | |
| 8722 "Shrinking tenured generation by " SIZE_FORMAT " (bytes)", | |
| 8723 shrink_bytes); | |
| 8724 } | |
| 8725 shrink(shrink_bytes); | |
| 8726 } | |
| 8727 } | |
| 8728 | |
| 8729 CMSGCAdaptivePolicyCounters* ASConcurrentMarkSweepGeneration::gc_adaptive_policy_counters() { | |
| 8730 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 8731 CMSGCAdaptivePolicyCounters* counters = | |
| 8732 (CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters(); | |
| 8733 assert(counters->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind, | |
| 8734 "Wrong kind of counters"); | |
| 8735 return counters; | |
| 8736 } | |
| 8737 | |
| 8738 | |
| 8739 void ASConcurrentMarkSweepGeneration::update_counters() { | |
| 8740 if (UsePerfData) { | |
| 8741 _space_counters->update_all(); | |
| 8742 _gen_counters->update_all(); | |
| 8743 CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters(); | |
| 8744 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 8745 CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats(); | |
| 8746 assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind, | |
| 8747 "Wrong gc statistics type"); | |
| 8748 counters->update_counters(gc_stats_l); | |
| 8749 } | |
| 8750 } | |
| 8751 | |
| 8752 void ASConcurrentMarkSweepGeneration::update_counters(size_t used) { | |
| 8753 if (UsePerfData) { | |
| 8754 _space_counters->update_used(used); | |
| 8755 _space_counters->update_capacity(); | |
| 8756 _gen_counters->update_all(); | |
| 8757 | |
| 8758 CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters(); | |
| 8759 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 8760 CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats(); | |
| 8761 assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind, | |
| 8762 "Wrong gc statistics type"); | |
| 8763 counters->update_counters(gc_stats_l); | |
| 8764 } | |
| 8765 } | |
| 8766 | |
| 8767 // The desired expansion delta is computed so that: | |
| 8768 // . desired free percentage or greater is used | |
| 8769 void ASConcurrentMarkSweepGeneration::compute_new_size() { | |
| 8770 assert_locked_or_safepoint(Heap_lock); | |
| 8771 | |
| 8772 GenCollectedHeap* gch = (GenCollectedHeap*) GenCollectedHeap::heap(); | |
| 8773 | |
| 8774 // If incremental collection failed, we just want to expand | |
| 8775 // to the limit. | |
| 8776 if (incremental_collection_failed()) { | |
| 8777 clear_incremental_collection_failed(); | |
| 8778 grow_to_reserved(); | |
| 8779 return; | |
| 8780 } | |
| 8781 | |
| 8782 assert(UseAdaptiveSizePolicy, "Should be using adaptive sizing"); | |
| 8783 | |
| 8784 assert(gch->kind() == CollectedHeap::GenCollectedHeap, | |
| 8785 "Wrong type of heap"); | |
| 8786 int prev_level = level() - 1; | |
| 8787 assert(prev_level >= 0, "The cms generation is the lowest generation"); | |
| 8788 Generation* prev_gen = gch->get_gen(prev_level); | |
| 8789 assert(prev_gen->kind() == Generation::ASParNew, | |
| 8790 "Wrong type of young generation"); | |
| 8791 ParNewGeneration* younger_gen = (ParNewGeneration*) prev_gen; | |
| 8792 size_t cur_eden = younger_gen->eden()->capacity(); | |
| 8793 CMSAdaptiveSizePolicy* size_policy = cms_size_policy(); | |
| 8794 size_t cur_promo = free(); | |
| 8795 size_policy->compute_tenured_generation_free_space(cur_promo, | |
| 8796 max_available(), | |
| 8797 cur_eden); | |
| 8798 resize(cur_promo, size_policy->promo_size()); | |
| 8799 | |
| 8800 // Record the new size of the space in the cms generation | |
| 8801 // that is available for promotions. This is temporary. | |
| 8802 // It should be the desired promo size. | |
| 8803 size_policy->avg_cms_promo()->sample(free()); | |
| 8804 size_policy->avg_old_live()->sample(used()); | |
| 8805 | |
| 8806 if (UsePerfData) { | |
| 8807 CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters(); | |
| 8808 counters->update_cms_capacity_counter(capacity()); | |
| 8809 } | |
| 8810 } | |
| 8811 | |
| 8812 void ASConcurrentMarkSweepGeneration::shrink_by(size_t desired_bytes) { | |
| 8813 assert_locked_or_safepoint(Heap_lock); | |
| 8814 assert_lock_strong(freelistLock()); | |
| 8815 HeapWord* old_end = _cmsSpace->end(); | |
| 8816 HeapWord* unallocated_start = _cmsSpace->unallocated_block(); | |
| 8817 assert(old_end >= unallocated_start, "Miscalculation of unallocated_start"); | |
| 8818 FreeChunk* chunk_at_end = find_chunk_at_end(); | |
| 8819 if (chunk_at_end == NULL) { | |
| 8820 // No room to shrink | |
| 8821 if (PrintGCDetails && Verbose) { | |
| 8822 gclog_or_tty->print_cr("No room to shrink: old_end " | |
| 8823 PTR_FORMAT " unallocated_start " PTR_FORMAT | |
| 8824 " chunk_at_end " PTR_FORMAT, | |
| 8825 old_end, unallocated_start, chunk_at_end); | |
| 8826 } | |
| 8827 return; | |
| 8828 } else { | |
| 8829 | |
| 8830 // Find the chunk at the end of the space and determine | |
| 8831 // how much it can be shrunk. | |
| 8832 size_t shrinkable_size_in_bytes = chunk_at_end->size(); | |
| 8833 size_t aligned_shrinkable_size_in_bytes = | |
| 8834 align_size_down(shrinkable_size_in_bytes, os::vm_page_size()); | |
| 8835 assert(unallocated_start <= chunk_at_end->end(), | |
| 8836 "Inconsistent chunk at end of space"); | |
| 8837 size_t bytes = MIN2(desired_bytes, aligned_shrinkable_size_in_bytes); | |
| 8838 size_t word_size_before = heap_word_size(_virtual_space.committed_size()); | |
| 8839 | |
| 8840 // Shrink the underlying space | |
| 8841 _virtual_space.shrink_by(bytes); | |
| 8842 if (PrintGCDetails && Verbose) { | |
| 8843 gclog_or_tty->print_cr("ConcurrentMarkSweepGeneration::shrink_by:" | |
| 8844 " desired_bytes " SIZE_FORMAT | |
| 8845 " shrinkable_size_in_bytes " SIZE_FORMAT | |
| 8846 " aligned_shrinkable_size_in_bytes " SIZE_FORMAT | |
| 8847 " bytes " SIZE_FORMAT, | |
| 8848 desired_bytes, shrinkable_size_in_bytes, | |
| 8849 aligned_shrinkable_size_in_bytes, bytes); | |
| 8850 gclog_or_tty->print_cr(" old_end " SIZE_FORMAT | |
| 8851 " unallocated_start " SIZE_FORMAT, | |
| 8852 old_end, unallocated_start); | |
| 8853 } | |
| 8854 | |
| 8855 // If the space did shrink (shrinking is not guaranteed), | |
| 8856 // shrink the chunk at the end by the appropriate amount. | |
| 8857 if (((HeapWord*)_virtual_space.high()) < old_end) { | |
| 8858 size_t new_word_size = | |
| 8859 heap_word_size(_virtual_space.committed_size()); | |
| 8860 | |
| 8861 // Have to remove the chunk from the dictionary because it is changing | |
| 8862 // size and might be someplace elsewhere in the dictionary. | |
| 8863 | |
| 8864 // Get the chunk at end, shrink it, and put it | |
| 8865 // back. | |
| 8866 _cmsSpace->removeChunkFromDictionary(chunk_at_end); | |
| 8867 size_t word_size_change = word_size_before - new_word_size; | |
| 8868 size_t chunk_at_end_old_size = chunk_at_end->size(); | |
| 8869 assert(chunk_at_end_old_size >= word_size_change, | |
| 8870 "Shrink is too large"); | |
| 8871 chunk_at_end->setSize(chunk_at_end_old_size - | |
| 8872 word_size_change); | |
| 8873 _cmsSpace->freed((HeapWord*) chunk_at_end->end(), | |
| 8874 word_size_change); | |
| 8875 | |
| 8876 _cmsSpace->returnChunkToDictionary(chunk_at_end); | |
| 8877 | |
| 8878 MemRegion mr(_cmsSpace->bottom(), new_word_size); | |
| 8879 _bts->resize(new_word_size); // resize the block offset shared array | |
| 8880 Universe::heap()->barrier_set()->resize_covered_region(mr); | |
| 8881 _cmsSpace->assert_locked(); | |
| 8882 _cmsSpace->set_end((HeapWord*)_virtual_space.high()); | |
| 8883 | |
| 8884 NOT_PRODUCT(_cmsSpace->dictionary()->verify()); | |
| 8885 | |
| 8886 // update the space and generation capacity counters | |
| 8887 if (UsePerfData) { | |
| 8888 _space_counters->update_capacity(); | |
| 8889 _gen_counters->update_all(); | |
| 8890 } | |
| 8891 | |
| 8892 if (Verbose && PrintGCDetails) { | |
| 8893 size_t new_mem_size = _virtual_space.committed_size(); | |
| 8894 size_t old_mem_size = new_mem_size + bytes; | |
| 8895 gclog_or_tty->print_cr("Shrinking %s from %ldK by %ldK to %ldK", | |
| 8896 name(), old_mem_size/K, bytes/K, new_mem_size/K); | |
| 8897 } | |
| 8898 } | |
| 8899 | |
| 8900 assert(_cmsSpace->unallocated_block() <= _cmsSpace->end(), | |
| 8901 "Inconsistency at end of space"); | |
| 8902 assert(chunk_at_end->end() == _cmsSpace->end(), | |
| 8903 "Shrinking is inconsistent"); | |
| 8904 return; | |
| 8905 } | |
| 8906 } | |
| 8907 | |
| 8908 // Transfer some number of overflown objects to usual marking | |
| 8909 // stack. Return true if some objects were transferred. | |
| 8910 bool MarkRefsIntoAndScanClosure::take_from_overflow_list() { | |
| 8911 size_t num = MIN2((size_t)_mark_stack->capacity()/4, | |
| 8912 (size_t)ParGCDesiredObjsFromOverflowList); | |
| 8913 | |
| 8914 bool res = _collector->take_from_overflow_list(num, _mark_stack); | |
| 8915 assert(_collector->overflow_list_is_empty() || res, | |
| 8916 "If list is not empty, we should have taken something"); | |
| 8917 assert(!res || !_mark_stack->isEmpty(), | |
| 8918 "If we took something, it should now be on our stack"); | |
| 8919 return res; | |
| 8920 } | |
| 8921 | |
| 8922 size_t MarkDeadObjectsClosure::do_blk(HeapWord* addr) { | |
| 8923 size_t res = _sp->block_size_no_stall(addr, _collector); | |
| 8924 assert(res != 0, "Should always be able to compute a size"); | |
| 8925 if (_sp->block_is_obj(addr)) { | |
| 8926 if (_live_bit_map->isMarked(addr)) { | |
| 8927 // It can't have been dead in a previous cycle | |
| 8928 guarantee(!_dead_bit_map->isMarked(addr), "No resurrection!"); | |
| 8929 } else { | |
| 8930 _dead_bit_map->mark(addr); // mark the dead object | |
| 8931 } | |
| 8932 } | |
| 8933 return res; | |
| 8934 } |