Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
| author | johnc |
|---|---|
| date | Wed, 24 Apr 2013 14:48:43 -0700 |
| parents | ebded0261dfc |
| children | b06ac540229e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6885
diff
changeset
|
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1521
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1521
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1521
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
26 #include "classfile/classLoaderData.hpp" |
| 1972 | 27 #include "classfile/symbolTable.hpp" |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "code/codeCache.hpp" | |
| 30 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" | |
| 31 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp" | |
| 32 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp" | |
| 33 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp" | |
| 34 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp" | |
| 35 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp" | |
| 36 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" | |
| 37 #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp" | |
| 38 #include "gc_implementation/parNew/parNewGeneration.hpp" | |
| 39 #include "gc_implementation/shared/collectorCounters.hpp" | |
| 40 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 41 #include "gc_interface/collectedHeap.inline.hpp" | |
| 42 #include "memory/cardTableRS.hpp" | |
| 43 #include "memory/collectorPolicy.hpp" | |
| 44 #include "memory/gcLocker.inline.hpp" | |
| 45 #include "memory/genCollectedHeap.hpp" | |
| 46 #include "memory/genMarkSweep.hpp" | |
| 47 #include "memory/genOopClosures.inline.hpp" | |
| 48 #include "memory/iterator.hpp" | |
| 49 #include "memory/referencePolicy.hpp" | |
| 50 #include "memory/resourceArea.hpp" | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
51 #include "memory/tenuredGeneration.hpp" |
| 1972 | 52 #include "oops/oop.inline.hpp" |
| 53 #include "prims/jvmtiExport.hpp" | |
| 54 #include "runtime/globals_extension.hpp" | |
| 55 #include "runtime/handles.inline.hpp" | |
| 56 #include "runtime/java.hpp" | |
| 57 #include "runtime/vmThread.hpp" | |
| 58 #include "services/memoryService.hpp" | |
| 59 #include "services/runtimeService.hpp" | |
| 0 | 60 |
| 61 // statics | |
| 62 CMSCollector* ConcurrentMarkSweepGeneration::_collector = NULL; | |
| 63 bool CMSCollector::_full_gc_requested = false; | |
| 64 | |
| 65 ////////////////////////////////////////////////////////////////// | |
| 66 // In support of CMS/VM thread synchronization | |
| 67 ////////////////////////////////////////////////////////////////// | |
| 68 // We split use of the CGC_lock into 2 "levels". | |
| 69 // The low-level locking is of the usual CGC_lock monitor. We introduce | |
| 70 // a higher level "token" (hereafter "CMS token") built on top of the | |
| 71 // low level monitor (hereafter "CGC lock"). | |
| 72 // The token-passing protocol gives priority to the VM thread. The | |
| 73 // CMS-lock doesn't provide any fairness guarantees, but clients | |
| 74 // should ensure that it is only held for very short, bounded | |
| 75 // durations. | |
| 76 // | |
| 77 // When either of the CMS thread or the VM thread is involved in | |
| 78 // collection operations during which it does not want the other | |
| 79 // thread to interfere, it obtains the CMS token. | |
| 80 // | |
| 81 // If either thread tries to get the token while the other has | |
| 82 // it, that thread waits. However, if the VM thread and CMS thread | |
| 83 // both want the token, then the VM thread gets priority while the | |
| 84 // CMS thread waits. This ensures, for instance, that the "concurrent" | |
| 85 // phases of the CMS thread's work do not block out the VM thread | |
| 86 // for long periods of time as the CMS thread continues to hog | |
| 87 // the token. (See bug 4616232). | |
| 88 // | |
| 89 // The baton-passing functions are, however, controlled by the | |
| 90 // flags _foregroundGCShouldWait and _foregroundGCIsActive, | |
| 91 // and here the low-level CMS lock, not the high level token, | |
| 92 // ensures mutual exclusion. | |
| 93 // | |
| 94 // Two important conditions that we have to satisfy: | |
| 95 // 1. if a thread does a low-level wait on the CMS lock, then it | |
| 96 // relinquishes the CMS token if it were holding that token | |
| 97 // when it acquired the low-level CMS lock. | |
| 98 // 2. any low-level notifications on the low-level lock | |
| 99 // should only be sent when a thread has relinquished the token. | |
| 100 // | |
| 101 // In the absence of either property, we'd have potential deadlock. | |
| 102 // | |
| 103 // We protect each of the CMS (concurrent and sequential) phases | |
| 104 // with the CMS _token_, not the CMS _lock_. | |
| 105 // | |
| 106 // The only code protected by CMS lock is the token acquisition code | |
| 107 // itself, see ConcurrentMarkSweepThread::[de]synchronize(), and the | |
| 108 // baton-passing code. | |
| 109 // | |
| 110 // Unfortunately, i couldn't come up with a good abstraction to factor and | |
| 111 // hide the naked CGC_lock manipulation in the baton-passing code | |
| 112 // further below. That's something we should try to do. Also, the proof | |
| 113 // of correctness of this 2-level locking scheme is far from obvious, | |
| 114 // and potentially quite slippery. We have an uneasy supsicion, for instance, | |
| 115 // that there may be a theoretical possibility of delay/starvation in the | |
| 116 // low-level lock/wait/notify scheme used for the baton-passing because of | |
| 117 // potential intereference with the priority scheme embodied in the | |
| 118 // CMS-token-passing protocol. See related comments at a CGC_lock->wait() | |
| 119 // invocation further below and marked with "XXX 20011219YSR". | |
| 120 // Indeed, as we note elsewhere, this may become yet more slippery | |
| 121 // in the presence of multiple CMS and/or multiple VM threads. XXX | |
| 122 | |
| 123 class CMSTokenSync: public StackObj { | |
| 124 private: | |
| 125 bool _is_cms_thread; | |
| 126 public: | |
| 127 CMSTokenSync(bool is_cms_thread): | |
| 128 _is_cms_thread(is_cms_thread) { | |
| 129 assert(is_cms_thread == Thread::current()->is_ConcurrentGC_thread(), | |
| 130 "Incorrect argument to constructor"); | |
| 131 ConcurrentMarkSweepThread::synchronize(_is_cms_thread); | |
| 132 } | |
| 133 | |
| 134 ~CMSTokenSync() { | |
| 135 assert(_is_cms_thread ? | |
| 136 ConcurrentMarkSweepThread::cms_thread_has_cms_token() : | |
| 137 ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 138 "Incorrect state"); | |
| 139 ConcurrentMarkSweepThread::desynchronize(_is_cms_thread); | |
| 140 } | |
| 141 }; | |
| 142 | |
| 143 // Convenience class that does a CMSTokenSync, and then acquires | |
| 144 // upto three locks. | |
| 145 class CMSTokenSyncWithLocks: public CMSTokenSync { | |
| 146 private: | |
| 147 // Note: locks are acquired in textual declaration order | |
| 148 // and released in the opposite order | |
| 149 MutexLockerEx _locker1, _locker2, _locker3; | |
| 150 public: | |
| 151 CMSTokenSyncWithLocks(bool is_cms_thread, Mutex* mutex1, | |
| 152 Mutex* mutex2 = NULL, Mutex* mutex3 = NULL): | |
| 153 CMSTokenSync(is_cms_thread), | |
| 154 _locker1(mutex1, Mutex::_no_safepoint_check_flag), | |
| 155 _locker2(mutex2, Mutex::_no_safepoint_check_flag), | |
| 156 _locker3(mutex3, Mutex::_no_safepoint_check_flag) | |
| 157 { } | |
| 158 }; | |
| 159 | |
| 160 | |
| 161 // Wrapper class to temporarily disable icms during a foreground cms collection. | |
| 162 class ICMSDisabler: public StackObj { | |
| 163 public: | |
| 164 // The ctor disables icms and wakes up the thread so it notices the change; | |
| 165 // the dtor re-enables icms. Note that the CMSCollector methods will check | |
| 166 // CMSIncrementalMode. | |
| 167 ICMSDisabler() { CMSCollector::disable_icms(); CMSCollector::start_icms(); } | |
| 168 ~ICMSDisabler() { CMSCollector::enable_icms(); } | |
| 169 }; | |
| 170 | |
| 171 ////////////////////////////////////////////////////////////////// | |
| 172 // Concurrent Mark-Sweep Generation ///////////////////////////// | |
| 173 ////////////////////////////////////////////////////////////////// | |
| 174 | |
| 175 NOT_PRODUCT(CompactibleFreeListSpace* debug_cms_space;) | |
| 176 | |
| 177 // This struct contains per-thread things necessary to support parallel | |
| 178 // young-gen collection. | |
| 6197 | 179 class CMSParGCThreadState: public CHeapObj<mtGC> { |
| 0 | 180 public: |
| 181 CFLS_LAB lab; | |
| 182 PromotionInfo promo; | |
| 183 | |
| 184 // Constructor. | |
| 185 CMSParGCThreadState(CompactibleFreeListSpace* cfls) : lab(cfls) { | |
| 186 promo.setSpace(cfls); | |
| 187 } | |
| 188 }; | |
| 189 | |
| 190 ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration( | |
| 191 ReservedSpace rs, size_t initial_byte_size, int level, | |
| 192 CardTableRS* ct, bool use_adaptive_freelists, | |
| 6026 | 193 FreeBlockDictionary<FreeChunk>::DictionaryChoice dictionaryChoice) : |
| 0 | 194 CardGeneration(rs, initial_byte_size, level, ct), |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1521
diff
changeset
|
195 _dilatation_factor(((double)MinChunkSize)/((double)(CollectedHeap::min_fill_size()))), |
| 0 | 196 _debug_collection_type(Concurrent_collection_type) |
| 197 { | |
| 198 HeapWord* bottom = (HeapWord*) _virtual_space.low(); | |
| 199 HeapWord* end = (HeapWord*) _virtual_space.high(); | |
| 200 | |
| 201 _direct_allocated_words = 0; | |
| 202 NOT_PRODUCT( | |
| 203 _numObjectsPromoted = 0; | |
| 204 _numWordsPromoted = 0; | |
| 205 _numObjectsAllocated = 0; | |
| 206 _numWordsAllocated = 0; | |
| 207 ) | |
| 208 | |
| 209 _cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end), | |
| 210 use_adaptive_freelists, | |
| 211 dictionaryChoice); | |
| 212 NOT_PRODUCT(debug_cms_space = _cmsSpace;) | |
| 213 if (_cmsSpace == NULL) { | |
| 214 vm_exit_during_initialization( | |
| 215 "CompactibleFreeListSpace allocation failure"); | |
| 216 } | |
| 217 _cmsSpace->_gen = this; | |
| 218 | |
| 219 _gc_stats = new CMSGCStats(); | |
| 220 | |
| 221 // Verify the assumption that FreeChunk::_prev and OopDesc::_klass | |
| 222 // offsets match. The ability to tell free chunks from objects | |
| 223 // depends on this property. | |
| 224 debug_only( | |
| 225 FreeChunk* junk = NULL; | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6787
diff
changeset
|
226 assert(UseCompressedKlassPointers || |
| 187 | 227 junk->prev_addr() == (void*)(oop(junk)->klass_addr()), |
| 0 | 228 "Offset of FreeChunk::_prev within FreeChunk must match" |
| 229 " that of OopDesc::_klass within OopDesc"); | |
| 230 ) | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
231 if (CollectedHeap::use_parallel_gc_threads()) { |
| 0 | 232 typedef CMSParGCThreadState* CMSParGCThreadStatePtr; |
| 233 _par_gc_thread_states = | |
| 6197 | 234 NEW_C_HEAP_ARRAY(CMSParGCThreadStatePtr, ParallelGCThreads, mtGC); |
| 0 | 235 if (_par_gc_thread_states == NULL) { |
| 236 vm_exit_during_initialization("Could not allocate par gc structs"); | |
| 237 } | |
| 238 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 239 _par_gc_thread_states[i] = new CMSParGCThreadState(cmsSpace()); | |
| 240 if (_par_gc_thread_states[i] == NULL) { | |
| 241 vm_exit_during_initialization("Could not allocate par gc structs"); | |
| 242 } | |
| 243 } | |
| 244 } else { | |
| 245 _par_gc_thread_states = NULL; | |
| 246 } | |
| 247 _incremental_collection_failed = false; | |
| 248 // The "dilatation_factor" is the expansion that can occur on | |
| 249 // account of the fact that the minimum object size in the CMS | |
| 250 // generation may be larger than that in, say, a contiguous young | |
| 251 // generation. | |
| 252 // Ideally, in the calculation below, we'd compute the dilatation | |
| 253 // factor as: MinChunkSize/(promoting_gen's min object size) | |
| 254 // Since we do not have such a general query interface for the | |
| 255 // promoting generation, we'll instead just use the mimimum | |
| 256 // object size (which today is a header's worth of space); | |
| 257 // note that all arithmetic is in units of HeapWords. | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1521
diff
changeset
|
258 assert(MinChunkSize >= CollectedHeap::min_fill_size(), "just checking"); |
| 0 | 259 assert(_dilatation_factor >= 1.0, "from previous assert"); |
| 260 } | |
| 261 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
262 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
263 // The field "_initiating_occupancy" represents the occupancy percentage |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
264 // at which we trigger a new collection cycle. Unless explicitly specified |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
265 // via CMSInitiatingOccupancyFraction (argument "io" below), it |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
266 // is calculated by: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
267 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
268 // Let "f" be MinHeapFreeRatio in |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
269 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
270 // _intiating_occupancy = 100-f + |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
271 // f * (CMSTriggerRatio/100) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
272 // where CMSTriggerRatio is the argument "tr" below. |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
273 // |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
274 // That is, if we assume the heap is at its desired maximum occupancy at the |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
275 // end of a collection, we let CMSTriggerRatio of the (purported) free |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
276 // space be allocated before initiating a new collection cycle. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
277 // |
| 8035 | 278 void ConcurrentMarkSweepGeneration::init_initiating_occupancy(intx io, uintx tr) { |
| 279 assert(io <= 100 && tr <= 100, "Check the arguments"); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
280 if (io >= 0) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
281 _initiating_occupancy = (double)io / 100.0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
282 } else { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
283 _initiating_occupancy = ((100 - MinHeapFreeRatio) + |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
284 (double)(tr * MinHeapFreeRatio) / 100.0) |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
285 / 100.0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
286 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
287 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
288 |
| 0 | 289 void ConcurrentMarkSweepGeneration::ref_processor_init() { |
| 290 assert(collector() != NULL, "no collector"); | |
| 291 collector()->ref_processor_init(); | |
| 292 } | |
| 293 | |
| 294 void CMSCollector::ref_processor_init() { | |
| 295 if (_ref_processor == NULL) { | |
| 296 // Allocate and initialize a reference processor | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
297 _ref_processor = |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
298 new ReferenceProcessor(_span, // span |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
299 (ParallelGCThreads > 1) && ParallelRefProcEnabled, // mt processing |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
300 (int) ParallelGCThreads, // mt processing degree |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
301 _cmsGen->refs_discovery_is_mt(), // mt discovery |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
302 (int) MAX2(ConcGCThreads, ParallelGCThreads), // mt discovery degree |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
303 _cmsGen->refs_discovery_is_atomic(), // discovery is not atomic |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
304 &_is_alive_closure, // closure for liveness info |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
305 false); // next field updates do not need write barrier |
| 0 | 306 // Initialize the _ref_processor field of CMSGen |
| 307 _cmsGen->set_ref_processor(_ref_processor); | |
| 308 | |
| 309 } | |
| 310 } | |
| 311 | |
| 312 CMSAdaptiveSizePolicy* CMSCollector::size_policy() { | |
| 313 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 314 assert(gch->kind() == CollectedHeap::GenCollectedHeap, | |
| 315 "Wrong type of heap"); | |
| 316 CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*) | |
| 317 gch->gen_policy()->size_policy(); | |
| 318 assert(sp->is_gc_cms_adaptive_size_policy(), | |
| 319 "Wrong type of size policy"); | |
| 320 return sp; | |
| 321 } | |
| 322 | |
| 323 CMSGCAdaptivePolicyCounters* CMSCollector::gc_adaptive_policy_counters() { | |
| 324 CMSGCAdaptivePolicyCounters* results = | |
| 325 (CMSGCAdaptivePolicyCounters*) collector_policy()->counters(); | |
| 326 assert( | |
| 327 results->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind, | |
| 328 "Wrong gc policy counter kind"); | |
| 329 return results; | |
| 330 } | |
| 331 | |
| 332 | |
| 333 void ConcurrentMarkSweepGeneration::initialize_performance_counters() { | |
| 334 | |
| 335 const char* gen_name = "old"; | |
| 336 | |
| 337 // Generation Counters - generation 1, 1 subspace | |
| 338 _gen_counters = new GenerationCounters(gen_name, 1, 1, &_virtual_space); | |
| 339 | |
| 340 _space_counters = new GSpaceCounters(gen_name, 0, | |
| 341 _virtual_space.reserved_size(), | |
| 342 this, _gen_counters); | |
| 343 } | |
| 344 | |
| 345 CMSStats::CMSStats(ConcurrentMarkSweepGeneration* cms_gen, unsigned int alpha): | |
| 346 _cms_gen(cms_gen) | |
| 347 { | |
| 348 assert(alpha <= 100, "bad value"); | |
| 349 _saved_alpha = alpha; | |
| 350 | |
| 351 // Initialize the alphas to the bootstrap value of 100. | |
| 352 _gc0_alpha = _cms_alpha = 100; | |
| 353 | |
| 354 _cms_begin_time.update(); | |
| 355 _cms_end_time.update(); | |
| 356 | |
| 357 _gc0_duration = 0.0; | |
| 358 _gc0_period = 0.0; | |
| 359 _gc0_promoted = 0; | |
| 360 | |
| 361 _cms_duration = 0.0; | |
| 362 _cms_period = 0.0; | |
| 363 _cms_allocated = 0; | |
| 364 | |
| 365 _cms_used_at_gc0_begin = 0; | |
| 366 _cms_used_at_gc0_end = 0; | |
| 367 _allow_duty_cycle_reduction = false; | |
| 368 _valid_bits = 0; | |
| 369 _icms_duty_cycle = CMSIncrementalDutyCycle; | |
| 370 } | |
| 371 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
372 double CMSStats::cms_free_adjustment_factor(size_t free) const { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
373 // TBD: CR 6909490 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
374 return 1.0; |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
375 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
376 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
377 void CMSStats::adjust_cms_free_adjustment_factor(bool fail, size_t free) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
378 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
379 |
| 0 | 380 // If promotion failure handling is on use |
| 381 // the padded average size of the promotion for each | |
| 382 // young generation collection. | |
| 383 double CMSStats::time_until_cms_gen_full() const { | |
| 384 size_t cms_free = _cms_gen->cmsSpace()->free(); | |
| 385 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
386 size_t expected_promotion = MIN2(gch->get_gen(0)->capacity(), |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
387 (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average()); |
| 0 | 388 if (cms_free > expected_promotion) { |
| 389 // Start a cms collection if there isn't enough space to promote | |
| 390 // for the next minor collection. Use the padded average as | |
| 391 // a safety factor. | |
| 392 cms_free -= expected_promotion; | |
| 393 | |
| 394 // Adjust by the safety factor. | |
| 395 double cms_free_dbl = (double)cms_free; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
396 double cms_adjustment = (100.0 - CMSIncrementalSafetyFactor)/100.0; |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
397 // Apply a further correction factor which tries to adjust |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
398 // for recent occurance of concurrent mode failures. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
399 cms_adjustment = cms_adjustment * cms_free_adjustment_factor(cms_free); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
400 cms_free_dbl = cms_free_dbl * cms_adjustment; |
| 0 | 401 |
| 402 if (PrintGCDetails && Verbose) { | |
| 403 gclog_or_tty->print_cr("CMSStats::time_until_cms_gen_full: cms_free " | |
| 404 SIZE_FORMAT " expected_promotion " SIZE_FORMAT, | |
| 405 cms_free, expected_promotion); | |
| 406 gclog_or_tty->print_cr(" cms_free_dbl %f cms_consumption_rate %f", | |
| 407 cms_free_dbl, cms_consumption_rate() + 1.0); | |
| 408 } | |
| 409 // Add 1 in case the consumption rate goes to zero. | |
| 410 return cms_free_dbl / (cms_consumption_rate() + 1.0); | |
| 411 } | |
| 412 return 0.0; | |
| 413 } | |
| 414 | |
| 415 // Compare the duration of the cms collection to the | |
| 416 // time remaining before the cms generation is empty. | |
| 417 // Note that the time from the start of the cms collection | |
| 418 // to the start of the cms sweep (less than the total | |
| 419 // duration of the cms collection) can be used. This | |
| 420 // has been tried and some applications experienced | |
| 421 // promotion failures early in execution. This was | |
| 422 // possibly because the averages were not accurate | |
| 423 // enough at the beginning. | |
| 424 double CMSStats::time_until_cms_start() const { | |
| 425 // We add "gc0_period" to the "work" calculation | |
| 426 // below because this query is done (mostly) at the | |
| 427 // end of a scavenge, so we need to conservatively | |
| 428 // account for that much possible delay | |
| 429 // in the query so as to avoid concurrent mode failures | |
| 430 // due to starting the collection just a wee bit too | |
| 431 // late. | |
| 432 double work = cms_duration() + gc0_period(); | |
| 433 double deadline = time_until_cms_gen_full(); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
434 // If a concurrent mode failure occurred recently, we want to be |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
435 // more conservative and halve our expected time_until_cms_gen_full() |
| 0 | 436 if (work > deadline) { |
| 437 if (Verbose && PrintGCDetails) { | |
| 438 gclog_or_tty->print( | |
| 439 " CMSCollector: collect because of anticipated promotion " | |
| 440 "before full %3.7f + %3.7f > %3.7f ", cms_duration(), | |
| 441 gc0_period(), time_until_cms_gen_full()); | |
| 442 } | |
| 443 return 0.0; | |
| 444 } | |
| 445 return work - deadline; | |
| 446 } | |
| 447 | |
| 448 // Return a duty cycle based on old_duty_cycle and new_duty_cycle, limiting the | |
| 449 // amount of change to prevent wild oscillation. | |
| 450 unsigned int CMSStats::icms_damped_duty_cycle(unsigned int old_duty_cycle, | |
| 451 unsigned int new_duty_cycle) { | |
| 452 assert(old_duty_cycle <= 100, "bad input value"); | |
| 453 assert(new_duty_cycle <= 100, "bad input value"); | |
| 454 | |
| 455 // Note: use subtraction with caution since it may underflow (values are | |
| 456 // unsigned). Addition is safe since we're in the range 0-100. | |
| 457 unsigned int damped_duty_cycle = new_duty_cycle; | |
| 458 if (new_duty_cycle < old_duty_cycle) { | |
| 459 const unsigned int largest_delta = MAX2(old_duty_cycle / 4, 5U); | |
| 460 if (new_duty_cycle + largest_delta < old_duty_cycle) { | |
| 461 damped_duty_cycle = old_duty_cycle - largest_delta; | |
| 462 } | |
| 463 } else if (new_duty_cycle > old_duty_cycle) { | |
| 464 const unsigned int largest_delta = MAX2(old_duty_cycle / 4, 15U); | |
| 465 if (new_duty_cycle > old_duty_cycle + largest_delta) { | |
| 466 damped_duty_cycle = MIN2(old_duty_cycle + largest_delta, 100U); | |
| 467 } | |
| 468 } | |
| 469 assert(damped_duty_cycle <= 100, "invalid duty cycle computed"); | |
| 470 | |
| 471 if (CMSTraceIncrementalPacing) { | |
| 472 gclog_or_tty->print(" [icms_damped_duty_cycle(%d,%d) = %d] ", | |
| 473 old_duty_cycle, new_duty_cycle, damped_duty_cycle); | |
| 474 } | |
| 475 return damped_duty_cycle; | |
| 476 } | |
| 477 | |
| 478 unsigned int CMSStats::icms_update_duty_cycle_impl() { | |
| 479 assert(CMSIncrementalPacing && valid(), | |
| 480 "should be handled in icms_update_duty_cycle()"); | |
| 481 | |
| 482 double cms_time_so_far = cms_timer().seconds(); | |
| 483 double scaled_duration = cms_duration_per_mb() * _cms_used_at_gc0_end / M; | |
| 484 double scaled_duration_remaining = fabsd(scaled_duration - cms_time_so_far); | |
| 485 | |
| 486 // Avoid division by 0. | |
| 487 double time_until_full = MAX2(time_until_cms_gen_full(), 0.01); | |
| 488 double duty_cycle_dbl = 100.0 * scaled_duration_remaining / time_until_full; | |
| 489 | |
| 490 unsigned int new_duty_cycle = MIN2((unsigned int)duty_cycle_dbl, 100U); | |
| 491 if (new_duty_cycle > _icms_duty_cycle) { | |
| 492 // Avoid very small duty cycles (1 or 2); 0 is allowed. | |
| 493 if (new_duty_cycle > 2) { | |
| 494 _icms_duty_cycle = icms_damped_duty_cycle(_icms_duty_cycle, | |
| 495 new_duty_cycle); | |
| 496 } | |
| 497 } else if (_allow_duty_cycle_reduction) { | |
| 498 // The duty cycle is reduced only once per cms cycle (see record_cms_end()). | |
| 499 new_duty_cycle = icms_damped_duty_cycle(_icms_duty_cycle, new_duty_cycle); | |
| 500 // Respect the minimum duty cycle. | |
| 501 unsigned int min_duty_cycle = (unsigned int)CMSIncrementalDutyCycleMin; | |
| 502 _icms_duty_cycle = MAX2(new_duty_cycle, min_duty_cycle); | |
| 503 } | |
| 504 | |
| 505 if (PrintGCDetails || CMSTraceIncrementalPacing) { | |
| 506 gclog_or_tty->print(" icms_dc=%d ", _icms_duty_cycle); | |
| 507 } | |
| 508 | |
| 509 _allow_duty_cycle_reduction = false; | |
| 510 return _icms_duty_cycle; | |
| 511 } | |
| 512 | |
| 513 #ifndef PRODUCT | |
| 514 void CMSStats::print_on(outputStream *st) const { | |
| 515 st->print(" gc0_alpha=%d,cms_alpha=%d", _gc0_alpha, _cms_alpha); | |
| 516 st->print(",gc0_dur=%g,gc0_per=%g,gc0_promo=" SIZE_FORMAT, | |
| 517 gc0_duration(), gc0_period(), gc0_promoted()); | |
| 518 st->print(",cms_dur=%g,cms_dur_per_mb=%g,cms_per=%g,cms_alloc=" SIZE_FORMAT, | |
| 519 cms_duration(), cms_duration_per_mb(), | |
| 520 cms_period(), cms_allocated()); | |
| 521 st->print(",cms_since_beg=%g,cms_since_end=%g", | |
| 522 cms_time_since_begin(), cms_time_since_end()); | |
| 523 st->print(",cms_used_beg=" SIZE_FORMAT ",cms_used_end=" SIZE_FORMAT, | |
| 524 _cms_used_at_gc0_begin, _cms_used_at_gc0_end); | |
| 525 if (CMSIncrementalMode) { | |
| 526 st->print(",dc=%d", icms_duty_cycle()); | |
| 527 } | |
| 528 | |
| 529 if (valid()) { | |
| 530 st->print(",promo_rate=%g,cms_alloc_rate=%g", | |
| 531 promotion_rate(), cms_allocation_rate()); | |
| 532 st->print(",cms_consumption_rate=%g,time_until_full=%g", | |
| 533 cms_consumption_rate(), time_until_cms_gen_full()); | |
| 534 } | |
| 535 st->print(" "); | |
| 536 } | |
| 537 #endif // #ifndef PRODUCT | |
| 538 | |
| 539 CMSCollector::CollectorState CMSCollector::_collectorState = | |
| 540 CMSCollector::Idling; | |
| 541 bool CMSCollector::_foregroundGCIsActive = false; | |
| 542 bool CMSCollector::_foregroundGCShouldWait = false; | |
| 543 | |
| 544 CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, | |
| 545 CardTableRS* ct, | |
| 546 ConcurrentMarkSweepPolicy* cp): | |
| 547 _cmsGen(cmsGen), | |
| 548 _ct(ct), | |
| 549 _ref_processor(NULL), // will be set later | |
| 550 _conc_workers(NULL), // may be set later | |
| 551 _abort_preclean(false), | |
| 552 _start_sampling(false), | |
| 553 _between_prologue_and_epilogue(false), | |
| 554 _markBitMap(0, Mutex::leaf + 1, "CMS_markBitMap_lock"), | |
| 555 _modUnionTable((CardTableModRefBS::card_shift - LogHeapWordSize), | |
| 556 -1 /* lock-free */, "No_lock" /* dummy */), | |
| 557 _modUnionClosure(&_modUnionTable), | |
| 558 _modUnionClosurePar(&_modUnionTable), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
559 // Adjust my span to cover old (cms) gen |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
560 _span(cmsGen->reserved()), |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
561 // Construct the is_alive_closure with _span & markBitMap |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
562 _is_alive_closure(_span, &_markBitMap), |
| 0 | 563 _restart_addr(NULL), |
| 564 _overflow_list(NULL), | |
| 565 _stats(cmsGen), | |
| 566 _eden_chunk_array(NULL), // may be set in ctor body | |
| 567 _eden_chunk_capacity(0), // -- ditto -- | |
| 568 _eden_chunk_index(0), // -- ditto -- | |
| 569 _survivor_plab_array(NULL), // -- ditto -- | |
| 570 _survivor_chunk_array(NULL), // -- ditto -- | |
| 571 _survivor_chunk_capacity(0), // -- ditto -- | |
| 572 _survivor_chunk_index(0), // -- ditto -- | |
| 573 _ser_pmc_preclean_ovflw(0), | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
574 _ser_kac_preclean_ovflw(0), |
| 0 | 575 _ser_pmc_remark_ovflw(0), |
| 576 _par_pmc_remark_ovflw(0), | |
| 577 _ser_kac_ovflw(0), | |
| 578 _par_kac_ovflw(0), | |
| 579 #ifndef PRODUCT | |
| 580 _num_par_pushes(0), | |
| 581 #endif | |
| 582 _collection_count_start(0), | |
| 583 _verifying(false), | |
| 584 _icms_start_limit(NULL), | |
| 585 _icms_stop_limit(NULL), | |
| 586 _verification_mark_bm(0, Mutex::leaf + 1, "CMS_verification_mark_bm_lock"), | |
| 587 _completed_initialization(false), | |
| 588 _collector_policy(cp), | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
589 _should_unload_classes(false), |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
590 _concurrent_cycles_since_last_unload(0), |
|
798
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
679
diff
changeset
|
591 _roots_scanning_options(0), |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
592 _inter_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
593 _intra_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding) |
| 0 | 594 { |
| 595 if (ExplicitGCInvokesConcurrentAndUnloadsClasses) { | |
| 596 ExplicitGCInvokesConcurrent = true; | |
| 597 } | |
| 598 // Now expand the span and allocate the collection support structures | |
| 599 // (MUT, marking bit map etc.) to cover both generations subject to | |
| 600 // collection. | |
| 601 | |
| 602 // For use by dirty card to oop closures. | |
| 603 _cmsGen->cmsSpace()->set_collector(this); | |
| 604 | |
| 605 // Allocate MUT and marking bit map | |
| 606 { | |
| 607 MutexLockerEx x(_markBitMap.lock(), Mutex::_no_safepoint_check_flag); | |
| 608 if (!_markBitMap.allocate(_span)) { | |
| 609 warning("Failed to allocate CMS Bit Map"); | |
| 610 return; | |
| 611 } | |
| 612 assert(_markBitMap.covers(_span), "_markBitMap inconsistency?"); | |
| 613 } | |
| 614 { | |
| 615 _modUnionTable.allocate(_span); | |
| 616 assert(_modUnionTable.covers(_span), "_modUnionTable inconsistency?"); | |
| 617 } | |
| 618 | |
| 1284 | 619 if (!_markStack.allocate(MarkStackSize)) { |
| 0 | 620 warning("Failed to allocate CMS Marking Stack"); |
| 621 return; | |
| 622 } | |
| 623 | |
| 624 // Support for multi-threaded concurrent phases | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
625 if (CMSConcurrentMTEnabled) { |
| 1284 | 626 if (FLAG_IS_DEFAULT(ConcGCThreads)) { |
| 0 | 627 // just for now |
| 1284 | 628 FLAG_SET_DEFAULT(ConcGCThreads, (ParallelGCThreads + 3)/4); |
| 629 } | |
| 630 if (ConcGCThreads > 1) { | |
| 0 | 631 _conc_workers = new YieldingFlexibleWorkGang("Parallel CMS Threads", |
| 1284 | 632 ConcGCThreads, true); |
| 0 | 633 if (_conc_workers == NULL) { |
| 634 warning("GC/CMS: _conc_workers allocation failure: " | |
| 635 "forcing -CMSConcurrentMTEnabled"); | |
| 636 CMSConcurrentMTEnabled = false; | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
637 } else { |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
638 _conc_workers->initialize_workers(); |
| 0 | 639 } |
| 640 } else { | |
| 641 CMSConcurrentMTEnabled = false; | |
| 642 } | |
| 643 } | |
| 644 if (!CMSConcurrentMTEnabled) { | |
| 1284 | 645 ConcGCThreads = 0; |
| 0 | 646 } else { |
| 647 // Turn off CMSCleanOnEnter optimization temporarily for | |
| 648 // the MT case where it's not fixed yet; see 6178663. | |
| 649 CMSCleanOnEnter = false; | |
| 650 } | |
| 1284 | 651 assert((_conc_workers != NULL) == (ConcGCThreads > 1), |
| 0 | 652 "Inconsistency"); |
| 653 | |
| 654 // Parallel task queues; these are shared for the | |
| 655 // concurrent and stop-world phases of CMS, but | |
| 656 // are not shared with parallel scavenge (ParNew). | |
| 657 { | |
| 658 uint i; | |
| 1284 | 659 uint num_queues = (uint) MAX2(ParallelGCThreads, ConcGCThreads); |
| 0 | 660 |
| 661 if ((CMSParallelRemarkEnabled || CMSConcurrentMTEnabled | |
| 662 || ParallelRefProcEnabled) | |
| 663 && num_queues > 0) { | |
| 664 _task_queues = new OopTaskQueueSet(num_queues); | |
| 665 if (_task_queues == NULL) { | |
| 666 warning("task_queues allocation failure."); | |
| 667 return; | |
| 668 } | |
| 6197 | 669 _hash_seed = NEW_C_HEAP_ARRAY(int, num_queues, mtGC); |
| 0 | 670 if (_hash_seed == NULL) { |
| 671 warning("_hash_seed array allocation failure"); | |
| 672 return; | |
| 673 } | |
| 674 | |
| 1665 | 675 typedef Padded<OopTaskQueue> PaddedOopTaskQueue; |
| 0 | 676 for (i = 0; i < num_queues; i++) { |
| 1665 | 677 PaddedOopTaskQueue *q = new PaddedOopTaskQueue(); |
| 678 if (q == NULL) { | |
| 0 | 679 warning("work_queue allocation failure."); |
| 680 return; | |
| 681 } | |
| 1665 | 682 _task_queues->register_queue(i, q); |
| 0 | 683 } |
| 684 for (i = 0; i < num_queues; i++) { | |
| 685 _task_queues->queue(i)->initialize(); | |
| 686 _hash_seed[i] = 17; // copied from ParNew | |
| 687 } | |
| 688 } | |
| 689 } | |
| 690 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
691 _cmsGen ->init_initiating_occupancy(CMSInitiatingOccupancyFraction, CMSTriggerRatio); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
692 |
| 0 | 693 // Clip CMSBootstrapOccupancy between 0 and 100. |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
694 _bootstrap_occupancy = ((double)MIN2((uintx)100, MAX2((uintx)0, CMSBootstrapOccupancy))) |
| 0 | 695 /(double)100; |
| 696 | |
| 697 _full_gcs_since_conc_gc = 0; | |
| 698 | |
| 699 // Now tell CMS generations the identity of their collector | |
| 700 ConcurrentMarkSweepGeneration::set_collector(this); | |
| 701 | |
| 702 // Create & start a CMS thread for this CMS collector | |
| 703 _cmsThread = ConcurrentMarkSweepThread::start(this); | |
| 704 assert(cmsThread() != NULL, "CMS Thread should have been created"); | |
| 705 assert(cmsThread()->collector() == this, | |
| 706 "CMS Thread should refer to this gen"); | |
| 707 assert(CGC_lock != NULL, "Where's the CGC_lock?"); | |
| 708 | |
| 709 // Support for parallelizing young gen rescan | |
| 710 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 711 _young_gen = gch->prev_gen(_cmsGen); | |
| 712 if (gch->supports_inline_contig_alloc()) { | |
| 713 _top_addr = gch->top_addr(); | |
| 714 _end_addr = gch->end_addr(); | |
| 715 assert(_young_gen != NULL, "no _young_gen"); | |
| 716 _eden_chunk_index = 0; | |
| 717 _eden_chunk_capacity = (_young_gen->max_capacity()+CMSSamplingGrain)/CMSSamplingGrain; | |
| 6197 | 718 _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity, mtGC); |
| 0 | 719 if (_eden_chunk_array == NULL) { |
| 720 _eden_chunk_capacity = 0; | |
| 721 warning("GC/CMS: _eden_chunk_array allocation failure"); | |
| 722 } | |
| 723 } | |
| 724 assert(_eden_chunk_array != NULL || _eden_chunk_capacity == 0, "Error"); | |
| 725 | |
| 726 // Support for parallelizing survivor space rescan | |
| 727 if (CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) { | |
|
1289
d47555d7aca8
6910182: CMS: assert(_cursor[j] == _survivor_plab_array[j].end(),"Ctl pt invariant")
jmasa
parents:
1284
diff
changeset
|
728 const size_t max_plab_samples = |
|
d47555d7aca8
6910182: CMS: assert(_cursor[j] == _survivor_plab_array[j].end(),"Ctl pt invariant")
jmasa
parents:
1284
diff
changeset
|
729 ((DefNewGeneration*)_young_gen)->max_survivor_size()/MinTLABSize; |
|
d47555d7aca8
6910182: CMS: assert(_cursor[j] == _survivor_plab_array[j].end(),"Ctl pt invariant")
jmasa
parents:
1284
diff
changeset
|
730 |
| 6197 | 731 _survivor_plab_array = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads, mtGC); |
| 732 _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples, mtGC); | |
| 733 _cursor = NEW_C_HEAP_ARRAY(size_t, ParallelGCThreads, mtGC); | |
| 0 | 734 if (_survivor_plab_array == NULL || _survivor_chunk_array == NULL |
| 735 || _cursor == NULL) { | |
| 736 warning("Failed to allocate survivor plab/chunk array"); | |
| 737 if (_survivor_plab_array != NULL) { | |
| 6197 | 738 FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array, mtGC); |
| 0 | 739 _survivor_plab_array = NULL; |
| 740 } | |
| 741 if (_survivor_chunk_array != NULL) { | |
| 6197 | 742 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array, mtGC); |
| 0 | 743 _survivor_chunk_array = NULL; |
| 744 } | |
| 745 if (_cursor != NULL) { | |
| 6197 | 746 FREE_C_HEAP_ARRAY(size_t, _cursor, mtGC); |
| 0 | 747 _cursor = NULL; |
| 748 } | |
| 749 } else { | |
| 750 _survivor_chunk_capacity = 2*max_plab_samples; | |
| 751 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 6197 | 752 HeapWord** vec = NEW_C_HEAP_ARRAY(HeapWord*, max_plab_samples, mtGC); |
| 0 | 753 if (vec == NULL) { |
| 754 warning("Failed to allocate survivor plab array"); | |
| 755 for (int j = i; j > 0; j--) { | |
| 6197 | 756 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_plab_array[j-1].array(), mtGC); |
| 0 | 757 } |
| 6197 | 758 FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array, mtGC); |
| 759 FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array, mtGC); | |
| 0 | 760 _survivor_plab_array = NULL; |
| 761 _survivor_chunk_array = NULL; | |
| 762 _survivor_chunk_capacity = 0; | |
| 763 break; | |
| 764 } else { | |
| 765 ChunkArray* cur = | |
| 766 ::new (&_survivor_plab_array[i]) ChunkArray(vec, | |
| 767 max_plab_samples); | |
| 768 assert(cur->end() == 0, "Should be 0"); | |
| 769 assert(cur->array() == vec, "Should be vec"); | |
| 770 assert(cur->capacity() == max_plab_samples, "Error"); | |
| 771 } | |
| 772 } | |
| 773 } | |
| 774 } | |
| 775 assert( ( _survivor_plab_array != NULL | |
| 776 && _survivor_chunk_array != NULL) | |
| 777 || ( _survivor_chunk_capacity == 0 | |
| 778 && _survivor_chunk_index == 0), | |
| 779 "Error"); | |
| 780 | |
| 781 // Choose what strong roots should be scanned depending on verification options | |
| 782 if (!CMSClassUnloadingEnabled) { | |
| 783 // If class unloading is disabled we want to include all classes into the root set. | |
| 784 add_root_scanning_option(SharedHeap::SO_AllClasses); | |
| 785 } else { | |
| 786 add_root_scanning_option(SharedHeap::SO_SystemClasses); | |
| 787 } | |
| 788 | |
| 789 NOT_PRODUCT(_overflow_counter = CMSMarkStackOverflowInterval;) | |
| 790 _gc_counters = new CollectorCounters("CMS", 1); | |
| 791 _completed_initialization = true; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
792 _inter_sweep_timer.start(); // start of time |
| 0 | 793 } |
| 794 | |
| 795 const char* ConcurrentMarkSweepGeneration::name() const { | |
| 796 return "concurrent mark-sweep generation"; | |
| 797 } | |
| 798 void ConcurrentMarkSweepGeneration::update_counters() { | |
| 799 if (UsePerfData) { | |
| 800 _space_counters->update_all(); | |
| 801 _gen_counters->update_all(); | |
| 802 } | |
| 803 } | |
| 804 | |
| 805 // this is an optimized version of update_counters(). it takes the | |
| 806 // used value as a parameter rather than computing it. | |
| 807 // | |
| 808 void ConcurrentMarkSweepGeneration::update_counters(size_t used) { | |
| 809 if (UsePerfData) { | |
| 810 _space_counters->update_used(used); | |
| 811 _space_counters->update_capacity(); | |
| 812 _gen_counters->update_all(); | |
| 813 } | |
| 814 } | |
| 815 | |
| 816 void ConcurrentMarkSweepGeneration::print() const { | |
| 817 Generation::print(); | |
| 818 cmsSpace()->print(); | |
| 819 } | |
| 820 | |
| 821 #ifndef PRODUCT | |
| 822 void ConcurrentMarkSweepGeneration::print_statistics() { | |
| 823 cmsSpace()->printFLCensus(0); | |
| 824 } | |
| 825 #endif | |
| 826 | |
| 827 void ConcurrentMarkSweepGeneration::printOccupancy(const char *s) { | |
| 828 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 829 if (PrintGCDetails) { | |
| 830 if (Verbose) { | |
|
7455
0b54ffe4c2d3
8005672: Clean up some changes to GC logging with GCCause's
jmasa
parents:
6885
diff
changeset
|
831 gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"("SIZE_FORMAT")]", |
| 0 | 832 level(), short_name(), s, used(), capacity()); |
| 833 } else { | |
|
7455
0b54ffe4c2d3
8005672: Clean up some changes to GC logging with GCCause's
jmasa
parents:
6885
diff
changeset
|
834 gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"K("SIZE_FORMAT"K)]", |
| 0 | 835 level(), short_name(), s, used() / K, capacity() / K); |
| 836 } | |
| 837 } | |
| 838 if (Verbose) { | |
| 839 gclog_or_tty->print(" "SIZE_FORMAT"("SIZE_FORMAT")", | |
| 840 gch->used(), gch->capacity()); | |
| 841 } else { | |
| 842 gclog_or_tty->print(" "SIZE_FORMAT"K("SIZE_FORMAT"K)", | |
| 843 gch->used() / K, gch->capacity() / K); | |
| 844 } | |
| 845 } | |
| 846 | |
| 847 size_t | |
| 848 ConcurrentMarkSweepGeneration::contiguous_available() const { | |
| 849 // dld proposes an improvement in precision here. If the committed | |
| 850 // part of the space ends in a free block we should add that to | |
| 851 // uncommitted size in the calculation below. Will make this | |
| 852 // change later, staying with the approximation below for the | |
| 853 // time being. -- ysr. | |
| 854 return MAX2(_virtual_space.uncommitted_size(), unsafe_max_alloc_nogc()); | |
| 855 } | |
| 856 | |
| 857 size_t | |
| 858 ConcurrentMarkSweepGeneration::unsafe_max_alloc_nogc() const { | |
| 859 return _cmsSpace->max_alloc_in_words() * HeapWordSize; | |
| 860 } | |
| 861 | |
| 862 size_t ConcurrentMarkSweepGeneration::max_available() const { | |
| 863 return free() + _virtual_space.uncommitted_size(); | |
| 864 } | |
| 865 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
866 bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
867 size_t available = max_available(); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
868 size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average(); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
869 bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
870 if (Verbose && PrintGCDetails) { |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
871 gclog_or_tty->print_cr( |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
872 "CMS: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
873 "max_promo("SIZE_FORMAT")", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
874 res? "":" not", available, res? ">=":"<", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
875 av_promo, max_promotion_in_bytes); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
876 } |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
877 return res; |
| 0 | 878 } |
| 879 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
880 // At a promotion failure dump information on block layout in heap |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
881 // (cms old generation). |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
882 void ConcurrentMarkSweepGeneration::promotion_failure_occurred() { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
883 if (CMSDumpAtPromotionFailure) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
884 cmsSpace()->dump_at_safepoint_with_locks(collector(), gclog_or_tty); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
885 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
886 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
887 |
| 0 | 888 CompactibleSpace* |
| 889 ConcurrentMarkSweepGeneration::first_compaction_space() const { | |
| 890 return _cmsSpace; | |
| 891 } | |
| 892 | |
| 893 void ConcurrentMarkSweepGeneration::reset_after_compaction() { | |
| 894 // Clear the promotion information. These pointers can be adjusted | |
| 895 // along with all the other pointers into the heap but | |
| 896 // compaction is expected to be a rare event with | |
| 897 // a heap using cms so don't do it without seeing the need. | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
898 if (CollectedHeap::use_parallel_gc_threads()) { |
| 0 | 899 for (uint i = 0; i < ParallelGCThreads; i++) { |
| 900 _par_gc_thread_states[i]->promo.reset(); | |
| 901 } | |
| 902 } | |
| 903 } | |
| 904 | |
| 905 void ConcurrentMarkSweepGeneration::space_iterate(SpaceClosure* blk, bool usedOnly) { | |
| 906 blk->do_space(_cmsSpace); | |
| 907 } | |
| 908 | |
| 909 void ConcurrentMarkSweepGeneration::compute_new_size() { | |
| 910 assert_locked_or_safepoint(Heap_lock); | |
| 911 | |
| 912 // If incremental collection failed, we just want to expand | |
| 913 // to the limit. | |
| 914 if (incremental_collection_failed()) { | |
| 915 clear_incremental_collection_failed(); | |
| 916 grow_to_reserved(); | |
| 917 return; | |
| 918 } | |
| 919 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
920 // Compute some numbers about the state of the heap. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
921 const size_t used_after_gc = used(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
922 const size_t capacity_after_gc = capacity(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
923 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
924 CardGeneration::compute_new_size(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
925 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
926 // Reset again after a possible resizing |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
927 cmsSpace()->reset_after_compaction(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
928 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
929 assert(used() == used_after_gc && used_after_gc <= capacity(), |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
930 err_msg("used: " SIZE_FORMAT " used_after_gc: " SIZE_FORMAT |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
931 " capacity: " SIZE_FORMAT, used(), used_after_gc, capacity())); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
932 } |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
933 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
934 void ConcurrentMarkSweepGeneration::compute_new_size_free_list() { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
935 assert_locked_or_safepoint(Heap_lock); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
936 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
937 // If incremental collection failed, we just want to expand |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
938 // to the limit. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
939 if (incremental_collection_failed()) { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
940 clear_incremental_collection_failed(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
941 grow_to_reserved(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
942 return; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
943 } |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
944 |
| 0 | 945 double free_percentage = ((double) free()) / capacity(); |
| 946 double desired_free_percentage = (double) MinHeapFreeRatio / 100; | |
| 947 double maximum_free_percentage = (double) MaxHeapFreeRatio / 100; | |
| 948 | |
| 949 // compute expansion delta needed for reaching desired free percentage | |
| 950 if (free_percentage < desired_free_percentage) { | |
| 951 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); | |
| 952 assert(desired_capacity >= capacity(), "invalid expansion size"); | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
953 size_t expand_bytes = MAX2(desired_capacity - capacity(), MinHeapDeltaBytes); |
| 0 | 954 if (PrintGCDetails && Verbose) { |
| 955 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); | |
| 956 gclog_or_tty->print_cr("\nFrom compute_new_size: "); | |
| 957 gclog_or_tty->print_cr(" Free fraction %f", free_percentage); | |
| 958 gclog_or_tty->print_cr(" Desired free fraction %f", | |
| 959 desired_free_percentage); | |
| 960 gclog_or_tty->print_cr(" Maximum free fraction %f", | |
| 961 maximum_free_percentage); | |
| 962 gclog_or_tty->print_cr(" Capactiy "SIZE_FORMAT, capacity()/1000); | |
| 963 gclog_or_tty->print_cr(" Desired capacity "SIZE_FORMAT, | |
| 964 desired_capacity/1000); | |
| 965 int prev_level = level() - 1; | |
| 966 if (prev_level >= 0) { | |
| 967 size_t prev_size = 0; | |
| 968 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 969 Generation* prev_gen = gch->_gens[prev_level]; | |
| 970 prev_size = prev_gen->capacity(); | |
| 971 gclog_or_tty->print_cr(" Younger gen size "SIZE_FORMAT, | |
| 972 prev_size/1000); | |
| 973 } | |
| 974 gclog_or_tty->print_cr(" unsafe_max_alloc_nogc "SIZE_FORMAT, | |
| 975 unsafe_max_alloc_nogc()/1000); | |
| 976 gclog_or_tty->print_cr(" contiguous available "SIZE_FORMAT, | |
| 977 contiguous_available()/1000); | |
| 978 gclog_or_tty->print_cr(" Expand by "SIZE_FORMAT" (bytes)", | |
| 979 expand_bytes); | |
| 980 } | |
| 981 // safe if expansion fails | |
| 982 expand(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio); | |
| 983 if (PrintGCDetails && Verbose) { | |
| 984 gclog_or_tty->print_cr(" Expanded free fraction %f", | |
| 985 ((double) free()) / capacity()); | |
| 986 } | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
987 } else { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
988 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
989 assert(desired_capacity <= capacity(), "invalid expansion size"); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
990 size_t shrink_bytes = capacity() - desired_capacity; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
991 // Don't shrink unless the delta is greater than the minimum shrink we want |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
992 if (shrink_bytes >= MinHeapDeltaBytes) { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
993 shrink_free_list_by(shrink_bytes); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
994 } |
| 0 | 995 } |
| 996 } | |
| 997 | |
| 998 Mutex* ConcurrentMarkSweepGeneration::freelistLock() const { | |
| 999 return cmsSpace()->freelistLock(); | |
| 1000 } | |
| 1001 | |
| 1002 HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size, | |
| 1003 bool tlab) { | |
| 1004 CMSSynchronousYieldRequest yr; | |
| 1005 MutexLockerEx x(freelistLock(), | |
| 1006 Mutex::_no_safepoint_check_flag); | |
| 1007 return have_lock_and_allocate(size, tlab); | |
| 1008 } | |
| 1009 | |
| 1010 HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size, | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1011 bool tlab /* ignored */) { |
| 0 | 1012 assert_lock_strong(freelistLock()); |
| 1013 size_t adjustedSize = CompactibleFreeListSpace::adjustObjectSize(size); | |
| 1014 HeapWord* res = cmsSpace()->allocate(adjustedSize); | |
| 1015 // Allocate the object live (grey) if the background collector has | |
| 1016 // started marking. This is necessary because the marker may | |
| 1017 // have passed this address and consequently this object will | |
| 1018 // not otherwise be greyed and would be incorrectly swept up. | |
| 1019 // Note that if this object contains references, the writing | |
| 1020 // of those references will dirty the card containing this object | |
| 1021 // allowing the object to be blackened (and its references scanned) | |
| 1022 // either during a preclean phase or at the final checkpoint. | |
| 1023 if (res != NULL) { | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1024 // We may block here with an uninitialized object with |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1025 // its mark-bit or P-bits not yet set. Such objects need |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1026 // to be safely navigable by block_start(). |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1027 assert(oop(res)->klass_or_null() == NULL, "Object should be uninitialized here."); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
1028 assert(!((FreeChunk*)res)->is_free(), "Error, block will look free but show wrong size"); |
| 0 | 1029 collector()->direct_allocated(res, adjustedSize); |
| 1030 _direct_allocated_words += adjustedSize; | |
| 1031 // allocation counters | |
| 1032 NOT_PRODUCT( | |
| 1033 _numObjectsAllocated++; | |
| 1034 _numWordsAllocated += (int)adjustedSize; | |
| 1035 ) | |
| 1036 } | |
| 1037 return res; | |
| 1038 } | |
| 1039 | |
| 1040 // In the case of direct allocation by mutators in a generation that | |
| 1041 // is being concurrently collected, the object must be allocated | |
| 1042 // live (grey) if the background collector has started marking. | |
| 1043 // This is necessary because the marker may | |
| 1044 // have passed this address and consequently this object will | |
| 1045 // not otherwise be greyed and would be incorrectly swept up. | |
| 1046 // Note that if this object contains references, the writing | |
| 1047 // of those references will dirty the card containing this object | |
| 1048 // allowing the object to be blackened (and its references scanned) | |
| 1049 // either during a preclean phase or at the final checkpoint. | |
| 1050 void CMSCollector::direct_allocated(HeapWord* start, size_t size) { | |
| 1051 assert(_markBitMap.covers(start, size), "Out of bounds"); | |
| 1052 if (_collectorState >= Marking) { | |
| 1053 MutexLockerEx y(_markBitMap.lock(), | |
| 1054 Mutex::_no_safepoint_check_flag); | |
| 1055 // [see comments preceding SweepClosure::do_blk() below for details] | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1056 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1057 // Can the P-bits be deleted now? JJJ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1058 // |
| 0 | 1059 // 1. need to mark the object as live so it isn't collected |
| 1060 // 2. need to mark the 2nd bit to indicate the object may be uninitialized | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1061 // 3. need to mark the end of the object so marking, precleaning or sweeping |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1062 // can skip over uninitialized or unparsable objects. An allocated |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1063 // object is considered uninitialized for our purposes as long as |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1064 // its klass word is NULL. All old gen objects are parsable |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1065 // as soon as they are initialized.) |
| 0 | 1066 _markBitMap.mark(start); // object is live |
| 1067 _markBitMap.mark(start + 1); // object is potentially uninitialized? | |
| 1068 _markBitMap.mark(start + size - 1); | |
| 1069 // mark end of object | |
| 1070 } | |
| 1071 // check that oop looks uninitialized | |
| 187 | 1072 assert(oop(start)->klass_or_null() == NULL, "_klass should be NULL"); |
| 0 | 1073 } |
| 1074 | |
| 1075 void CMSCollector::promoted(bool par, HeapWord* start, | |
| 1076 bool is_obj_array, size_t obj_size) { | |
| 1077 assert(_markBitMap.covers(start), "Out of bounds"); | |
| 1078 // See comment in direct_allocated() about when objects should | |
| 1079 // be allocated live. | |
| 1080 if (_collectorState >= Marking) { | |
| 1081 // we already hold the marking bit map lock, taken in | |
| 1082 // the prologue | |
| 1083 if (par) { | |
| 1084 _markBitMap.par_mark(start); | |
| 1085 } else { | |
| 1086 _markBitMap.mark(start); | |
| 1087 } | |
| 1088 // We don't need to mark the object as uninitialized (as | |
| 1089 // in direct_allocated above) because this is being done with the | |
| 1090 // world stopped and the object will be initialized by the | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1091 // time the marking, precleaning or sweeping get to look at it. |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1092 // But see the code for copying objects into the CMS generation, |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1093 // where we need to ensure that concurrent readers of the |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1094 // block offset table are able to safely navigate a block that |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1095 // is in flux from being free to being allocated (and in |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1096 // transition while being copied into) and subsequently |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1097 // becoming a bona-fide object when the copy/promotion is complete. |
| 0 | 1098 assert(SafepointSynchronize::is_at_safepoint(), |
| 1099 "expect promotion only at safepoints"); | |
| 1100 | |
| 1101 if (_collectorState < Sweeping) { | |
| 1102 // Mark the appropriate cards in the modUnionTable, so that | |
| 1103 // this object gets scanned before the sweep. If this is | |
| 1104 // not done, CMS generation references in the object might | |
| 1105 // not get marked. | |
| 1106 // For the case of arrays, which are otherwise precisely | |
| 1107 // marked, we need to dirty the entire array, not just its head. | |
| 1108 if (is_obj_array) { | |
| 1109 // The [par_]mark_range() method expects mr.end() below to | |
| 1110 // be aligned to the granularity of a bit's representation | |
| 1111 // in the heap. In the case of the MUT below, that's a | |
| 1112 // card size. | |
| 1113 MemRegion mr(start, | |
| 1114 (HeapWord*)round_to((intptr_t)(start + obj_size), | |
| 1115 CardTableModRefBS::card_size /* bytes */)); | |
| 1116 if (par) { | |
| 1117 _modUnionTable.par_mark_range(mr); | |
| 1118 } else { | |
| 1119 _modUnionTable.mark_range(mr); | |
| 1120 } | |
| 1121 } else { // not an obj array; we can just mark the head | |
| 1122 if (par) { | |
| 1123 _modUnionTable.par_mark(start); | |
| 1124 } else { | |
| 1125 _modUnionTable.mark(start); | |
| 1126 } | |
| 1127 } | |
| 1128 } | |
| 1129 } | |
| 1130 } | |
| 1131 | |
| 1132 static inline size_t percent_of_space(Space* space, HeapWord* addr) | |
| 1133 { | |
| 1134 size_t delta = pointer_delta(addr, space->bottom()); | |
| 1135 return (size_t)(delta * 100.0 / (space->capacity() / HeapWordSize)); | |
| 1136 } | |
| 1137 | |
| 1138 void CMSCollector::icms_update_allocation_limits() | |
| 1139 { | |
| 1140 Generation* gen0 = GenCollectedHeap::heap()->get_gen(0); | |
| 1141 EdenSpace* eden = gen0->as_DefNewGeneration()->eden(); | |
| 1142 | |
| 1143 const unsigned int duty_cycle = stats().icms_update_duty_cycle(); | |
| 1144 if (CMSTraceIncrementalPacing) { | |
| 1145 stats().print(); | |
| 1146 } | |
| 1147 | |
| 1148 assert(duty_cycle <= 100, "invalid duty cycle"); | |
| 1149 if (duty_cycle != 0) { | |
| 1150 // The duty_cycle is a percentage between 0 and 100; convert to words and | |
| 1151 // then compute the offset from the endpoints of the space. | |
| 1152 size_t free_words = eden->free() / HeapWordSize; | |
| 1153 double free_words_dbl = (double)free_words; | |
| 1154 size_t duty_cycle_words = (size_t)(free_words_dbl * duty_cycle / 100.0); | |
| 1155 size_t offset_words = (free_words - duty_cycle_words) / 2; | |
| 1156 | |
| 1157 _icms_start_limit = eden->top() + offset_words; | |
| 1158 _icms_stop_limit = eden->end() - offset_words; | |
| 1159 | |
| 1160 // The limits may be adjusted (shifted to the right) by | |
| 1161 // CMSIncrementalOffset, to allow the application more mutator time after a | |
| 1162 // young gen gc (when all mutators were stopped) and before CMS starts and | |
| 1163 // takes away one or more cpus. | |
| 1164 if (CMSIncrementalOffset != 0) { | |
| 1165 double adjustment_dbl = free_words_dbl * CMSIncrementalOffset / 100.0; | |
| 1166 size_t adjustment = (size_t)adjustment_dbl; | |
| 1167 HeapWord* tmp_stop = _icms_stop_limit + adjustment; | |
| 1168 if (tmp_stop > _icms_stop_limit && tmp_stop < eden->end()) { | |
| 1169 _icms_start_limit += adjustment; | |
| 1170 _icms_stop_limit = tmp_stop; | |
| 1171 } | |
| 1172 } | |
| 1173 } | |
| 1174 if (duty_cycle == 0 || (_icms_start_limit == _icms_stop_limit)) { | |
| 1175 _icms_start_limit = _icms_stop_limit = eden->end(); | |
| 1176 } | |
| 1177 | |
| 1178 // Install the new start limit. | |
| 1179 eden->set_soft_end(_icms_start_limit); | |
| 1180 | |
| 1181 if (CMSTraceIncrementalMode) { | |
| 1182 gclog_or_tty->print(" icms alloc limits: " | |
| 1183 PTR_FORMAT "," PTR_FORMAT | |
| 1184 " (" SIZE_FORMAT "%%," SIZE_FORMAT "%%) ", | |
| 1185 _icms_start_limit, _icms_stop_limit, | |
| 1186 percent_of_space(eden, _icms_start_limit), | |
| 1187 percent_of_space(eden, _icms_stop_limit)); | |
| 1188 if (Verbose) { | |
| 1189 gclog_or_tty->print("eden: "); | |
| 1190 eden->print_on(gclog_or_tty); | |
| 1191 } | |
| 1192 } | |
| 1193 } | |
| 1194 | |
| 1195 // Any changes here should try to maintain the invariant | |
| 1196 // that if this method is called with _icms_start_limit | |
| 1197 // and _icms_stop_limit both NULL, then it should return NULL | |
| 1198 // and not notify the icms thread. | |
| 1199 HeapWord* | |
| 1200 CMSCollector::allocation_limit_reached(Space* space, HeapWord* top, | |
| 1201 size_t word_size) | |
| 1202 { | |
| 1203 // A start_limit equal to end() means the duty cycle is 0, so treat that as a | |
| 1204 // nop. | |
| 1205 if (CMSIncrementalMode && _icms_start_limit != space->end()) { | |
| 1206 if (top <= _icms_start_limit) { | |
| 1207 if (CMSTraceIncrementalMode) { | |
| 1208 space->print_on(gclog_or_tty); | |
| 1209 gclog_or_tty->stamp(); | |
| 1210 gclog_or_tty->print_cr(" start limit top=" PTR_FORMAT | |
| 1211 ", new limit=" PTR_FORMAT | |
| 1212 " (" SIZE_FORMAT "%%)", | |
| 1213 top, _icms_stop_limit, | |
| 1214 percent_of_space(space, _icms_stop_limit)); | |
| 1215 } | |
| 1216 ConcurrentMarkSweepThread::start_icms(); | |
| 1217 assert(top < _icms_stop_limit, "Tautology"); | |
| 1218 if (word_size < pointer_delta(_icms_stop_limit, top)) { | |
| 1219 return _icms_stop_limit; | |
| 1220 } | |
| 1221 | |
| 1222 // The allocation will cross both the _start and _stop limits, so do the | |
| 1223 // stop notification also and return end(). | |
| 1224 if (CMSTraceIncrementalMode) { | |
| 1225 space->print_on(gclog_or_tty); | |
| 1226 gclog_or_tty->stamp(); | |
| 1227 gclog_or_tty->print_cr(" +stop limit top=" PTR_FORMAT | |
| 1228 ", new limit=" PTR_FORMAT | |
| 1229 " (" SIZE_FORMAT "%%)", | |
| 1230 top, space->end(), | |
| 1231 percent_of_space(space, space->end())); | |
| 1232 } | |
| 1233 ConcurrentMarkSweepThread::stop_icms(); | |
| 1234 return space->end(); | |
| 1235 } | |
| 1236 | |
| 1237 if (top <= _icms_stop_limit) { | |
| 1238 if (CMSTraceIncrementalMode) { | |
| 1239 space->print_on(gclog_or_tty); | |
| 1240 gclog_or_tty->stamp(); | |
| 1241 gclog_or_tty->print_cr(" stop limit top=" PTR_FORMAT | |
| 1242 ", new limit=" PTR_FORMAT | |
| 1243 " (" SIZE_FORMAT "%%)", | |
| 1244 top, space->end(), | |
| 1245 percent_of_space(space, space->end())); | |
| 1246 } | |
| 1247 ConcurrentMarkSweepThread::stop_icms(); | |
| 1248 return space->end(); | |
| 1249 } | |
| 1250 | |
| 1251 if (CMSTraceIncrementalMode) { | |
| 1252 space->print_on(gclog_or_tty); | |
| 1253 gclog_or_tty->stamp(); | |
| 1254 gclog_or_tty->print_cr(" end limit top=" PTR_FORMAT | |
| 1255 ", new limit=" PTR_FORMAT, | |
| 1256 top, NULL); | |
| 1257 } | |
| 1258 } | |
| 1259 | |
| 1260 return NULL; | |
| 1261 } | |
| 1262 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1263 oop ConcurrentMarkSweepGeneration::promote(oop obj, size_t obj_size) { |
| 0 | 1264 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); |
| 1265 // allocate, copy and if necessary update promoinfo -- | |
| 1266 // delegate to underlying space. | |
| 1267 assert_lock_strong(freelistLock()); | |
| 1268 | |
| 1269 #ifndef PRODUCT | |
| 1270 if (Universe::heap()->promotion_should_fail()) { | |
| 1271 return NULL; | |
| 1272 } | |
| 1273 #endif // #ifndef PRODUCT | |
| 1274 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1275 oop res = _cmsSpace->promote(obj, obj_size); |
| 0 | 1276 if (res == NULL) { |
| 1277 // expand and retry | |
| 1278 size_t s = _cmsSpace->expansionSpaceRequired(obj_size); // HeapWords | |
| 1279 expand(s*HeapWordSize, MinHeapDeltaBytes, | |
| 1280 CMSExpansionCause::_satisfy_promotion); | |
| 1281 // Since there's currently no next generation, we don't try to promote | |
| 1282 // into a more senior generation. | |
| 1283 assert(next_gen() == NULL, "assumption, based upon which no attempt " | |
| 1284 "is made to pass on a possibly failing " | |
| 1285 "promotion to next generation"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1286 res = _cmsSpace->promote(obj, obj_size); |
| 0 | 1287 } |
| 1288 if (res != NULL) { | |
| 1289 // See comment in allocate() about when objects should | |
| 1290 // be allocated live. | |
| 1291 assert(obj->is_oop(), "Will dereference klass pointer below"); | |
| 1292 collector()->promoted(false, // Not parallel | |
| 1293 (HeapWord*)res, obj->is_objArray(), obj_size); | |
| 1294 // promotion counters | |
| 1295 NOT_PRODUCT( | |
| 1296 _numObjectsPromoted++; | |
| 1297 _numWordsPromoted += | |
| 1298 (int)(CompactibleFreeListSpace::adjustObjectSize(obj->size())); | |
| 1299 ) | |
| 1300 } | |
| 1301 return res; | |
| 1302 } | |
| 1303 | |
| 1304 | |
| 1305 HeapWord* | |
| 1306 ConcurrentMarkSweepGeneration::allocation_limit_reached(Space* space, | |
| 1307 HeapWord* top, | |
| 1308 size_t word_sz) | |
| 1309 { | |
| 1310 return collector()->allocation_limit_reached(space, top, word_sz); | |
| 1311 } | |
| 1312 | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1313 // IMPORTANT: Notes on object size recognition in CMS. |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1314 // --------------------------------------------------- |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1315 // A block of storage in the CMS generation is always in |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1316 // one of three states. A free block (FREE), an allocated |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1317 // object (OBJECT) whose size() method reports the correct size, |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1318 // and an intermediate state (TRANSIENT) in which its size cannot |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1319 // be accurately determined. |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1320 // STATE IDENTIFICATION: (32 bit and 64 bit w/o COOPS) |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1321 // ----------------------------------------------------- |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1322 // FREE: klass_word & 1 == 1; mark_word holds block size |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1323 // |
|
1777
179464550c7d
6983930: CMS: Various small cleanups ca September 2010
ysr
parents:
1720
diff
changeset
|
1324 // OBJECT: klass_word installed; klass_word != 0 && klass_word & 1 == 0; |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1325 // obj->size() computes correct size |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1326 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1327 // TRANSIENT: klass_word == 0; size is indeterminate until we become an OBJECT |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1328 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1329 // STATE IDENTIFICATION: (64 bit+COOPS) |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1330 // ------------------------------------ |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1331 // FREE: mark_word & CMS_FREE_BIT == 1; mark_word & ~CMS_FREE_BIT gives block_size |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1332 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1333 // OBJECT: klass_word installed; klass_word != 0; |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1334 // obj->size() computes correct size |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1335 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1336 // TRANSIENT: klass_word == 0; size is indeterminate until we become an OBJECT |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1337 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1338 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1339 // STATE TRANSITION DIAGRAM |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1340 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1341 // mut / parnew mut / parnew |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1342 // FREE --------------------> TRANSIENT ---------------------> OBJECT --| |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1343 // ^ | |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1344 // |------------------------ DEAD <------------------------------------| |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1345 // sweep mut |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1346 // |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1347 // While a block is in TRANSIENT state its size cannot be determined |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1348 // so readers will either need to come back later or stall until |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1349 // the size can be determined. Note that for the case of direct |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1350 // allocation, P-bits, when available, may be used to determine the |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1351 // size of an object that may not yet have been initialized. |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1352 |
| 0 | 1353 // Things to support parallel young-gen collection. |
| 1354 oop | |
| 1355 ConcurrentMarkSweepGeneration::par_promote(int thread_num, | |
| 1356 oop old, markOop m, | |
| 1357 size_t word_sz) { | |
| 1358 #ifndef PRODUCT | |
| 1359 if (Universe::heap()->promotion_should_fail()) { | |
| 1360 return NULL; | |
| 1361 } | |
| 1362 #endif // #ifndef PRODUCT | |
| 1363 | |
| 1364 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
| 1365 PromotionInfo* promoInfo = &ps->promo; | |
| 1366 // if we are tracking promotions, then first ensure space for | |
| 1367 // promotion (including spooling space for saving header if necessary). | |
| 1368 // then allocate and copy, then track promoted info if needed. | |
| 1369 // When tracking (see PromotionInfo::track()), the mark word may | |
| 1370 // be displaced and in this case restoration of the mark word | |
| 1371 // occurs in the (oop_since_save_marks_)iterate phase. | |
| 1372 if (promoInfo->tracking() && !promoInfo->ensure_spooling_space()) { | |
| 1373 // Out of space for allocating spooling buffers; | |
| 1374 // try expanding and allocating spooling buffers. | |
| 1375 if (!expand_and_ensure_spooling_space(promoInfo)) { | |
| 1376 return NULL; | |
| 1377 } | |
| 1378 } | |
| 1379 assert(promoInfo->has_spooling_space(), "Control point invariant"); | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1380 const size_t alloc_sz = CompactibleFreeListSpace::adjustObjectSize(word_sz); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1381 HeapWord* obj_ptr = ps->lab.alloc(alloc_sz); |
| 0 | 1382 if (obj_ptr == NULL) { |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1383 obj_ptr = expand_and_par_lab_allocate(ps, alloc_sz); |
| 0 | 1384 if (obj_ptr == NULL) { |
| 1385 return NULL; | |
| 1386 } | |
| 1387 } | |
| 1388 oop obj = oop(obj_ptr); | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1389 OrderAccess::storestore(); |
| 187 | 1390 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here."); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
1391 assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size"); |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1392 // IMPORTANT: See note on object initialization for CMS above. |
| 0 | 1393 // Otherwise, copy the object. Here we must be careful to insert the |
| 1394 // klass pointer last, since this marks the block as an allocated object. | |
| 187 | 1395 // Except with compressed oops it's the mark word. |
| 0 | 1396 HeapWord* old_ptr = (HeapWord*)old; |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1397 // Restore the mark word copied above. |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1398 obj->set_mark(m); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1399 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here."); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
1400 assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size"); |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1401 OrderAccess::storestore(); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1402 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1403 if (UseCompressedKlassPointers) { |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1404 // Copy gap missed by (aligned) header size calculation below |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1405 obj->set_klass_gap(old->klass_gap()); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1406 } |
| 0 | 1407 if (word_sz > (size_t)oopDesc::header_size()) { |
| 1408 Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(), | |
| 1409 obj_ptr + oopDesc::header_size(), | |
| 1410 word_sz - oopDesc::header_size()); | |
| 1411 } | |
| 187 | 1412 |
| 0 | 1413 // Now we can track the promoted object, if necessary. We take care |
| 1521 | 1414 // to delay the transition from uninitialized to full object |
| 0 | 1415 // (i.e., insertion of klass pointer) until after, so that it |
| 1416 // atomically becomes a promoted object. | |
| 1417 if (promoInfo->tracking()) { | |
| 1418 promoInfo->track((PromotedObject*)obj, old->klass()); | |
| 1419 } | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1420 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here."); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
1421 assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size"); |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1422 assert(old->is_oop(), "Will use and dereference old klass ptr below"); |
| 187 | 1423 |
| 1424 // Finally, install the klass pointer (this should be volatile). | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1425 OrderAccess::storestore(); |
| 0 | 1426 obj->set_klass(old->klass()); |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1427 // We should now be able to calculate the right size for this object |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1428 assert(obj->is_oop() && obj->size() == (int)word_sz, "Error, incorrect size computed for promoted object"); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1429 |
| 0 | 1430 collector()->promoted(true, // parallel |
| 1431 obj_ptr, old->is_objArray(), word_sz); | |
| 1432 | |
| 1433 NOT_PRODUCT( | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1434 Atomic::inc_ptr(&_numObjectsPromoted); |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1704
diff
changeset
|
1435 Atomic::add_ptr(alloc_sz, &_numWordsPromoted); |
| 0 | 1436 ) |
| 1437 | |
| 1438 return obj; | |
| 1439 } | |
| 1440 | |
| 1441 void | |
| 1442 ConcurrentMarkSweepGeneration:: | |
| 1443 par_promote_alloc_undo(int thread_num, | |
| 1444 HeapWord* obj, size_t word_sz) { | |
| 1445 // CMS does not support promotion undo. | |
| 1446 ShouldNotReachHere(); | |
| 1447 } | |
| 1448 | |
| 1449 void | |
| 1450 ConcurrentMarkSweepGeneration:: | |
| 1451 par_promote_alloc_done(int thread_num) { | |
| 1452 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
1453 ps->lab.retire(thread_num); |
| 0 | 1454 } |
| 1455 | |
| 1456 void | |
| 1457 ConcurrentMarkSweepGeneration:: | |
| 1458 par_oop_since_save_marks_iterate_done(int thread_num) { | |
| 1459 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num]; | |
| 1460 ParScanWithoutBarrierClosure* dummy_cl = NULL; | |
| 1461 ps->promo.promoted_oops_iterate_nv(dummy_cl); | |
| 1462 } | |
| 1463 | |
| 1464 bool ConcurrentMarkSweepGeneration::should_collect(bool full, | |
| 1465 size_t size, | |
| 1466 bool tlab) | |
| 1467 { | |
| 1468 // We allow a STW collection only if a full | |
| 1469 // collection was requested. | |
| 1470 return full || should_allocate(size, tlab); // FIX ME !!! | |
| 1471 // This and promotion failure handling are connected at the | |
| 1472 // hip and should be fixed by untying them. | |
| 1473 } | |
| 1474 | |
| 1475 bool CMSCollector::shouldConcurrentCollect() { | |
| 1476 if (_full_gc_requested) { | |
| 1477 if (Verbose && PrintGCDetails) { | |
| 1478 gclog_or_tty->print_cr("CMSCollector: collect because of explicit " | |
|
1520
bb843ebc7c55
6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents:
1518
diff
changeset
|
1479 " gc request (or gc_locker)"); |
| 0 | 1480 } |
| 1481 return true; | |
| 1482 } | |
| 1483 | |
| 1484 // For debugging purposes, change the type of collection. | |
| 1485 // If the rotation is not on the concurrent collection | |
| 1486 // type, don't start a concurrent collection. | |
| 1487 NOT_PRODUCT( | |
| 1488 if (RotateCMSCollectionTypes && | |
| 1489 (_cmsGen->debug_collection_type() != | |
| 1490 ConcurrentMarkSweepGeneration::Concurrent_collection_type)) { | |
| 1491 assert(_cmsGen->debug_collection_type() != | |
| 1492 ConcurrentMarkSweepGeneration::Unknown_collection_type, | |
| 1493 "Bad cms collection type"); | |
| 1494 return false; | |
| 1495 } | |
| 1496 ) | |
| 1497 | |
| 1498 FreelistLocker x(this); | |
| 1499 // ------------------------------------------------------------------ | |
| 1500 // Print out lots of information which affects the initiation of | |
| 1501 // a collection. | |
| 1502 if (PrintCMSInitiationStatistics && stats().valid()) { | |
| 1503 gclog_or_tty->print("CMSCollector shouldConcurrentCollect: "); | |
| 1504 gclog_or_tty->stamp(); | |
| 1505 gclog_or_tty->print_cr(""); | |
| 1506 stats().print_on(gclog_or_tty); | |
| 1507 gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f", | |
| 1508 stats().time_until_cms_gen_full()); | |
| 1509 gclog_or_tty->print_cr("free="SIZE_FORMAT, _cmsGen->free()); | |
| 1510 gclog_or_tty->print_cr("contiguous_available="SIZE_FORMAT, | |
| 1511 _cmsGen->contiguous_available()); | |
| 1512 gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate()); | |
| 1513 gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate()); | |
| 1514 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
|
1515 gclog_or_tty->print_cr("initiatingOccupancy=%3.7f", _cmsGen->initiating_occupancy()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1516 gclog_or_tty->print_cr("metadata initialized %d", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1517 MetaspaceGC::should_concurrent_collect()); |
| 0 | 1518 } |
| 1519 // ------------------------------------------------------------------ | |
| 1520 | |
| 1521 // If the estimated time to complete a cms collection (cms_duration()) | |
| 1522 // is less than the estimated time remaining until the cms generation | |
| 1523 // is full, start a collection. | |
| 1524 if (!UseCMSInitiatingOccupancyOnly) { | |
| 1525 if (stats().valid()) { | |
| 1526 if (stats().time_until_cms_start() == 0.0) { | |
| 1527 return true; | |
| 1528 } | |
| 1529 } else { | |
| 1530 // We want to conservatively collect somewhat early in order | |
| 1531 // to try and "bootstrap" our CMS/promotion statistics; | |
| 1532 // this branch will not fire after the first successful CMS | |
| 1533 // collection because the stats should then be valid. | |
| 1534 if (_cmsGen->occupancy() >= _bootstrap_occupancy) { | |
| 1535 if (Verbose && PrintGCDetails) { | |
| 1536 gclog_or_tty->print_cr( | |
| 1537 " CMSCollector: collect for bootstrapping statistics:" | |
| 1538 " occupancy = %f, boot occupancy = %f", _cmsGen->occupancy(), | |
| 1539 _bootstrap_occupancy); | |
| 1540 } | |
| 1541 return true; | |
| 1542 } | |
| 1543 } | |
| 1544 } | |
| 1545 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1546 // Otherwise, we start a collection cycle if |
| 0 | 1547 // old gen want a collection cycle started. Each may use |
| 1548 // an appropriate criterion for making this decision. | |
| 1549 // 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
|
1550 // 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
|
1551 if (_cmsGen->should_concurrent_collect()) { |
| 0 | 1552 if (Verbose && PrintGCDetails) { |
| 1553 gclog_or_tty->print_cr("CMS old gen initiated"); | |
| 1554 } | |
| 1555 return true; | |
| 1556 } | |
| 1557 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1558 // 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
|
1559 // 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
|
1560 // late anyway. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1561 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1562 assert(gch->collector_policy()->is_two_generation_policy(), |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1563 "You may want to check the correctness of the following"); |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
1564 if (gch->incremental_collection_will_fail(true /* consult_young */)) { |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
1565 if (Verbose && PrintGCDetails) { |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1566 gclog_or_tty->print("CMSCollector: collect because incremental collection will fail "); |
| 0 | 1567 } |
| 1568 return true; | |
| 1569 } | |
| 1570 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1571 if (MetaspaceGC::should_concurrent_collect()) { |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1572 if (Verbose && PrintGCDetails) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1573 gclog_or_tty->print("CMSCollector: collect for metadata allocation "); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1574 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1575 return true; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1576 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1577 |
| 0 | 1578 return false; |
| 1579 } | |
| 1580 | |
| 1581 // Clear _expansion_cause fields of constituent generations | |
| 1582 void CMSCollector::clear_expansion_cause() { | |
| 1583 _cmsGen->clear_expansion_cause(); | |
| 1584 } | |
| 1585 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1586 // 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
|
1587 // 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
|
1588 // 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
|
1589 // 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
|
1590 // 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
|
1591 // UseCMSInitiatingOccupancyOnly. This also has the advantage of |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1592 // 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
|
1593 // collections. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1594 // 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
|
1595 // conditions hold: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1596 // . our current occupancy exceeds the configured initiating occupancy |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1597 // for this generation, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1598 // . 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
|
1599 // expansion, done a collection of this generation, or |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1600 // . 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
|
1601 // 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
|
1602 // 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
|
1603 // 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
|
1604 // the generation, etc... or ... |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1605 // [.(currently done by CMSCollector::shouldConcurrentCollect() only for |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1606 // the case of the old generation; see CR 6543076): |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1607 // 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
|
1608 // 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
|
1609 bool ConcurrentMarkSweepGeneration::should_concurrent_collect() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1610 |
| 0 | 1611 assert_lock_strong(freelistLock()); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1612 if (occupancy() > initiating_occupancy()) { |
| 0 | 1613 if (PrintGCDetails && Verbose) { |
| 1614 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
|
1615 short_name(), occupancy(), initiating_occupancy()); |
| 0 | 1616 } |
| 1617 return true; | |
| 1618 } | |
| 1619 if (UseCMSInitiatingOccupancyOnly) { | |
| 1620 return false; | |
| 1621 } | |
| 1622 if (expansion_cause() == CMSExpansionCause::_satisfy_allocation) { | |
| 1623 if (PrintGCDetails && Verbose) { | |
| 1624 gclog_or_tty->print(" %s: collect because expanded for allocation ", | |
| 1625 short_name()); | |
| 1626 } | |
| 1627 return true; | |
| 1628 } | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1629 if (_cmsSpace->should_concurrent_collect()) { |
| 0 | 1630 if (PrintGCDetails && Verbose) { |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
1631 gclog_or_tty->print(" %s: collect because cmsSpace says so ", |
| 0 | 1632 short_name()); |
| 1633 } | |
| 1634 return true; | |
| 1635 } | |
| 1636 return false; | |
| 1637 } | |
| 1638 | |
| 1639 void ConcurrentMarkSweepGeneration::collect(bool full, | |
| 1640 bool clear_all_soft_refs, | |
| 1641 size_t size, | |
| 1642 bool tlab) | |
| 1643 { | |
| 1644 collector()->collect(full, clear_all_soft_refs, size, tlab); | |
| 1645 } | |
| 1646 | |
| 1647 void CMSCollector::collect(bool full, | |
| 1648 bool clear_all_soft_refs, | |
| 1649 size_t size, | |
| 1650 bool tlab) | |
| 1651 { | |
| 1652 if (!UseCMSCollectionPassing && _collectorState > Idling) { | |
| 1653 // For debugging purposes skip the collection if the state | |
| 1654 // is not currently idle | |
| 1655 if (TraceCMSState) { | |
| 1656 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " skipped full:%d CMS state %d", | |
| 1657 Thread::current(), full, _collectorState); | |
| 1658 } | |
| 1659 return; | |
| 1660 } | |
| 1661 | |
| 1662 // The following "if" branch is present for defensive reasons. | |
| 1663 // In the current uses of this interface, it can be replaced with: | |
| 1664 // assert(!GC_locker.is_active(), "Can't be called otherwise"); | |
| 1665 // But I am not placing that assert here to allow future | |
| 1666 // generality in invoking this interface. | |
| 1667 if (GC_locker::is_active()) { | |
| 1668 // A consistency test for GC_locker | |
| 1669 assert(GC_locker::needs_gc(), "Should have been set already"); | |
| 1670 // Skip this foreground collection, instead | |
| 1671 // expanding the heap if necessary. | |
| 1672 // Need the free list locks for the call to free() in compute_new_size() | |
| 1673 compute_new_size(); | |
| 1674 return; | |
| 1675 } | |
| 1676 acquire_control_and_collect(full, clear_all_soft_refs); | |
| 1677 _full_gcs_since_conc_gc++; | |
| 1678 | |
| 1679 } | |
| 1680 | |
| 1681 void CMSCollector::request_full_gc(unsigned int full_gc_count) { | |
| 1682 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1683 unsigned int gc_count = gch->total_full_collections(); | |
| 1684 if (gc_count == full_gc_count) { | |
| 1685 MutexLockerEx y(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 1686 _full_gc_requested = true; | |
| 1687 CGC_lock->notify(); // nudge CMS thread | |
|
2365
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
2226
diff
changeset
|
1688 } else { |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
2226
diff
changeset
|
1689 assert(gc_count > full_gc_count, "Error: causal loop"); |
| 0 | 1690 } |
| 1691 } | |
| 1692 | |
| 1693 | |
| 1694 // The foreground and background collectors need to coordinate in order | |
| 1695 // to make sure that they do not mutually interfere with CMS collections. | |
| 1696 // When a background collection is active, | |
| 1697 // the foreground collector may need to take over (preempt) and | |
| 1698 // synchronously complete an ongoing collection. Depending on the | |
| 1699 // frequency of the background collections and the heap usage | |
| 1700 // of the application, this preemption can be seldom or frequent. | |
| 1701 // There are only certain | |
| 1702 // points in the background collection that the "collection-baton" | |
| 1703 // can be passed to the foreground collector. | |
| 1704 // | |
| 1705 // The foreground collector will wait for the baton before | |
| 1706 // starting any part of the collection. The foreground collector | |
| 1707 // will only wait at one location. | |
| 1708 // | |
| 1709 // The background collector will yield the baton before starting a new | |
| 1710 // phase of the collection (e.g., before initial marking, marking from roots, | |
| 1711 // precleaning, final re-mark, sweep etc.) This is normally done at the head | |
| 1712 // of the loop which switches the phases. The background collector does some | |
| 1713 // of the phases (initial mark, final re-mark) with the world stopped. | |
| 1714 // Because of locking involved in stopping the world, | |
| 1715 // the foreground collector should not block waiting for the background | |
| 1716 // collector when it is doing a stop-the-world phase. The background | |
| 1717 // collector will yield the baton at an additional point just before | |
| 1718 // it enters a stop-the-world phase. Once the world is stopped, the | |
| 1719 // background collector checks the phase of the collection. If the | |
| 1720 // phase has not changed, it proceeds with the collection. If the | |
| 1721 // phase has changed, it skips that phase of the collection. See | |
| 1722 // the comments on the use of the Heap_lock in collect_in_background(). | |
| 1723 // | |
| 1724 // Variable used in baton passing. | |
| 1725 // _foregroundGCIsActive - Set to true by the foreground collector when | |
| 1726 // it wants the baton. The foreground clears it when it has finished | |
| 1727 // the collection. | |
| 1728 // _foregroundGCShouldWait - Set to true by the background collector | |
| 1729 // when it is running. The foreground collector waits while | |
| 1730 // _foregroundGCShouldWait is true. | |
| 1731 // CGC_lock - monitor used to protect access to the above variables | |
| 1732 // and to notify the foreground and background collectors. | |
| 1733 // _collectorState - current state of the CMS collection. | |
| 1734 // | |
| 1735 // The foreground collector | |
| 1736 // acquires the CGC_lock | |
| 1737 // sets _foregroundGCIsActive | |
| 1738 // waits on the CGC_lock for _foregroundGCShouldWait to be false | |
| 1739 // various locks acquired in preparation for the collection | |
| 1740 // are released so as not to block the background collector | |
| 1741 // that is in the midst of a collection | |
| 1742 // proceeds with the collection | |
| 1743 // clears _foregroundGCIsActive | |
| 1744 // returns | |
| 1745 // | |
| 1746 // The background collector in a loop iterating on the phases of the | |
| 1747 // collection | |
| 1748 // acquires the CGC_lock | |
| 1749 // sets _foregroundGCShouldWait | |
| 1750 // if _foregroundGCIsActive is set | |
| 1751 // clears _foregroundGCShouldWait, notifies _CGC_lock | |
| 1752 // waits on _CGC_lock for _foregroundGCIsActive to become false | |
| 1753 // and exits the loop. | |
| 1754 // otherwise | |
| 1755 // proceed with that phase of the collection | |
| 1756 // if the phase is a stop-the-world phase, | |
| 1757 // yield the baton once more just before enqueueing | |
| 1758 // the stop-world CMS operation (executed by the VM thread). | |
| 1759 // returns after all phases of the collection are done | |
| 1760 // | |
| 1761 | |
| 1762 void CMSCollector::acquire_control_and_collect(bool full, | |
| 1763 bool clear_all_soft_refs) { | |
| 1764 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); | |
| 1765 assert(!Thread::current()->is_ConcurrentGC_thread(), | |
| 1766 "shouldn't try to acquire control from self!"); | |
| 1767 | |
| 1768 // Start the protocol for acquiring control of the | |
| 1769 // collection from the background collector (aka CMS thread). | |
| 1770 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 1771 "VM thread should have CMS token"); | |
| 1772 // Remember the possibly interrupted state of an ongoing | |
| 1773 // concurrent collection | |
| 1774 CollectorState first_state = _collectorState; | |
| 1775 | |
| 1776 // Signal to a possibly ongoing concurrent collection that | |
| 1777 // we want to do a foreground collection. | |
| 1778 _foregroundGCIsActive = true; | |
| 1779 | |
| 1780 // Disable incremental mode during a foreground collection. | |
| 1781 ICMSDisabler icms_disabler; | |
| 1782 | |
| 1783 // release locks and wait for a notify from the background collector | |
| 1784 // releasing the locks in only necessary for phases which | |
| 1785 // do yields to improve the granularity of the collection. | |
| 1786 assert_lock_strong(bitMapLock()); | |
| 1787 // We need to lock the Free list lock for the space that we are | |
| 1788 // currently collecting. | |
| 1789 assert(haveFreelistLocks(), "Must be holding free list locks"); | |
| 1790 bitMapLock()->unlock(); | |
| 1791 releaseFreelistLocks(); | |
| 1792 { | |
| 1793 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 1794 if (_foregroundGCShouldWait) { | |
| 1795 // We are going to be waiting for action for the CMS thread; | |
| 1796 // it had better not be gone (for instance at shutdown)! | |
| 1797 assert(ConcurrentMarkSweepThread::cmst() != NULL, | |
| 1798 "CMS thread must be running"); | |
| 1799 // Wait here until the background collector gives us the go-ahead | |
| 1800 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 1801 ConcurrentMarkSweepThread::CMS_vm_has_token); // release token | |
| 1802 // Get a possibly blocked CMS thread going: | |
| 1803 // Note that we set _foregroundGCIsActive true above, | |
| 1804 // without protection of the CGC_lock. | |
| 1805 CGC_lock->notify(); | |
| 1806 assert(!ConcurrentMarkSweepThread::vm_thread_wants_cms_token(), | |
| 1807 "Possible deadlock"); | |
| 1808 while (_foregroundGCShouldWait) { | |
| 1809 // wait for notification | |
| 1810 CGC_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 1811 // Possibility of delay/starvation here, since CMS token does | |
| 1812 // not know to give priority to VM thread? Actually, i think | |
| 1813 // there wouldn't be any delay/starvation, but the proof of | |
| 1814 // that "fact" (?) appears non-trivial. XXX 20011219YSR | |
| 1815 } | |
| 1816 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 1817 ConcurrentMarkSweepThread::CMS_vm_has_token); | |
| 1818 } | |
| 1819 } | |
| 1820 // The CMS_token is already held. Get back the other locks. | |
| 1821 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 1822 "VM thread should have CMS token"); | |
| 1823 getFreelistLocks(); | |
| 1824 bitMapLock()->lock_without_safepoint_check(); | |
| 1825 if (TraceCMSState) { | |
| 1826 gclog_or_tty->print_cr("CMS foreground collector has asked for control " | |
| 1827 INTPTR_FORMAT " with first state %d", Thread::current(), first_state); | |
| 1828 gclog_or_tty->print_cr(" gets control with state %d", _collectorState); | |
| 1829 } | |
| 1830 | |
| 1831 // Check if we need to do a compaction, or if not, whether | |
| 1832 // we need to start the mark-sweep from scratch. | |
| 1833 bool should_compact = false; | |
| 1834 bool should_start_over = false; | |
| 1835 decide_foreground_collection_type(clear_all_soft_refs, | |
| 1836 &should_compact, &should_start_over); | |
| 1837 | |
| 1838 NOT_PRODUCT( | |
| 1839 if (RotateCMSCollectionTypes) { | |
| 1840 if (_cmsGen->debug_collection_type() == | |
| 1841 ConcurrentMarkSweepGeneration::MSC_foreground_collection_type) { | |
| 1842 should_compact = true; | |
| 1843 } else if (_cmsGen->debug_collection_type() == | |
| 1844 ConcurrentMarkSweepGeneration::MS_foreground_collection_type) { | |
| 1845 should_compact = false; | |
| 1846 } | |
| 1847 } | |
| 1848 ) | |
| 1849 | |
| 1850 if (PrintGCDetails && first_state > Idling) { | |
| 1851 GCCause::Cause cause = GenCollectedHeap::heap()->gc_cause(); | |
| 1852 if (GCCause::is_user_requested_gc(cause) || | |
| 1853 GCCause::is_serviceability_requested_gc(cause)) { | |
| 1854 gclog_or_tty->print(" (concurrent mode interrupted)"); | |
| 1855 } else { | |
| 1856 gclog_or_tty->print(" (concurrent mode failure)"); | |
| 1857 } | |
| 1858 } | |
| 1859 | |
| 1860 if (should_compact) { | |
| 1861 // If the collection is being acquired from the background | |
| 1862 // collector, there may be references on the discovered | |
| 1863 // references lists that have NULL referents (being those | |
| 1864 // that were concurrently cleared by a mutator) or | |
| 1865 // that are no longer active (having been enqueued concurrently | |
| 1866 // by the mutator). | |
| 1867 // Scrub the list of those references because Mark-Sweep-Compact | |
| 1868 // code assumes referents are not NULL and that all discovered | |
| 1869 // Reference objects are active. | |
| 1870 ref_processor()->clean_up_discovered_references(); | |
| 1871 | |
| 1872 do_compaction_work(clear_all_soft_refs); | |
| 1873 | |
| 1874 // Has the GC time limit been exceeded? | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1875 DefNewGeneration* young_gen = _young_gen->as_DefNewGeneration(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1876 size_t max_eden_size = young_gen->max_capacity() - |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1877 young_gen->to()->capacity() - |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1878 young_gen->from()->capacity(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1879 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1880 GCCause::Cause gc_cause = gch->gc_cause(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1881 size_policy()->check_gc_overhead_limit(_young_gen->used(), |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1882 young_gen->eden()->used(), |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1883 _cmsGen->max_capacity(), |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1884 max_eden_size, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1885 full, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1886 gc_cause, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
1887 gch->collector_policy()); |
| 0 | 1888 } else { |
| 1889 do_mark_sweep_work(clear_all_soft_refs, first_state, | |
| 1890 should_start_over); | |
| 1891 } | |
| 1892 // Reset the expansion cause, now that we just completed | |
| 1893 // a collection cycle. | |
| 1894 clear_expansion_cause(); | |
| 1895 _foregroundGCIsActive = false; | |
| 1896 return; | |
| 1897 } | |
| 1898 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1899 // Resize the tenured generation |
| 0 | 1900 // after obtaining the free list locks for the |
| 1901 // two generations. | |
| 1902 void CMSCollector::compute_new_size() { | |
| 1903 assert_locked_or_safepoint(Heap_lock); | |
| 1904 FreelistLocker z(this); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1905 MetaspaceGC::compute_new_size(); |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
1906 _cmsGen->compute_new_size_free_list(); |
| 0 | 1907 } |
| 1908 | |
| 1909 // A work method used by foreground collection to determine | |
| 1910 // what type of collection (compacting or not, continuing or fresh) | |
| 1911 // it should do. | |
| 1912 // NOTE: the intent is to make UseCMSCompactAtFullCollection | |
| 1913 // and CMSCompactWhenClearAllSoftRefs the default in the future | |
| 1914 // and do away with the flags after a suitable period. | |
| 1915 void CMSCollector::decide_foreground_collection_type( | |
| 1916 bool clear_all_soft_refs, bool* should_compact, | |
| 1917 bool* should_start_over) { | |
| 1918 // Normally, we'll compact only if the UseCMSCompactAtFullCollection | |
| 1919 // flag is set, and we have either requested a System.gc() or | |
| 1920 // the number of full gc's since the last concurrent cycle | |
| 1921 // has exceeded the threshold set by CMSFullGCsBeforeCompaction, | |
| 1922 // or if an incremental collection has failed | |
| 1923 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1924 assert(gch->collector_policy()->is_two_generation_policy(), | |
| 1925 "You may want to check the correctness of the following"); | |
| 1926 // Inform cms gen if this was due to partial collection failing. | |
| 1927 // The CMS gen may use this fact to determine its expansion policy. | |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
1928 if (gch->incremental_collection_will_fail(false /* don't consult_young */)) { |
| 0 | 1929 assert(!_cmsGen->incremental_collection_failed(), |
| 1930 "Should have been noticed, reacted to and cleared"); | |
| 1931 _cmsGen->set_incremental_collection_failed(); | |
| 1932 } | |
| 1933 *should_compact = | |
| 1934 UseCMSCompactAtFullCollection && | |
| 1935 ((_full_gcs_since_conc_gc >= CMSFullGCsBeforeCompaction) || | |
| 1936 GCCause::is_user_requested_gc(gch->gc_cause()) || | |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
1937 gch->incremental_collection_will_fail(true /* consult_young */)); |
| 0 | 1938 *should_start_over = false; |
| 1939 if (clear_all_soft_refs && !*should_compact) { | |
| 1940 // We are about to do a last ditch collection attempt | |
| 1941 // so it would normally make sense to do a compaction | |
| 1942 // to reclaim as much space as possible. | |
| 1943 if (CMSCompactWhenClearAllSoftRefs) { | |
| 1944 // Default: The rationale is that in this case either | |
| 1945 // we are past the final marking phase, in which case | |
| 1946 // we'd have to start over, or so little has been done | |
| 1947 // that there's little point in saving that work. Compaction | |
| 1948 // appears to be the sensible choice in either case. | |
| 1949 *should_compact = true; | |
| 1950 } else { | |
| 1951 // We have been asked to clear all soft refs, but not to | |
| 1952 // compact. Make sure that we aren't past the final checkpoint | |
| 1953 // phase, for that is where we process soft refs. If we are already | |
| 1954 // past that phase, we'll need to redo the refs discovery phase and | |
| 1955 // if necessary clear soft refs that weren't previously | |
| 1956 // cleared. We do so by remembering the phase in which | |
| 1957 // we came in, and if we are past the refs processing | |
| 1958 // phase, we'll choose to just redo the mark-sweep | |
| 1959 // collection from scratch. | |
| 1960 if (_collectorState > FinalMarking) { | |
| 1961 // We are past the refs processing phase; | |
| 1962 // start over and do a fresh synchronous CMS cycle | |
| 1963 _collectorState = Resetting; // skip to reset to start new cycle | |
| 1964 reset(false /* == !asynch */); | |
| 1965 *should_start_over = true; | |
| 1966 } // else we can continue a possibly ongoing current cycle | |
| 1967 } | |
| 1968 } | |
| 1969 } | |
| 1970 | |
| 1971 // A work method used by the foreground collector to do | |
| 1972 // a mark-sweep-compact. | |
| 1973 void CMSCollector::do_compaction_work(bool clear_all_soft_refs) { | |
| 1974 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 1975 TraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, gclog_or_tty); | |
| 1976 if (PrintGC && Verbose && !(GCCause::is_user_requested_gc(gch->gc_cause()))) { | |
| 1977 gclog_or_tty->print_cr("Compact ConcurrentMarkSweepGeneration after %d " | |
| 1978 "collections passed to foreground collector", _full_gcs_since_conc_gc); | |
| 1979 } | |
| 1980 | |
| 1981 // Sample collection interval time and reset for collection pause. | |
| 1982 if (UseAdaptiveSizePolicy) { | |
| 1983 size_policy()->msc_collection_begin(); | |
| 1984 } | |
| 1985 | |
| 1986 // Temporarily widen the span of the weak reference processing to | |
| 1987 // the entire heap. | |
| 1988 MemRegion new_span(GenCollectedHeap::heap()->reserved_region()); | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1989 ReferenceProcessorSpanMutator rp_mut_span(ref_processor(), new_span); |
| 0 | 1990 // Temporarily, clear the "is_alive_non_header" field of the |
| 1991 // reference processor. | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1992 ReferenceProcessorIsAliveMutator rp_mut_closure(ref_processor(), NULL); |
| 0 | 1993 // Temporarily make reference _processing_ single threaded (non-MT). |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1994 ReferenceProcessorMTProcMutator rp_mut_mt_processing(ref_processor(), false); |
| 0 | 1995 // Temporarily make refs discovery atomic |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1996 ReferenceProcessorAtomicMutator rp_mut_atomic(ref_processor(), true); |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1997 // Temporarily make reference _discovery_ single threaded (non-MT) |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
1998 ReferenceProcessorMTDiscoveryMutator rp_mut_discovery(ref_processor(), false); |
| 0 | 1999 |
| 2000 ref_processor()->set_enqueuing_is_done(false); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3827
diff
changeset
|
2001 ref_processor()->enable_discovery(false /*verify_disabled*/, false /*check_no_refs*/); |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
2002 ref_processor()->setup_policy(clear_all_soft_refs); |
| 0 | 2003 // If an asynchronous collection finishes, the _modUnionTable is |
| 2004 // all clear. If we are assuming the collection from an asynchronous | |
| 2005 // collection, clear the _modUnionTable. | |
| 2006 assert(_collectorState != Idling || _modUnionTable.isAllClear(), | |
| 2007 "_modUnionTable should be clear if the baton was not passed"); | |
| 2008 _modUnionTable.clear_all(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2009 assert(_collectorState != Idling || _ct->klass_rem_set()->mod_union_is_clear(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2010 "mod union for klasses should be clear if the baton was passed"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2011 _ct->klass_rem_set()->clear_mod_union(); |
| 0 | 2012 |
| 2013 // We must adjust the allocation statistics being maintained | |
| 2014 // in the free list space. We do so by reading and clearing | |
| 2015 // the sweep timer and updating the block flux rate estimates below. | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2016 assert(!_intra_sweep_timer.is_active(), "_intra_sweep_timer should be inactive"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2017 if (_inter_sweep_timer.is_active()) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2018 _inter_sweep_timer.stop(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2019 // Note that we do not use this sample to update the _inter_sweep_estimate. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2020 _cmsGen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2021 _inter_sweep_estimate.padded_average(), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2022 _intra_sweep_estimate.padded_average()); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2023 } |
| 0 | 2024 |
| 2025 GenMarkSweep::invoke_at_safepoint(_cmsGen->level(), | |
| 2026 ref_processor(), clear_all_soft_refs); | |
| 2027 #ifdef ASSERT | |
| 2028 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); | |
| 2029 size_t free_size = cms_space->free(); | |
| 2030 assert(free_size == | |
| 2031 pointer_delta(cms_space->end(), cms_space->compaction_top()) | |
| 2032 * HeapWordSize, | |
| 2033 "All the free space should be compacted into one chunk at top"); | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
2034 assert(cms_space->dictionary()->total_chunk_size( |
| 0 | 2035 debug_only(cms_space->freelistLock())) == 0 || |
| 2036 cms_space->totalSizeInIndexedFreeLists() == 0, | |
| 2037 "All the free space should be in a single chunk"); | |
| 2038 size_t num = cms_space->totalCount(); | |
| 2039 assert((free_size == 0 && num == 0) || | |
| 2040 (free_size > 0 && (num == 1 || num == 2)), | |
| 2041 "There should be at most 2 free chunks after compaction"); | |
| 2042 #endif // ASSERT | |
| 2043 _collectorState = Resetting; | |
| 2044 assert(_restart_addr == NULL, | |
| 2045 "Should have been NULL'd before baton was passed"); | |
| 2046 reset(false /* == !asynch */); | |
| 2047 _cmsGen->reset_after_compaction(); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2048 _concurrent_cycles_since_last_unload = 0; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2049 |
| 0 | 2050 // Clear any data recorded in the PLAB chunk arrays. |
| 2051 if (_survivor_plab_array != NULL) { | |
| 2052 reset_survivor_plab_arrays(); | |
| 2053 } | |
| 2054 | |
| 2055 // Adjust the per-size allocation stats for the next epoch. | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2056 _cmsGen->cmsSpace()->endSweepFLCensus(sweep_count() /* fake */); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2057 // Restart the "inter sweep timer" for the next epoch. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2058 _inter_sweep_timer.reset(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2059 _inter_sweep_timer.start(); |
| 0 | 2060 |
| 2061 // Sample collection pause time and reset for collection interval. | |
| 2062 if (UseAdaptiveSizePolicy) { | |
| 2063 size_policy()->msc_collection_end(gch->gc_cause()); | |
| 2064 } | |
| 2065 | |
| 2066 // For a mark-sweep-compact, compute_new_size() will be called | |
| 2067 // in the heap's do_collection() method. | |
| 2068 } | |
| 2069 | |
| 2070 // A work method used by the foreground collector to do | |
| 2071 // a mark-sweep, after taking over from a possibly on-going | |
| 2072 // concurrent mark-sweep collection. | |
| 2073 void CMSCollector::do_mark_sweep_work(bool clear_all_soft_refs, | |
| 2074 CollectorState first_state, bool should_start_over) { | |
| 2075 if (PrintGC && Verbose) { | |
| 2076 gclog_or_tty->print_cr("Pass concurrent collection to foreground " | |
| 2077 "collector with count %d", | |
| 2078 _full_gcs_since_conc_gc); | |
| 2079 } | |
| 2080 switch (_collectorState) { | |
| 2081 case Idling: | |
| 2082 if (first_state == Idling || should_start_over) { | |
| 2083 // The background GC was not active, or should | |
| 2084 // restarted from scratch; start the cycle. | |
| 2085 _collectorState = InitialMarking; | |
| 2086 } | |
| 2087 // If first_state was not Idling, then a background GC | |
| 2088 // was in progress and has now finished. No need to do it | |
| 2089 // again. Leave the state as Idling. | |
| 2090 break; | |
| 2091 case Precleaning: | |
| 2092 // In the foreground case don't do the precleaning since | |
| 2093 // it is not done concurrently and there is extra work | |
| 2094 // required. | |
| 2095 _collectorState = FinalMarking; | |
| 2096 } | |
| 2097 collect_in_foreground(clear_all_soft_refs); | |
| 2098 | |
| 2099 // For a mark-sweep, compute_new_size() will be called | |
| 2100 // in the heap's do_collection() method. | |
| 2101 } | |
| 2102 | |
| 2103 | |
| 2104 void CMSCollector::getFreelistLocks() const { | |
| 2105 // Get locks for all free lists in all generations that this | |
| 2106 // collector is responsible for | |
| 2107 _cmsGen->freelistLock()->lock_without_safepoint_check(); | |
| 2108 } | |
| 2109 | |
| 2110 void CMSCollector::releaseFreelistLocks() const { | |
| 2111 // Release locks for all free lists in all generations that this | |
| 2112 // collector is responsible for | |
| 2113 _cmsGen->freelistLock()->unlock(); | |
| 2114 } | |
| 2115 | |
| 2116 bool CMSCollector::haveFreelistLocks() const { | |
| 2117 // Check locks for all free lists in all generations that this | |
| 2118 // collector is responsible for | |
| 2119 assert_lock_strong(_cmsGen->freelistLock()); | |
| 2120 PRODUCT_ONLY(ShouldNotReachHere()); | |
| 2121 return true; | |
| 2122 } | |
| 2123 | |
| 2124 // A utility class that is used by the CMS collector to | |
| 2125 // temporarily "release" the foreground collector from its | |
| 2126 // usual obligation to wait for the background collector to | |
| 2127 // complete an ongoing phase before proceeding. | |
| 2128 class ReleaseForegroundGC: public StackObj { | |
| 2129 private: | |
| 2130 CMSCollector* _c; | |
| 2131 public: | |
| 2132 ReleaseForegroundGC(CMSCollector* c) : _c(c) { | |
| 2133 assert(_c->_foregroundGCShouldWait, "Else should not need to call"); | |
| 2134 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2135 // allow a potentially blocked foreground collector to proceed | |
| 2136 _c->_foregroundGCShouldWait = false; | |
| 2137 if (_c->_foregroundGCIsActive) { | |
| 2138 CGC_lock->notify(); | |
| 2139 } | |
| 2140 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2141 "Possible deadlock"); | |
| 2142 } | |
| 2143 | |
| 2144 ~ReleaseForegroundGC() { | |
| 2145 assert(!_c->_foregroundGCShouldWait, "Usage protocol violation?"); | |
| 2146 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2147 _c->_foregroundGCShouldWait = true; | |
| 2148 } | |
| 2149 }; | |
| 2150 | |
| 2151 // There are separate collect_in_background and collect_in_foreground because of | |
| 2152 // the different locking requirements of the background collector and the | |
| 2153 // foreground collector. There was originally an attempt to share | |
| 2154 // one "collect" method between the background collector and the foreground | |
| 2155 // collector but the if-then-else required made it cleaner to have | |
| 2156 // separate methods. | |
| 2157 void CMSCollector::collect_in_background(bool clear_all_soft_refs) { | |
| 2158 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 2159 "A CMS asynchronous collection is only allowed on a CMS thread."); | |
| 2160 | |
| 2161 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2162 { | |
| 2163 bool safepoint_check = Mutex::_no_safepoint_check_flag; | |
| 2164 MutexLockerEx hl(Heap_lock, safepoint_check); | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2165 FreelistLocker fll(this); |
| 0 | 2166 MutexLockerEx x(CGC_lock, safepoint_check); |
| 2167 if (_foregroundGCIsActive || !UseAsyncConcMarkSweepGC) { | |
| 2168 // The foreground collector is active or we're | |
| 2169 // not using asynchronous collections. Skip this | |
| 2170 // background collection. | |
| 2171 assert(!_foregroundGCShouldWait, "Should be clear"); | |
| 2172 return; | |
| 2173 } else { | |
| 2174 assert(_collectorState == Idling, "Should be idling before start."); | |
| 2175 _collectorState = InitialMarking; | |
| 2176 // Reset the expansion cause, now that we are about to begin | |
| 2177 // a new cycle. | |
| 2178 clear_expansion_cause(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2179 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2180 // Clear the MetaspaceGC flag since a concurrent collection |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2181 // is starting but also clear it after the collection. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2182 MetaspaceGC::set_should_concurrent_collect(false); |
| 0 | 2183 } |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2184 // 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
|
2185 // ensuing concurrent GC cycle. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
2186 update_should_unload_classes(); |
| 0 | 2187 _full_gc_requested = false; // acks all outstanding full gc requests |
| 2188 // Signal that we are about to start a collection | |
| 2189 gch->increment_total_full_collections(); // ... starting a collection cycle | |
| 2190 _collection_count_start = gch->total_full_collections(); | |
| 2191 } | |
| 2192 | |
| 2193 // Used for PrintGC | |
| 2194 size_t prev_used; | |
| 2195 if (PrintGC && Verbose) { | |
| 2196 prev_used = _cmsGen->used(); // XXXPERM | |
| 2197 } | |
| 2198 | |
| 2199 // The change of the collection state is normally done at this level; | |
| 2200 // the exceptions are phases that are executed while the world is | |
| 2201 // stopped. For those phases the change of state is done while the | |
| 2202 // world is stopped. For baton passing purposes this allows the | |
| 2203 // background collector to finish the phase and change state atomically. | |
| 2204 // The foreground collector cannot wait on a phase that is done | |
| 2205 // while the world is stopped because the foreground collector already | |
| 2206 // has the world stopped and would deadlock. | |
| 2207 while (_collectorState != Idling) { | |
| 2208 if (TraceCMSState) { | |
| 2209 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d", | |
| 2210 Thread::current(), _collectorState); | |
| 2211 } | |
| 2212 // The foreground collector | |
| 2213 // holds the Heap_lock throughout its collection. | |
| 2214 // holds the CMS token (but not the lock) | |
| 2215 // except while it is waiting for the background collector to yield. | |
| 2216 // | |
| 2217 // The foreground collector should be blocked (not for long) | |
| 2218 // if the background collector is about to start a phase | |
| 2219 // executed with world stopped. If the background | |
| 2220 // collector has already started such a phase, the | |
| 2221 // foreground collector is blocked waiting for the | |
| 2222 // Heap_lock. The stop-world phases (InitialMarking and FinalMarking) | |
| 2223 // are executed in the VM thread. | |
| 2224 // | |
| 2225 // The locking order is | |
| 2226 // PendingListLock (PLL) -- if applicable (FinalMarking) | |
| 2227 // Heap_lock (both this & PLL locked in VM_CMS_Operation::prologue()) | |
| 2228 // CMS token (claimed in | |
| 2229 // stop_world_and_do() --> | |
| 2230 // safepoint_synchronize() --> | |
| 2231 // CMSThread::synchronize()) | |
| 2232 | |
| 2233 { | |
| 2234 // Check if the FG collector wants us to yield. | |
| 2235 CMSTokenSync x(true); // is cms thread | |
| 2236 if (waitForForegroundGC()) { | |
| 2237 // We yielded to a foreground GC, nothing more to be | |
| 2238 // done this round. | |
| 2239 assert(_foregroundGCShouldWait == false, "We set it to false in " | |
| 2240 "waitForForegroundGC()"); | |
| 2241 if (TraceCMSState) { | |
| 2242 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2243 " exiting collection CMS state %d", | |
| 2244 Thread::current(), _collectorState); | |
| 2245 } | |
| 2246 return; | |
| 2247 } else { | |
| 2248 // The background collector can run but check to see if the | |
| 2249 // foreground collector has done a collection while the | |
| 2250 // background collector was waiting to get the CGC_lock | |
| 2251 // above. If yes, break so that _foregroundGCShouldWait | |
| 2252 // is cleared before returning. | |
| 2253 if (_collectorState == Idling) { | |
| 2254 break; | |
| 2255 } | |
| 2256 } | |
| 2257 } | |
| 2258 | |
| 2259 assert(_foregroundGCShouldWait, "Foreground collector, if active, " | |
| 2260 "should be waiting"); | |
| 2261 | |
| 2262 switch (_collectorState) { | |
| 2263 case InitialMarking: | |
| 2264 { | |
| 2265 ReleaseForegroundGC x(this); | |
| 2266 stats().record_cms_begin(); | |
| 2267 | |
| 2268 VM_CMS_Initial_Mark initial_mark_op(this); | |
| 2269 VMThread::execute(&initial_mark_op); | |
| 2270 } | |
| 2271 // The collector state may be any legal state at this point | |
| 2272 // since the background collector may have yielded to the | |
| 2273 // foreground collector. | |
| 2274 break; | |
| 2275 case Marking: | |
| 2276 // initial marking in checkpointRootsInitialWork has been completed | |
| 2277 if (markFromRoots(true)) { // we were successful | |
| 2278 assert(_collectorState == Precleaning, "Collector state should " | |
| 2279 "have changed"); | |
| 2280 } else { | |
| 2281 assert(_foregroundGCIsActive, "Internal state inconsistency"); | |
| 2282 } | |
| 2283 break; | |
| 2284 case Precleaning: | |
| 2285 if (UseAdaptiveSizePolicy) { | |
| 2286 size_policy()->concurrent_precleaning_begin(); | |
| 2287 } | |
| 2288 // marking from roots in markFromRoots has been completed | |
| 2289 preclean(); | |
| 2290 if (UseAdaptiveSizePolicy) { | |
| 2291 size_policy()->concurrent_precleaning_end(); | |
| 2292 } | |
| 2293 assert(_collectorState == AbortablePreclean || | |
| 2294 _collectorState == FinalMarking, | |
| 2295 "Collector state should have changed"); | |
| 2296 break; | |
| 2297 case AbortablePreclean: | |
| 2298 if (UseAdaptiveSizePolicy) { | |
| 2299 size_policy()->concurrent_phases_resume(); | |
| 2300 } | |
| 2301 abortable_preclean(); | |
| 2302 if (UseAdaptiveSizePolicy) { | |
| 2303 size_policy()->concurrent_precleaning_end(); | |
| 2304 } | |
| 2305 assert(_collectorState == FinalMarking, "Collector state should " | |
| 2306 "have changed"); | |
| 2307 break; | |
| 2308 case FinalMarking: | |
| 2309 { | |
| 2310 ReleaseForegroundGC x(this); | |
| 2311 | |
| 2312 VM_CMS_Final_Remark final_remark_op(this); | |
| 2313 VMThread::execute(&final_remark_op); | |
| 935 | 2314 } |
| 0 | 2315 assert(_foregroundGCShouldWait, "block post-condition"); |
| 2316 break; | |
| 2317 case Sweeping: | |
| 2318 if (UseAdaptiveSizePolicy) { | |
| 2319 size_policy()->concurrent_sweeping_begin(); | |
| 2320 } | |
| 2321 // final marking in checkpointRootsFinal has been completed | |
| 2322 sweep(true); | |
| 2323 assert(_collectorState == Resizing, "Collector state change " | |
| 2324 "to Resizing must be done under the free_list_lock"); | |
| 2325 _full_gcs_since_conc_gc = 0; | |
| 2326 | |
| 2327 // Stop the timers for adaptive size policy for the concurrent phases | |
| 2328 if (UseAdaptiveSizePolicy) { | |
| 2329 size_policy()->concurrent_sweeping_end(); | |
| 2330 size_policy()->concurrent_phases_end(gch->gc_cause(), | |
| 2331 gch->prev_gen(_cmsGen)->capacity(), | |
| 2332 _cmsGen->free()); | |
| 2333 } | |
| 2334 | |
| 2335 case Resizing: { | |
| 2336 // Sweeping has been completed... | |
| 2337 // At this point the background collection has completed. | |
| 2338 // Don't move the call to compute_new_size() down | |
| 2339 // into code that might be executed if the background | |
| 2340 // collection was preempted. | |
| 2341 { | |
| 2342 ReleaseForegroundGC x(this); // unblock FG collection | |
| 2343 MutexLockerEx y(Heap_lock, Mutex::_no_safepoint_check_flag); | |
| 2344 CMSTokenSync z(true); // not strictly needed. | |
| 2345 if (_collectorState == Resizing) { | |
| 2346 compute_new_size(); | |
| 2347 _collectorState = Resetting; | |
| 2348 } else { | |
| 2349 assert(_collectorState == Idling, "The state should only change" | |
| 2350 " because the foreground collector has finished the collection"); | |
| 2351 } | |
| 2352 } | |
| 2353 break; | |
| 2354 } | |
| 2355 case Resetting: | |
| 2356 // CMS heap resizing has been completed | |
| 2357 reset(true); | |
| 2358 assert(_collectorState == Idling, "Collector state should " | |
| 2359 "have changed"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2360 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2361 MetaspaceGC::set_should_concurrent_collect(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2362 |
| 0 | 2363 stats().record_cms_end(); |
| 2364 // Don't move the concurrent_phases_end() and compute_new_size() | |
| 2365 // calls to here because a preempted background collection | |
| 2366 // has it's state set to "Resetting". | |
| 2367 break; | |
| 2368 case Idling: | |
| 2369 default: | |
| 2370 ShouldNotReachHere(); | |
| 2371 break; | |
| 2372 } | |
| 2373 if (TraceCMSState) { | |
| 2374 gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d", | |
| 2375 Thread::current(), _collectorState); | |
| 2376 } | |
| 2377 assert(_foregroundGCShouldWait, "block post-condition"); | |
| 2378 } | |
| 2379 | |
| 2380 // Should this be in gc_epilogue? | |
| 2381 collector_policy()->counters()->update_counters(); | |
| 2382 | |
| 2383 { | |
| 2384 // Clear _foregroundGCShouldWait and, in the event that the | |
| 2385 // foreground collector is waiting, notify it, before | |
| 2386 // returning. | |
| 2387 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2388 _foregroundGCShouldWait = false; | |
| 2389 if (_foregroundGCIsActive) { | |
| 2390 CGC_lock->notify(); | |
| 2391 } | |
| 2392 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2393 "Possible deadlock"); | |
| 2394 } | |
| 2395 if (TraceCMSState) { | |
| 2396 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2397 " exiting collection CMS state %d", | |
| 2398 Thread::current(), _collectorState); | |
| 2399 } | |
| 2400 if (PrintGC && Verbose) { | |
| 2401 _cmsGen->print_heap_change(prev_used); | |
| 2402 } | |
| 2403 } | |
| 2404 | |
| 2405 void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) { | |
| 2406 assert(_foregroundGCIsActive && !_foregroundGCShouldWait, | |
| 2407 "Foreground collector should be waiting, not executing"); | |
| 2408 assert(Thread::current()->is_VM_thread(), "A foreground collection" | |
| 2409 "may only be done by the VM Thread with the world stopped"); | |
| 2410 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(), | |
| 2411 "VM thread should have CMS token"); | |
| 2412 | |
| 2413 NOT_PRODUCT(TraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose, | |
| 2414 true, gclog_or_tty);) | |
| 2415 if (UseAdaptiveSizePolicy) { | |
| 2416 size_policy()->ms_collection_begin(); | |
| 2417 } | |
| 2418 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact); | |
| 2419 | |
| 2420 HandleMark hm; // Discard invalid handles created during verification | |
| 2421 | |
| 2422 if (VerifyBeforeGC && | |
| 2423 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2424 Universe::verify(); |
| 0 | 2425 } |
| 2426 | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
2427 // Snapshot the soft reference policy to be used in this collection cycle. |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
2428 ref_processor()->setup_policy(clear_all_soft_refs); |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
2429 |
| 0 | 2430 bool init_mark_was_synchronous = false; // until proven otherwise |
| 2431 while (_collectorState != Idling) { | |
| 2432 if (TraceCMSState) { | |
| 2433 gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d", | |
| 2434 Thread::current(), _collectorState); | |
| 2435 } | |
| 2436 switch (_collectorState) { | |
| 2437 case InitialMarking: | |
| 2438 init_mark_was_synchronous = true; // fact to be exploited in re-mark | |
| 2439 checkpointRootsInitial(false); | |
| 2440 assert(_collectorState == Marking, "Collector state should have changed" | |
| 2441 " within checkpointRootsInitial()"); | |
| 2442 break; | |
| 2443 case Marking: | |
| 2444 // initial marking in checkpointRootsInitialWork has been completed | |
| 2445 if (VerifyDuringGC && | |
| 2446 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2447 gclog_or_tty->print("Verify before initial mark: "); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2448 Universe::verify(); |
| 0 | 2449 } |
| 2450 { | |
| 2451 bool res = markFromRoots(false); | |
| 2452 assert(res && _collectorState == FinalMarking, "Collector state should " | |
| 2453 "have changed"); | |
| 2454 break; | |
| 2455 } | |
| 2456 case FinalMarking: | |
| 2457 if (VerifyDuringGC && | |
| 2458 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2459 gclog_or_tty->print("Verify before re-mark: "); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2460 Universe::verify(); |
| 0 | 2461 } |
| 2462 checkpointRootsFinal(false, clear_all_soft_refs, | |
| 2463 init_mark_was_synchronous); | |
| 2464 assert(_collectorState == Sweeping, "Collector state should not " | |
| 2465 "have changed within checkpointRootsFinal()"); | |
| 2466 break; | |
| 2467 case Sweeping: | |
| 2468 // final marking in checkpointRootsFinal has been completed | |
| 2469 if (VerifyDuringGC && | |
| 2470 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2471 gclog_or_tty->print("Verify before sweep: "); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2472 Universe::verify(); |
| 0 | 2473 } |
| 2474 sweep(false); | |
| 2475 assert(_collectorState == Resizing, "Incorrect state"); | |
| 2476 break; | |
| 2477 case Resizing: { | |
| 2478 // Sweeping has been completed; the actual resize in this case | |
| 2479 // is done separately; nothing to be done in this state. | |
| 2480 _collectorState = Resetting; | |
| 2481 break; | |
| 2482 } | |
| 2483 case Resetting: | |
| 2484 // The heap has been resized. | |
| 2485 if (VerifyDuringGC && | |
| 2486 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2487 gclog_or_tty->print("Verify before reset: "); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2488 Universe::verify(); |
| 0 | 2489 } |
| 2490 reset(false); | |
| 2491 assert(_collectorState == Idling, "Collector state should " | |
| 2492 "have changed"); | |
| 2493 break; | |
| 2494 case Precleaning: | |
| 2495 case AbortablePreclean: | |
| 2496 // Elide the preclean phase | |
| 2497 _collectorState = FinalMarking; | |
| 2498 break; | |
| 2499 default: | |
| 2500 ShouldNotReachHere(); | |
| 2501 } | |
| 2502 if (TraceCMSState) { | |
| 2503 gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d", | |
| 2504 Thread::current(), _collectorState); | |
| 2505 } | |
| 2506 } | |
| 2507 | |
| 2508 if (UseAdaptiveSizePolicy) { | |
| 2509 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2510 size_policy()->ms_collection_end(gch->gc_cause()); | |
| 2511 } | |
| 2512 | |
| 2513 if (VerifyAfterGC && | |
| 2514 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
2515 Universe::verify(); |
| 0 | 2516 } |
| 2517 if (TraceCMSState) { | |
| 2518 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT | |
| 2519 " exiting collection CMS state %d", | |
| 2520 Thread::current(), _collectorState); | |
| 2521 } | |
| 2522 } | |
| 2523 | |
| 2524 bool CMSCollector::waitForForegroundGC() { | |
| 2525 bool res = false; | |
| 2526 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 2527 "CMS thread should have CMS token"); | |
| 2528 // Block the foreground collector until the | |
| 2529 // background collectors decides whether to | |
| 2530 // yield. | |
| 2531 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); | |
| 2532 _foregroundGCShouldWait = true; | |
| 2533 if (_foregroundGCIsActive) { | |
| 2534 // The background collector yields to the | |
| 2535 // foreground collector and returns a value | |
| 2536 // indicating that it has yielded. The foreground | |
| 2537 // collector can proceed. | |
| 2538 res = true; | |
| 2539 _foregroundGCShouldWait = false; | |
| 2540 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 2541 ConcurrentMarkSweepThread::CMS_cms_has_token); | |
| 2542 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 2543 ConcurrentMarkSweepThread::CMS_cms_wants_token); | |
| 2544 // Get a possibly blocked foreground thread going | |
| 2545 CGC_lock->notify(); | |
| 2546 if (TraceCMSState) { | |
| 2547 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d", | |
| 2548 Thread::current(), _collectorState); | |
| 2549 } | |
| 2550 while (_foregroundGCIsActive) { | |
| 2551 CGC_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 2552 } | |
| 2553 ConcurrentMarkSweepThread::set_CMS_flag( | |
| 2554 ConcurrentMarkSweepThread::CMS_cms_has_token); | |
| 2555 ConcurrentMarkSweepThread::clear_CMS_flag( | |
| 2556 ConcurrentMarkSweepThread::CMS_cms_wants_token); | |
| 2557 } | |
| 2558 if (TraceCMSState) { | |
| 2559 gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d", | |
| 2560 Thread::current(), _collectorState); | |
| 2561 } | |
| 2562 return res; | |
| 2563 } | |
| 2564 | |
| 2565 // Because of the need to lock the free lists and other structures in | |
| 2566 // the collector, common to all the generations that the collector is | |
| 2567 // collecting, we need the gc_prologues of individual CMS generations | |
| 2568 // delegate to their collector. It may have been simpler had the | |
| 2569 // current infrastructure allowed one to call a prologue on a | |
| 2570 // collector. In the absence of that we have the generation's | |
| 2571 // prologue delegate to the collector, which delegates back | |
| 2572 // some "local" work to a worker method in the individual generations | |
| 2573 // that it's responsible for collecting, while itself doing any | |
| 2574 // work common to all generations it's responsible for. A similar | |
| 2575 // comment applies to the gc_epilogue()'s. | |
| 2576 // The role of the varaible _between_prologue_and_epilogue is to | |
| 2577 // enforce the invocation protocol. | |
| 2578 void CMSCollector::gc_prologue(bool full) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2579 // Call gc_prologue_work() for the CMSGen |
| 0 | 2580 // we are responsible for. |
| 2581 | |
| 2582 // The following locking discipline assumes that we are only called | |
| 2583 // when the world is stopped. | |
| 2584 assert(SafepointSynchronize::is_at_safepoint(), "world is stopped assumption"); | |
| 2585 | |
| 2586 // The CMSCollector prologue must call the gc_prologues for the | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2587 // "generations" that it's responsible |
| 0 | 2588 // for. |
| 2589 | |
| 2590 assert( Thread::current()->is_VM_thread() | |
| 2591 || ( CMSScavengeBeforeRemark | |
| 2592 && Thread::current()->is_ConcurrentGC_thread()), | |
| 2593 "Incorrect thread type for prologue execution"); | |
| 2594 | |
| 2595 if (_between_prologue_and_epilogue) { | |
| 2596 // We have already been invoked; this is a gc_prologue delegation | |
| 2597 // from yet another CMS generation that we are responsible for, just | |
| 2598 // ignore it since all relevant work has already been done. | |
| 2599 return; | |
| 2600 } | |
| 2601 | |
| 2602 // set a bit saying prologue has been called; cleared in epilogue | |
| 2603 _between_prologue_and_epilogue = true; | |
| 2604 // Claim locks for common data structures, then call gc_prologue_work() | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2605 // for each CMSGen. |
| 0 | 2606 |
| 2607 getFreelistLocks(); // gets free list locks on constituent spaces | |
| 2608 bitMapLock()->lock_without_safepoint_check(); | |
| 2609 | |
| 2610 // Should call gc_prologue_work() for all cms gens we are responsible for | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2611 bool duringMarking = _collectorState >= Marking |
| 0 | 2612 && _collectorState < Sweeping; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2613 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2614 // The young collections clear the modified oops state, which tells if |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2615 // there are any modified oops in the class. The remark phase also needs |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2616 // that information. Tell the young collection to save the union of all |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2617 // modified klasses. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2618 if (duringMarking) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2619 _ct->klass_rem_set()->set_accumulate_modified_oops(true); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2620 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2621 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2622 bool registerClosure = duringMarking; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2623 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
2624 ModUnionClosure* muc = CollectedHeap::use_parallel_gc_threads() ? |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
2625 &_modUnionClosurePar |
| 0 | 2626 : &_modUnionClosure; |
| 2627 _cmsGen->gc_prologue_work(full, registerClosure, muc); | |
| 2628 | |
| 2629 if (!full) { | |
| 2630 stats().record_gc0_begin(); | |
| 2631 } | |
| 2632 } | |
| 2633 | |
| 2634 void ConcurrentMarkSweepGeneration::gc_prologue(bool full) { | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
2635 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
2636 _capacity_at_prologue = capacity(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
2637 _used_at_prologue = used(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
2638 |
| 0 | 2639 // Delegate to CMScollector which knows how to coordinate between |
| 2640 // this and any other CMS generations that it is responsible for | |
| 2641 // collecting. | |
| 2642 collector()->gc_prologue(full); | |
| 2643 } | |
| 2644 | |
| 2645 // This is a "private" interface for use by this generation's CMSCollector. | |
| 2646 // Not to be called directly by any other entity (for instance, | |
| 2647 // GenCollectedHeap, which calls the "public" gc_prologue method above). | |
| 2648 void ConcurrentMarkSweepGeneration::gc_prologue_work(bool full, | |
| 2649 bool registerClosure, ModUnionClosure* modUnionClosure) { | |
| 2650 assert(!incremental_collection_failed(), "Shouldn't be set yet"); | |
| 2651 assert(cmsSpace()->preconsumptionDirtyCardClosure() == NULL, | |
| 2652 "Should be NULL"); | |
| 2653 if (registerClosure) { | |
| 2654 cmsSpace()->setPreconsumptionDirtyCardClosure(modUnionClosure); | |
| 2655 } | |
| 2656 cmsSpace()->gc_prologue(); | |
| 2657 // Clear stat counters | |
| 2658 NOT_PRODUCT( | |
| 2659 assert(_numObjectsPromoted == 0, "check"); | |
| 2660 assert(_numWordsPromoted == 0, "check"); | |
| 2661 if (Verbose && PrintGC) { | |
| 2662 gclog_or_tty->print("Allocated "SIZE_FORMAT" objects, " | |
| 2663 SIZE_FORMAT" bytes concurrently", | |
| 2664 _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); | |
| 2665 } | |
| 2666 _numObjectsAllocated = 0; | |
| 2667 _numWordsAllocated = 0; | |
| 2668 ) | |
| 2669 } | |
| 2670 | |
| 2671 void CMSCollector::gc_epilogue(bool full) { | |
| 2672 // The following locking discipline assumes that we are only called | |
| 2673 // when the world is stopped. | |
| 2674 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2675 "world is stopped assumption"); | |
| 2676 | |
| 2677 // Currently the CMS epilogue (see CompactibleFreeListSpace) merely checks | |
| 2678 // if linear allocation blocks need to be appropriately marked to allow the | |
| 2679 // the blocks to be parsable. We also check here whether we need to nudge the | |
| 2680 // CMS collector thread to start a new cycle (if it's not already active). | |
| 2681 assert( Thread::current()->is_VM_thread() | |
| 2682 || ( CMSScavengeBeforeRemark | |
| 2683 && Thread::current()->is_ConcurrentGC_thread()), | |
| 2684 "Incorrect thread type for epilogue execution"); | |
| 2685 | |
| 2686 if (!_between_prologue_and_epilogue) { | |
| 2687 // We have already been invoked; this is a gc_epilogue delegation | |
| 2688 // from yet another CMS generation that we are responsible for, just | |
| 2689 // ignore it since all relevant work has already been done. | |
| 2690 return; | |
| 2691 } | |
| 2692 assert(haveFreelistLocks(), "must have freelist locks"); | |
| 2693 assert_lock_strong(bitMapLock()); | |
| 2694 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2695 _ct->klass_rem_set()->set_accumulate_modified_oops(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2696 |
| 0 | 2697 _cmsGen->gc_epilogue_work(full); |
| 2698 | |
| 2699 if (_collectorState == AbortablePreclean || _collectorState == Precleaning) { | |
| 2700 // in case sampling was not already enabled, enable it | |
| 2701 _start_sampling = true; | |
| 2702 } | |
| 2703 // reset _eden_chunk_array so sampling starts afresh | |
| 2704 _eden_chunk_index = 0; | |
| 2705 | |
| 2706 size_t cms_used = _cmsGen->cmsSpace()->used(); | |
| 2707 | |
| 2708 // update performance counters - this uses a special version of | |
| 2709 // update_counters() that allows the utilization to be passed as a | |
| 2710 // parameter, avoiding multiple calls to used(). | |
| 2711 // | |
| 2712 _cmsGen->update_counters(cms_used); | |
| 2713 | |
| 2714 if (CMSIncrementalMode) { | |
| 2715 icms_update_allocation_limits(); | |
| 2716 } | |
| 2717 | |
| 2718 bitMapLock()->unlock(); | |
| 2719 releaseFreelistLocks(); | |
| 2720 | |
|
3799
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3746
diff
changeset
|
2721 if (!CleanChunkPoolAsync) { |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3746
diff
changeset
|
2722 Chunk::clean_chunk_pool(); |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3746
diff
changeset
|
2723 } |
|
48048b59a551
7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents:
3746
diff
changeset
|
2724 |
| 0 | 2725 _between_prologue_and_epilogue = false; // ready for next cycle |
| 2726 } | |
| 2727 | |
| 2728 void ConcurrentMarkSweepGeneration::gc_epilogue(bool full) { | |
| 2729 collector()->gc_epilogue(full); | |
| 2730 | |
| 2731 // Also reset promotion tracking in par gc thread states. | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
2732 if (CollectedHeap::use_parallel_gc_threads()) { |
| 0 | 2733 for (uint i = 0; i < ParallelGCThreads; i++) { |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2734 _par_gc_thread_states[i]->promo.stopTrackingPromotions(i); |
| 0 | 2735 } |
| 2736 } | |
| 2737 } | |
| 2738 | |
| 2739 void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) { | |
| 2740 assert(!incremental_collection_failed(), "Should have been cleared"); | |
| 2741 cmsSpace()->setPreconsumptionDirtyCardClosure(NULL); | |
| 2742 cmsSpace()->gc_epilogue(); | |
| 2743 // Print stat counters | |
| 2744 NOT_PRODUCT( | |
| 2745 assert(_numObjectsAllocated == 0, "check"); | |
| 2746 assert(_numWordsAllocated == 0, "check"); | |
| 2747 if (Verbose && PrintGC) { | |
| 2748 gclog_or_tty->print("Promoted "SIZE_FORMAT" objects, " | |
| 2749 SIZE_FORMAT" bytes", | |
| 2750 _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); | |
| 2751 } | |
| 2752 _numObjectsPromoted = 0; | |
| 2753 _numWordsPromoted = 0; | |
| 2754 ) | |
| 2755 | |
| 2756 if (PrintGC && Verbose) { | |
| 2757 // Call down the chain in contiguous_available needs the freelistLock | |
| 2758 // so print this out before releasing the freeListLock. | |
| 2759 gclog_or_tty->print(" Contiguous available "SIZE_FORMAT" bytes ", | |
| 2760 contiguous_available()); | |
| 2761 } | |
| 2762 } | |
| 2763 | |
| 2764 #ifndef PRODUCT | |
| 2765 bool CMSCollector::have_cms_token() { | |
| 2766 Thread* thr = Thread::current(); | |
| 2767 if (thr->is_VM_thread()) { | |
| 2768 return ConcurrentMarkSweepThread::vm_thread_has_cms_token(); | |
| 2769 } else if (thr->is_ConcurrentGC_thread()) { | |
| 2770 return ConcurrentMarkSweepThread::cms_thread_has_cms_token(); | |
| 2771 } else if (thr->is_GC_task_thread()) { | |
| 2772 return ConcurrentMarkSweepThread::vm_thread_has_cms_token() && | |
| 2773 ParGCRareEvent_lock->owned_by_self(); | |
| 2774 } | |
| 2775 return false; | |
| 2776 } | |
| 2777 #endif | |
| 2778 | |
| 2779 // Check reachability of the given heap address in CMS generation, | |
| 2780 // treating all other generations as roots. | |
| 2781 bool CMSCollector::is_cms_reachable(HeapWord* addr) { | |
| 2782 // We could "guarantee" below, rather than assert, but i'll | |
| 2783 // leave these as "asserts" so that an adventurous debugger | |
| 2784 // could try this in the product build provided some subset of | |
| 2785 // the conditions were met, provided they were intersted in the | |
| 2786 // results and knew that the computation below wouldn't interfere | |
| 2787 // with other concurrent computations mutating the structures | |
| 2788 // being read or written. | |
| 2789 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2790 "Else mutations in object graph will make answer suspect"); | |
| 2791 assert(have_cms_token(), "Should hold cms token"); | |
| 2792 assert(haveFreelistLocks(), "must hold free list locks"); | |
| 2793 assert_lock_strong(bitMapLock()); | |
| 2794 | |
| 2795 // Clear the marking bit map array before starting, but, just | |
| 2796 // for kicks, first report if the given address is already marked | |
| 2797 gclog_or_tty->print_cr("Start: Address 0x%x is%s marked", addr, | |
| 2798 _markBitMap.isMarked(addr) ? "" : " not"); | |
| 2799 | |
| 2800 if (verify_after_remark()) { | |
| 2801 MutexLockerEx x(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag); | |
| 2802 bool result = verification_mark_bm()->isMarked(addr); | |
| 2803 gclog_or_tty->print_cr("TransitiveMark: Address 0x%x %s marked", addr, | |
| 2804 result ? "IS" : "is NOT"); | |
| 2805 return result; | |
| 2806 } else { | |
| 2807 gclog_or_tty->print_cr("Could not compute result"); | |
| 2808 return false; | |
| 2809 } | |
| 2810 } | |
| 2811 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2812 |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2813 void |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2814 CMSCollector::print_on_error(outputStream* st) { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2815 CMSCollector* collector = ConcurrentMarkSweepGeneration::_collector; |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2816 if (collector != NULL) { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2817 CMSBitMap* bitmap = &collector->_markBitMap; |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2818 st->print_cr("Marking Bits: (CMSBitMap*) " PTR_FORMAT, bitmap); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2819 bitmap->print_on_error(st, " Bits: "); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2820 |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2821 st->cr(); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2822 |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2823 CMSBitMap* mut_bitmap = &collector->_modUnionTable; |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2824 st->print_cr("Mod Union Table: (CMSBitMap*) " PTR_FORMAT, mut_bitmap); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2825 mut_bitmap->print_on_error(st, " Bits: "); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2826 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2827 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
2828 |
| 0 | 2829 //////////////////////////////////////////////////////// |
| 2830 // CMS Verification Support | |
| 2831 //////////////////////////////////////////////////////// | |
| 2832 // Following the remark phase, the following invariant | |
| 2833 // should hold -- each object in the CMS heap which is | |
| 2834 // marked in markBitMap() should be marked in the verification_mark_bm(). | |
| 2835 | |
| 2836 class VerifyMarkedClosure: public BitMapClosure { | |
| 2837 CMSBitMap* _marks; | |
| 2838 bool _failed; | |
| 2839 | |
| 2840 public: | |
| 2841 VerifyMarkedClosure(CMSBitMap* bm): _marks(bm), _failed(false) {} | |
| 2842 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
2843 bool do_bit(size_t offset) { |
| 0 | 2844 HeapWord* addr = _marks->offsetToHeapWord(offset); |
| 2845 if (!_marks->isMarked(addr)) { | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2846 oop(addr)->print_on(gclog_or_tty); |
| 0 | 2847 gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr); |
| 2848 _failed = true; | |
| 2849 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
2850 return true; |
| 0 | 2851 } |
| 2852 | |
| 2853 bool failed() { return _failed; } | |
| 2854 }; | |
| 2855 | |
| 2856 bool CMSCollector::verify_after_remark() { | |
| 2857 gclog_or_tty->print(" [Verifying CMS Marking... "); | |
| 2858 MutexLockerEx ml(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag); | |
| 2859 static bool init = false; | |
| 2860 | |
| 2861 assert(SafepointSynchronize::is_at_safepoint(), | |
| 2862 "Else mutations in object graph will make answer suspect"); | |
| 2863 assert(have_cms_token(), | |
| 2864 "Else there may be mutual interference in use of " | |
| 2865 " verification data structures"); | |
| 2866 assert(_collectorState > Marking && _collectorState <= Sweeping, | |
| 2867 "Else marking info checked here may be obsolete"); | |
| 2868 assert(haveFreelistLocks(), "must hold free list locks"); | |
| 2869 assert_lock_strong(bitMapLock()); | |
| 2870 | |
| 2871 | |
| 2872 // Allocate marking bit map if not already allocated | |
| 2873 if (!init) { // first time | |
| 2874 if (!verification_mark_bm()->allocate(_span)) { | |
| 2875 return false; | |
| 2876 } | |
| 2877 init = true; | |
| 2878 } | |
| 2879 | |
| 2880 assert(verification_mark_stack()->isEmpty(), "Should be empty"); | |
| 2881 | |
| 2882 // Turn off refs discovery -- so we will be tracing through refs. | |
| 2883 // This is as intended, because by this time | |
| 2884 // GC must already have cleared any refs that need to be cleared, | |
| 2885 // and traced those that need to be marked; moreover, | |
| 2886 // the marking done here is not going to intefere in any | |
| 2887 // way with the marking information used by GC. | |
| 2888 NoRefDiscovery no_discovery(ref_processor()); | |
| 2889 | |
| 2890 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 2891 | |
| 2892 // Clear any marks from a previous round | |
| 2893 verification_mark_bm()->clear_all(); | |
| 2894 assert(verification_mark_stack()->isEmpty(), "markStack should be empty"); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2895 verify_work_stacks_empty(); |
| 0 | 2896 |
| 2897 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2898 gch->ensure_parsability(false); // fill TLABs, but no need to retire them | |
| 2899 // Update the saved marks which may affect the root scans. | |
| 2900 gch->save_marks(); | |
| 2901 | |
| 2902 if (CMSRemarkVerifyVariant == 1) { | |
| 2903 // In this first variant of verification, we complete | |
| 2904 // all marking, then check if the new marks-verctor is | |
| 2905 // a subset of the CMS marks-vector. | |
| 2906 verify_after_remark_work_1(); | |
| 2907 } else if (CMSRemarkVerifyVariant == 2) { | |
| 2908 // In this second variant of verification, we flag an error | |
| 2909 // (i.e. an object reachable in the new marks-vector not reachable | |
| 2910 // in the CMS marks-vector) immediately, also indicating the | |
| 2911 // identify of an object (A) that references the unmarked object (B) -- | |
| 2912 // presumably, a mutation to A failed to be picked up by preclean/remark? | |
| 2913 verify_after_remark_work_2(); | |
| 2914 } else { | |
| 2915 warning("Unrecognized value %d for CMSRemarkVerifyVariant", | |
| 2916 CMSRemarkVerifyVariant); | |
| 2917 } | |
| 2918 gclog_or_tty->print(" done] "); | |
| 2919 return true; | |
| 2920 } | |
| 2921 | |
| 2922 void CMSCollector::verify_after_remark_work_1() { | |
| 2923 ResourceMark rm; | |
| 2924 HandleMark hm; | |
| 2925 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2926 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2927 // Get a clear set of claim bits for the strong roots processing to work with. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2928 ClassLoaderDataGraph::clear_claimed_marks(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2929 |
| 0 | 2930 // Mark from roots one level into CMS |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
2931 MarkRefsIntoClosure notOlder(_span, verification_mark_bm()); |
| 0 | 2932 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. |
| 2933 | |
| 2934 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 2935 true, // younger gens are roots | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
2936 true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2937 false, // not scavenging |
| 0 | 2938 SharedHeap::ScanningOption(roots_scanning_options()), |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
2939 ¬Older, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
2940 true, // walk code active on stacks |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2941 NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2942 NULL); // SSS: Provide correct closure |
| 0 | 2943 |
| 2944 // Now mark from the roots | |
| 2945 MarkFromRootsClosure markFromRootsClosure(this, _span, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2946 verification_mark_bm(), verification_mark_stack(), |
| 0 | 2947 false /* don't yield */, true /* verifying */); |
| 2948 assert(_restart_addr == NULL, "Expected pre-condition"); | |
| 2949 verification_mark_bm()->iterate(&markFromRootsClosure); | |
| 2950 while (_restart_addr != NULL) { | |
| 2951 // Deal with stack overflow: by restarting at the indicated | |
| 2952 // address. | |
| 2953 HeapWord* ra = _restart_addr; | |
| 2954 markFromRootsClosure.reset(ra); | |
| 2955 _restart_addr = NULL; | |
| 2956 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end()); | |
| 2957 } | |
| 2958 assert(verification_mark_stack()->isEmpty(), "Should have been drained"); | |
| 2959 verify_work_stacks_empty(); | |
| 2960 | |
| 2961 // Marking completed -- now verify that each bit marked in | |
| 2962 // verification_mark_bm() is also marked in markBitMap(); flag all | |
| 2963 // errors by printing corresponding objects. | |
| 2964 VerifyMarkedClosure vcl(markBitMap()); | |
| 2965 verification_mark_bm()->iterate(&vcl); | |
| 2966 if (vcl.failed()) { | |
| 2967 gclog_or_tty->print("Verification failed"); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2968 Universe::heap()->print_on(gclog_or_tty); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
2969 fatal("CMS: failed marking verification after remark"); |
| 0 | 2970 } |
| 2971 } | |
| 2972 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2973 class VerifyKlassOopsKlassClosure : public KlassClosure { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2974 class VerifyKlassOopsClosure : public OopClosure { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2975 CMSBitMap* _bitmap; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2976 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2977 VerifyKlassOopsClosure(CMSBitMap* bitmap) : _bitmap(bitmap) { } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2978 void do_oop(oop* p) { guarantee(*p == NULL || _bitmap->isMarked((HeapWord*) *p), "Should be marked"); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2979 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2980 } _oop_closure; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2981 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2982 VerifyKlassOopsKlassClosure(CMSBitMap* bitmap) : _oop_closure(bitmap) {} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2983 void do_klass(Klass* k) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2984 k->oops_do(&_oop_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2985 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2986 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2987 |
| 0 | 2988 void CMSCollector::verify_after_remark_work_2() { |
| 2989 ResourceMark rm; | |
| 2990 HandleMark hm; | |
| 2991 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 2992 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2993 // Get a clear set of claim bits for the strong roots processing to work with. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2994 ClassLoaderDataGraph::clear_claimed_marks(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2995 |
| 0 | 2996 // Mark from roots one level into CMS |
| 2997 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(), | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
2998 markBitMap()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2999 CMKlassClosure klass_closure(¬Older); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3000 |
| 0 | 3001 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. |
| 3002 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 3003 true, // younger gens are roots | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3004 true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3005 false, // not scavenging |
| 0 | 3006 SharedHeap::ScanningOption(roots_scanning_options()), |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3007 ¬Older, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3008 true, // walk code active on stacks |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3009 NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3010 &klass_closure); |
| 0 | 3011 |
| 3012 // Now mark from the roots | |
| 3013 MarkFromRootsVerifyClosure markFromRootsClosure(this, _span, | |
| 3014 verification_mark_bm(), markBitMap(), verification_mark_stack()); | |
| 3015 assert(_restart_addr == NULL, "Expected pre-condition"); | |
| 3016 verification_mark_bm()->iterate(&markFromRootsClosure); | |
| 3017 while (_restart_addr != NULL) { | |
| 3018 // Deal with stack overflow: by restarting at the indicated | |
| 3019 // address. | |
| 3020 HeapWord* ra = _restart_addr; | |
| 3021 markFromRootsClosure.reset(ra); | |
| 3022 _restart_addr = NULL; | |
| 3023 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end()); | |
| 3024 } | |
| 3025 assert(verification_mark_stack()->isEmpty(), "Should have been drained"); | |
| 3026 verify_work_stacks_empty(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3027 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3028 VerifyKlassOopsKlassClosure verify_klass_oops(verification_mark_bm()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3029 ClassLoaderDataGraph::classes_do(&verify_klass_oops); |
| 0 | 3030 |
| 3031 // Marking completed -- now verify that each bit marked in | |
| 3032 // verification_mark_bm() is also marked in markBitMap(); flag all | |
| 3033 // errors by printing corresponding objects. | |
| 3034 VerifyMarkedClosure vcl(markBitMap()); | |
| 3035 verification_mark_bm()->iterate(&vcl); | |
| 3036 assert(!vcl.failed(), "Else verification above should not have succeeded"); | |
| 3037 } | |
| 3038 | |
| 3039 void ConcurrentMarkSweepGeneration::save_marks() { | |
| 3040 // delegate to CMS space | |
| 3041 cmsSpace()->save_marks(); | |
| 3042 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 3043 _par_gc_thread_states[i]->promo.startTrackingPromotions(); | |
| 3044 } | |
| 3045 } | |
| 3046 | |
| 3047 bool ConcurrentMarkSweepGeneration::no_allocs_since_save_marks() { | |
| 3048 return cmsSpace()->no_allocs_since_save_marks(); | |
| 3049 } | |
| 3050 | |
| 3051 #define CMS_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \ | |
| 3052 \ | |
| 3053 void ConcurrentMarkSweepGeneration:: \ | |
| 3054 oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \ | |
| 3055 cl->set_generation(this); \ | |
| 3056 cmsSpace()->oop_since_save_marks_iterate##nv_suffix(cl); \ | |
| 3057 cl->reset_generation(); \ | |
| 3058 save_marks(); \ | |
| 3059 } | |
| 3060 | |
| 3061 ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DEFN) | |
| 3062 | |
| 3063 void | |
| 3064 ConcurrentMarkSweepGeneration::object_iterate_since_last_GC(ObjectClosure* blk) | |
| 3065 { | |
| 3066 // Not currently implemented; need to do the following. -- ysr. | |
| 3067 // dld -- I think that is used for some sort of allocation profiler. So it | |
| 3068 // really means the objects allocated by the mutator since the last | |
| 3069 // GC. We could potentially implement this cheaply by recording only | |
| 3070 // the direct allocations in a side data structure. | |
| 3071 // | |
| 3072 // I think we probably ought not to be required to support these | |
| 3073 // iterations at any arbitrary point; I think there ought to be some | |
| 3074 // call to enable/disable allocation profiling in a generation/space, | |
| 3075 // and the iterator ought to return the objects allocated in the | |
| 3076 // gen/space since the enable call, or the last iterator call (which | |
| 3077 // will probably be at a GC.) That way, for gens like CM&S that would | |
| 3078 // require some extra data structure to support this, we only pay the | |
| 3079 // cost when it's in use... | |
| 3080 cmsSpace()->object_iterate_since_last_GC(blk); | |
| 3081 } | |
| 3082 | |
| 3083 void | |
| 3084 ConcurrentMarkSweepGeneration::younger_refs_iterate(OopsInGenClosure* cl) { | |
| 3085 cl->set_generation(this); | |
| 3086 younger_refs_in_space_iterate(_cmsSpace, cl); | |
| 3087 cl->reset_generation(); | |
| 3088 } | |
| 3089 | |
| 3090 void | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3091 ConcurrentMarkSweepGeneration::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) { |
| 0 | 3092 if (freelistLock()->owned_by_self()) { |
| 3093 Generation::oop_iterate(mr, cl); | |
| 3094 } else { | |
| 3095 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3096 Generation::oop_iterate(mr, cl); | |
| 3097 } | |
| 3098 } | |
| 3099 | |
| 3100 void | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3101 ConcurrentMarkSweepGeneration::oop_iterate(ExtendedOopClosure* cl) { |
| 0 | 3102 if (freelistLock()->owned_by_self()) { |
| 3103 Generation::oop_iterate(cl); | |
| 3104 } else { | |
| 3105 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3106 Generation::oop_iterate(cl); | |
| 3107 } | |
| 3108 } | |
| 3109 | |
| 3110 void | |
| 3111 ConcurrentMarkSweepGeneration::object_iterate(ObjectClosure* cl) { | |
| 3112 if (freelistLock()->owned_by_self()) { | |
| 3113 Generation::object_iterate(cl); | |
| 3114 } else { | |
| 3115 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3116 Generation::object_iterate(cl); | |
| 3117 } | |
| 3118 } | |
| 3119 | |
| 3120 void | |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3121 ConcurrentMarkSweepGeneration::safe_object_iterate(ObjectClosure* cl) { |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3122 if (freelistLock()->owned_by_self()) { |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3123 Generation::safe_object_iterate(cl); |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3124 } else { |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3125 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3126 Generation::safe_object_iterate(cl); |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3127 } |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3128 } |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3129 |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
457
diff
changeset
|
3130 void |
| 0 | 3131 ConcurrentMarkSweepGeneration::post_compact() { |
| 3132 } | |
| 3133 | |
| 3134 void | |
| 3135 ConcurrentMarkSweepGeneration::prepare_for_verify() { | |
| 3136 // Fix the linear allocation blocks to look like free blocks. | |
| 3137 | |
| 3138 // Locks are normally acquired/released in gc_prologue/gc_epilogue, but those | |
| 3139 // are not called when the heap is verified during universe initialization and | |
| 3140 // at vm shutdown. | |
| 3141 if (freelistLock()->owned_by_self()) { | |
| 3142 cmsSpace()->prepare_for_verify(); | |
| 3143 } else { | |
| 3144 MutexLockerEx fll(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3145 cmsSpace()->prepare_for_verify(); | |
| 3146 } | |
| 3147 } | |
| 3148 | |
| 3149 void | |
| 6008 | 3150 ConcurrentMarkSweepGeneration::verify() { |
| 0 | 3151 // Locks are normally acquired/released in gc_prologue/gc_epilogue, but those |
| 3152 // are not called when the heap is verified during universe initialization and | |
| 3153 // at vm shutdown. | |
| 3154 if (freelistLock()->owned_by_self()) { | |
| 6008 | 3155 cmsSpace()->verify(); |
| 0 | 3156 } else { |
| 3157 MutexLockerEx fll(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 6008 | 3158 cmsSpace()->verify(); |
| 3159 } | |
| 3160 } | |
| 3161 | |
| 3162 void CMSCollector::verify() { | |
| 3163 _cmsGen->verify(); | |
| 0 | 3164 } |
| 3165 | |
| 3166 #ifndef PRODUCT | |
| 3167 bool CMSCollector::overflow_list_is_empty() const { | |
| 3168 assert(_num_par_pushes >= 0, "Inconsistency"); | |
| 3169 if (_overflow_list == NULL) { | |
| 3170 assert(_num_par_pushes == 0, "Inconsistency"); | |
| 3171 } | |
| 3172 return _overflow_list == NULL; | |
| 3173 } | |
| 3174 | |
| 3175 // The methods verify_work_stacks_empty() and verify_overflow_empty() | |
| 3176 // merely consolidate assertion checks that appear to occur together frequently. | |
| 3177 void CMSCollector::verify_work_stacks_empty() const { | |
| 3178 assert(_markStack.isEmpty(), "Marking stack should be empty"); | |
| 3179 assert(overflow_list_is_empty(), "Overflow list should be empty"); | |
| 3180 } | |
| 3181 | |
| 3182 void CMSCollector::verify_overflow_empty() const { | |
| 3183 assert(overflow_list_is_empty(), "Overflow list should be empty"); | |
| 3184 assert(no_preserved_marks(), "No preserved marks"); | |
| 3185 } | |
| 3186 #endif // PRODUCT | |
| 3187 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3188 // Decide if we want to enable class unloading as part of the |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3189 // ensuing concurrent GC cycle. We will collect and |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3190 // unload classes if it's the case that: |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3191 // (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
|
3192 // ExplicitGCInvokesConcurrentAndUnloadsClasses is set, OR |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3193 // (2) (a) class unloading is enabled at the command line, and |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3194 // (b) old gen is getting really full |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3195 // 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
|
3196 // 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
|
3197 // 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
|
3198 // 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
|
3199 // 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
|
3200 // the property that concurrent_cycles_since_last_unload() |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3201 // will not decrease unless a collection cycle happened and that |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3202 // _cmsGen->is_too_full() are |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3203 // themselves also monotonic in that sense. See check_monotonicity() |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3204 // below. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3205 void CMSCollector::update_should_unload_classes() { |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3206 _should_unload_classes = false; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3207 // Condition 1 above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3208 if (_full_gc_requested && ExplicitGCInvokesConcurrentAndUnloadsClasses) { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3209 _should_unload_classes = true; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3210 } else if (CMSClassUnloadingEnabled) { // Condition 2.a above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3211 // Disjuncts 2.b.(i,ii,iii) above |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3212 _should_unload_classes = (concurrent_cycles_since_last_unload() >= |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3213 CMSClassUnloadingMaxInterval) |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3214 || _cmsGen->is_too_full(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3215 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3216 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3217 |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3218 bool ConcurrentMarkSweepGeneration::is_too_full() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3219 bool res = should_concurrent_collect(); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3220 res = res && (occupancy() > (double)CMSIsTooFullPercentage/100.0); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3221 return res; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3222 } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3223 |
| 0 | 3224 void CMSCollector::setup_cms_unloading_and_verification_state() { |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
2379
diff
changeset
|
3225 const bool should_verify = VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC |
| 0 | 3226 || VerifyBeforeExit; |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
2379
diff
changeset
|
3227 const int rso = SharedHeap::SO_Strings | SharedHeap::SO_CodeCache; |
| 0 | 3228 |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3229 if (should_unload_classes()) { // Should unload classes this cycle |
| 0 | 3230 remove_root_scanning_option(rso); // Shrink the root set appropriately |
| 3231 set_verifying(should_verify); // Set verification state for this cycle | |
| 3232 return; // Nothing else needs to be done at this time | |
| 3233 } | |
| 3234 | |
| 3235 // Not unloading classes this cycle | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3236 assert(!should_unload_classes(), "Inconsitency!"); |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
3237 if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) { |
| 0 | 3238 // Include symbols, strings and code cache elements to prevent their resurrection. |
| 3239 add_root_scanning_option(rso); | |
| 3240 set_verifying(true); | |
| 3241 } else if (verifying() && !should_verify) { | |
| 3242 // We were verifying, but some verification flags got disabled. | |
| 3243 set_verifying(false); | |
| 3244 // Exclude symbols, strings and code cache elements from root scanning to | |
| 3245 // reduce IM and RM pauses. | |
| 3246 remove_root_scanning_option(rso); | |
| 3247 } | |
| 3248 } | |
| 3249 | |
| 3250 | |
| 3251 #ifndef PRODUCT | |
| 3252 HeapWord* CMSCollector::block_start(const void* p) const { | |
| 3253 const HeapWord* addr = (HeapWord*)p; | |
| 3254 if (_span.contains(p)) { | |
| 3255 if (_cmsGen->cmsSpace()->is_in_reserved(addr)) { | |
| 3256 return _cmsGen->cmsSpace()->block_start(p); | |
| 3257 } | |
| 3258 } | |
| 3259 return NULL; | |
| 3260 } | |
| 3261 #endif | |
| 3262 | |
| 3263 HeapWord* | |
| 3264 ConcurrentMarkSweepGeneration::expand_and_allocate(size_t word_size, | |
| 3265 bool tlab, | |
| 3266 bool parallel) { | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3267 CMSSynchronousYieldRequest yr; |
| 0 | 3268 assert(!tlab, "Can't deal with TLAB allocation"); |
| 3269 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); | |
| 3270 expand(word_size*HeapWordSize, MinHeapDeltaBytes, | |
| 3271 CMSExpansionCause::_satisfy_allocation); | |
| 3272 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3273 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3274 } | |
|
9
173195ff483a
6642634: Test nsk/regression/b6186200 crashed with SIGSEGV
ysr
parents:
7
diff
changeset
|
3275 return have_lock_and_allocate(word_size, tlab); |
| 0 | 3276 } |
| 3277 | |
| 3278 // YSR: All of this generation expansion/shrinking stuff is an exact copy of | |
| 3279 // OneContigSpaceCardGeneration, which makes me wonder if we should move this | |
| 3280 // to CardGeneration and share it... | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3281 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
|
3282 return CardGeneration::expand(bytes, expand_bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3283 } |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3284 |
| 0 | 3285 void ConcurrentMarkSweepGeneration::expand(size_t bytes, size_t expand_bytes, |
| 3286 CMSExpansionCause::Cause cause) | |
| 3287 { | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3288 |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3289 bool success = expand(bytes, expand_bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
3290 |
| 0 | 3291 // remember why we expanded; this information is used |
| 3292 // by shouldConcurrentCollect() when making decisions on whether to start | |
| 3293 // a new CMS cycle. | |
| 3294 if (success) { | |
| 3295 set_expansion_cause(cause); | |
| 3296 if (PrintGCDetails && Verbose) { | |
| 3297 gclog_or_tty->print_cr("Expanded CMS gen for %s", | |
| 3298 CMSExpansionCause::to_string(cause)); | |
| 3299 } | |
| 3300 } | |
| 3301 } | |
| 3302 | |
| 3303 HeapWord* ConcurrentMarkSweepGeneration::expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz) { | |
| 3304 HeapWord* res = NULL; | |
| 3305 MutexLocker x(ParGCRareEvent_lock); | |
| 3306 while (true) { | |
| 3307 // Expansion by some other thread might make alloc OK now: | |
| 3308 res = ps->lab.alloc(word_sz); | |
| 3309 if (res != NULL) return res; | |
| 3310 // If there's not enough expansion space available, give up. | |
| 3311 if (_virtual_space.uncommitted_size() < (word_sz * HeapWordSize)) { | |
| 3312 return NULL; | |
| 3313 } | |
| 3314 // Otherwise, we try expansion. | |
| 3315 expand(word_sz*HeapWordSize, MinHeapDeltaBytes, | |
| 3316 CMSExpansionCause::_allocate_par_lab); | |
| 3317 // Now go around the loop and try alloc again; | |
| 3318 // A competing par_promote might beat us to the expansion space, | |
| 3319 // so we may go around the loop again if promotion fails agaion. | |
| 3320 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3321 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3322 } | |
| 3323 } | |
| 3324 } | |
| 3325 | |
| 3326 | |
| 3327 bool ConcurrentMarkSweepGeneration::expand_and_ensure_spooling_space( | |
| 3328 PromotionInfo* promo) { | |
| 3329 MutexLocker x(ParGCRareEvent_lock); | |
| 3330 size_t refill_size_bytes = promo->refillSize() * HeapWordSize; | |
| 3331 while (true) { | |
| 3332 // Expansion by some other thread might make alloc OK now: | |
| 3333 if (promo->ensure_spooling_space()) { | |
| 3334 assert(promo->has_spooling_space(), | |
| 3335 "Post-condition of successful ensure_spooling_space()"); | |
| 3336 return true; | |
| 3337 } | |
| 3338 // If there's not enough expansion space available, give up. | |
| 3339 if (_virtual_space.uncommitted_size() < refill_size_bytes) { | |
| 3340 return false; | |
| 3341 } | |
| 3342 // Otherwise, we try expansion. | |
| 3343 expand(refill_size_bytes, MinHeapDeltaBytes, | |
| 3344 CMSExpansionCause::_allocate_par_spooling_space); | |
| 3345 // Now go around the loop and try alloc again; | |
| 3346 // A competing allocation might beat us to the expansion space, | |
| 3347 // so we may go around the loop again if allocation fails again. | |
| 3348 if (GCExpandToAllocateDelayMillis > 0) { | |
| 3349 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false); | |
| 3350 } | |
| 3351 } | |
| 3352 } | |
| 3353 | |
| 3354 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3355 void ConcurrentMarkSweepGeneration::shrink_by(size_t bytes) { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3356 assert_locked_or_safepoint(ExpandHeap_lock); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3357 // Shrink committed space |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3358 _virtual_space.shrink_by(bytes); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3359 // Shrink space; this also shrinks the space's BOT |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3360 _cmsSpace->set_end((HeapWord*) _virtual_space.high()); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3361 size_t new_word_size = heap_word_size(_cmsSpace->capacity()); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3362 // Shrink the shared block offset array |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3363 _bts->resize(new_word_size); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3364 MemRegion mr(_cmsSpace->bottom(), new_word_size); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3365 // Shrink the card table |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3366 Universe::heap()->barrier_set()->resize_covered_region(mr); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3367 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3368 if (Verbose && PrintGC) { |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3369 size_t new_mem_size = _virtual_space.committed_size(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3370 size_t old_mem_size = new_mem_size + bytes; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3371 gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K to " SIZE_FORMAT "K", |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3372 name(), old_mem_size/K, new_mem_size/K); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3373 } |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3374 } |
| 0 | 3375 |
| 3376 void ConcurrentMarkSweepGeneration::shrink(size_t bytes) { | |
| 3377 assert_locked_or_safepoint(Heap_lock); | |
| 3378 size_t size = ReservedSpace::page_align_size_down(bytes); | |
| 3379 if (size > 0) { | |
| 3380 shrink_by(size); | |
| 3381 } | |
| 3382 } | |
| 3383 | |
| 3384 bool ConcurrentMarkSweepGeneration::grow_by(size_t bytes) { | |
| 3385 assert_locked_or_safepoint(Heap_lock); | |
| 3386 bool result = _virtual_space.expand_by(bytes); | |
| 3387 if (result) { | |
| 3388 HeapWord* old_end = _cmsSpace->end(); | |
| 3389 size_t new_word_size = | |
| 3390 heap_word_size(_virtual_space.committed_size()); | |
| 3391 MemRegion mr(_cmsSpace->bottom(), new_word_size); | |
| 3392 _bts->resize(new_word_size); // resize the block offset shared array | |
| 3393 Universe::heap()->barrier_set()->resize_covered_region(mr); | |
| 3394 // Hmmmm... why doesn't CFLS::set_end verify locking? | |
| 3395 // This is quite ugly; FIX ME XXX | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
3396 _cmsSpace->assert_locked(freelistLock()); |
| 0 | 3397 _cmsSpace->set_end((HeapWord*)_virtual_space.high()); |
| 3398 | |
| 3399 // update the space and generation capacity counters | |
| 3400 if (UsePerfData) { | |
| 3401 _space_counters->update_capacity(); | |
| 3402 _gen_counters->update_all(); | |
| 3403 } | |
| 3404 | |
| 3405 if (Verbose && PrintGC) { | |
| 3406 size_t new_mem_size = _virtual_space.committed_size(); | |
| 3407 size_t old_mem_size = new_mem_size - bytes; | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6885
diff
changeset
|
3408 gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K", |
| 0 | 3409 name(), old_mem_size/K, bytes/K, new_mem_size/K); |
| 3410 } | |
| 3411 } | |
| 3412 return result; | |
| 3413 } | |
| 3414 | |
| 3415 bool ConcurrentMarkSweepGeneration::grow_to_reserved() { | |
| 3416 assert_locked_or_safepoint(Heap_lock); | |
| 3417 bool success = true; | |
| 3418 const size_t remaining_bytes = _virtual_space.uncommitted_size(); | |
| 3419 if (remaining_bytes > 0) { | |
| 3420 success = grow_by(remaining_bytes); | |
| 3421 DEBUG_ONLY(if (!success) warning("grow to reserved failed");) | |
| 3422 } | |
| 3423 return success; | |
| 3424 } | |
| 3425 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8784
diff
changeset
|
3426 void ConcurrentMarkSweepGeneration::shrink_free_list_by(size_t bytes) { |
| 0 | 3427 assert_locked_or_safepoint(Heap_lock); |
| 3428 assert_lock_strong(freelistLock()); | |
|
10180
ebded0261dfc
8012111: Remove warning about CMS generation shrinking.
jmasa
parents:
9152
diff
changeset
|
3429 if (PrintGCDetails && Verbose) { |
|
ebded0261dfc
8012111: Remove warning about CMS generation shrinking.
jmasa
parents:
9152
diff
changeset
|
3430 warning("Shrinking of CMS not yet implemented"); |
|
ebded0261dfc
8012111: Remove warning about CMS generation shrinking.
jmasa
parents:
9152
diff
changeset
|
3431 } |
| 0 | 3432 return; |
| 3433 } | |
| 3434 | |
| 3435 | |
| 3436 // Simple ctor/dtor wrapper for accounting & timer chores around concurrent | |
| 3437 // phases. | |
| 3438 class CMSPhaseAccounting: public StackObj { | |
| 3439 public: | |
| 3440 CMSPhaseAccounting(CMSCollector *collector, | |
| 3441 const char *phase, | |
| 3442 bool print_cr = true); | |
| 3443 ~CMSPhaseAccounting(); | |
| 3444 | |
| 3445 private: | |
| 3446 CMSCollector *_collector; | |
| 3447 const char *_phase; | |
| 3448 elapsedTimer _wallclock; | |
| 3449 bool _print_cr; | |
| 3450 | |
| 3451 public: | |
| 3452 // Not MT-safe; so do not pass around these StackObj's | |
| 3453 // where they may be accessed by other threads. | |
| 3454 jlong wallclock_millis() { | |
| 3455 assert(_wallclock.is_active(), "Wall clock should not stop"); | |
| 3456 _wallclock.stop(); // to record time | |
| 3457 jlong ret = _wallclock.milliseconds(); | |
| 3458 _wallclock.start(); // restart | |
| 3459 return ret; | |
| 3460 } | |
| 3461 }; | |
| 3462 | |
| 3463 CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector, | |
| 3464 const char *phase, | |
| 3465 bool print_cr) : | |
| 3466 _collector(collector), _phase(phase), _print_cr(print_cr) { | |
| 3467 | |
| 3468 if (PrintCMSStatistics != 0) { | |
| 3469 _collector->resetYields(); | |
| 3470 } | |
|
8740
62609ffa2fc6
8008684: CMS: concurrent phase start markers should always be printed
tschatzl
parents:
8736
diff
changeset
|
3471 if (PrintGCDetails) { |
| 0 | 3472 gclog_or_tty->date_stamp(PrintGCDateStamps); |
|
8740
62609ffa2fc6
8008684: CMS: concurrent phase start markers should always be printed
tschatzl
parents:
8736
diff
changeset
|
3473 gclog_or_tty->stamp(PrintGCTimeStamps); |
|
62609ffa2fc6
8008684: CMS: concurrent phase start markers should always be printed
tschatzl
parents:
8736
diff
changeset
|
3474 gclog_or_tty->print_cr("[%s-concurrent-%s-start]", |
| 0 | 3475 _collector->cmsGen()->short_name(), _phase); |
| 3476 } | |
| 3477 _collector->resetTimer(); | |
| 3478 _wallclock.start(); | |
| 3479 _collector->startTimer(); | |
| 3480 } | |
| 3481 | |
| 3482 CMSPhaseAccounting::~CMSPhaseAccounting() { | |
| 3483 assert(_wallclock.is_active(), "Wall clock should not have stopped"); | |
| 3484 _collector->stopTimer(); | |
| 3485 _wallclock.stop(); | |
| 3486 if (PrintGCDetails) { | |
| 3487 gclog_or_tty->date_stamp(PrintGCDateStamps); | |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3488 gclog_or_tty->stamp(PrintGCTimeStamps); |
| 0 | 3489 gclog_or_tty->print("[%s-concurrent-%s: %3.3f/%3.3f secs]", |
| 3490 _collector->cmsGen()->short_name(), | |
| 3491 _phase, _collector->timerValue(), _wallclock.seconds()); | |
| 3492 if (_print_cr) { | |
| 3493 gclog_or_tty->print_cr(""); | |
| 3494 } | |
| 3495 if (PrintCMSStatistics != 0) { | |
| 3496 gclog_or_tty->print_cr(" (CMS-concurrent-%s yielded %d times)", _phase, | |
| 3497 _collector->yields()); | |
| 3498 } | |
| 3499 } | |
| 3500 } | |
| 3501 | |
| 3502 // CMS work | |
| 3503 | |
| 3504 // Checkpoint the roots into this generation from outside | |
| 3505 // this generation. [Note this initial checkpoint need only | |
| 3506 // be approximate -- we'll do a catch up phase subsequently.] | |
| 3507 void CMSCollector::checkpointRootsInitial(bool asynch) { | |
| 3508 assert(_collectorState == InitialMarking, "Wrong collector state"); | |
| 3509 check_correct_thread_executing(); | |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
3510 TraceCMSMemoryManagerStats tms(_collectorState,GenCollectedHeap::heap()->gc_cause()); |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1994
diff
changeset
|
3511 |
| 0 | 3512 ReferenceProcessor* rp = ref_processor(); |
| 3513 SpecializationStats::clear(); | |
| 3514 assert(_restart_addr == NULL, "Control point invariant"); | |
| 3515 if (asynch) { | |
| 3516 // acquire locks for subsequent manipulations | |
| 3517 MutexLockerEx x(bitMapLock(), | |
| 3518 Mutex::_no_safepoint_check_flag); | |
| 3519 checkpointRootsInitialWork(asynch); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3827
diff
changeset
|
3520 // enable ("weak") refs discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3827
diff
changeset
|
3521 rp->enable_discovery(true /*verify_disabled*/, true /*check_no_refs*/); |
| 0 | 3522 _collectorState = Marking; |
| 3523 } else { | |
| 3524 // (Weak) Refs discovery: this is controlled from genCollectedHeap::do_collection | |
| 3525 // which recognizes if we are a CMS generation, and doesn't try to turn on | |
| 3526 // discovery; verify that they aren't meddling. | |
| 3527 assert(!rp->discovery_is_atomic(), | |
| 3528 "incorrect setting of discovery predicate"); | |
| 3529 assert(!rp->discovery_enabled(), "genCollectedHeap shouldn't control " | |
| 3530 "ref discovery for this generation kind"); | |
| 3531 // already have locks | |
| 3532 checkpointRootsInitialWork(asynch); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3827
diff
changeset
|
3533 // now enable ("weak") refs discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3827
diff
changeset
|
3534 rp->enable_discovery(true /*verify_disabled*/, false /*verify_no_refs*/); |
| 0 | 3535 _collectorState = Marking; |
| 3536 } | |
| 3537 SpecializationStats::print(); | |
| 3538 } | |
| 3539 | |
| 3540 void CMSCollector::checkpointRootsInitialWork(bool asynch) { | |
| 3541 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); | |
| 3542 assert(_collectorState == InitialMarking, "just checking"); | |
| 3543 | |
| 3544 // If there has not been a GC[n-1] since last GC[n] cycle completed, | |
| 3545 // precede our marking with a collection of all | |
| 3546 // younger generations to keep floating garbage to a minimum. | |
| 3547 // XXX: we won't do this for now -- it's an optimization to be done later. | |
| 3548 | |
| 3549 // already have locks | |
| 3550 assert_lock_strong(bitMapLock()); | |
| 3551 assert(_markBitMap.isAllClear(), "was reset at end of previous cycle"); | |
| 3552 | |
| 3553 // Setup the verification and class unloading state for this | |
| 3554 // CMS collection cycle. | |
| 3555 setup_cms_unloading_and_verification_state(); | |
| 3556 | |
| 3557 NOT_PRODUCT(TraceTime t("\ncheckpointRootsInitialWork", | |
| 3558 PrintGCDetails && Verbose, true, gclog_or_tty);) | |
| 3559 if (UseAdaptiveSizePolicy) { | |
| 3560 size_policy()->checkpoint_roots_initial_begin(); | |
| 3561 } | |
| 3562 | |
| 3563 // Reset all the PLAB chunk arrays if necessary. | |
| 3564 if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) { | |
| 3565 reset_survivor_plab_arrays(); | |
| 3566 } | |
| 3567 | |
| 3568 ResourceMark rm; | |
| 3569 HandleMark hm; | |
| 3570 | |
| 3571 FalseClosure falseClosure; | |
| 3572 // In the case of a synchronous collection, we will elide the | |
| 3573 // remark step, so it's important to catch all the nmethod oops | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
3574 // in this step. |
|
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
3575 // The final 'true' flag to gen_process_strong_roots will ensure this. |
|
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
3576 // If 'async' is true, we can relax the nmethod tracing. |
|
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
3577 MarkRefsIntoClosure notOlder(_span, &_markBitMap); |
| 0 | 3578 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
| 3579 | |
| 3580 verify_work_stacks_empty(); | |
| 3581 verify_overflow_empty(); | |
| 3582 | |
| 3583 gch->ensure_parsability(false); // fill TLABs, but no need to retire them | |
| 3584 // Update the saved marks which may affect the root scans. | |
| 3585 gch->save_marks(); | |
| 3586 | |
| 3587 // weak reference processing has not started yet. | |
| 3588 ref_processor()->set_enqueuing_is_done(false); | |
| 3589 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3590 // Need to remember all newly created CLDs, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3591 // so that we can guarantee that the remark finds them. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3592 ClassLoaderDataGraph::remember_new_clds(true); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3593 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3594 // Whenever a CLD is found, it will be claimed before proceeding to mark |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3595 // the klasses. The claimed marks need to be cleared before marking starts. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3596 ClassLoaderDataGraph::clear_claimed_marks(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3597 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3598 CMKlassClosure klass_closure(¬Older); |
| 0 | 3599 { |
| 3600 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 3601 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
| 3602 gch->gen_process_strong_roots(_cmsGen->level(), | |
| 3603 true, // younger gens are roots | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3604 true, // activate StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3605 false, // not scavenging |
| 0 | 3606 SharedHeap::ScanningOption(roots_scanning_options()), |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3607 ¬Older, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
3608 true, // walk all of code cache if (so & SO_CodeCache) |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3609 NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3610 &klass_closure); |
| 0 | 3611 } |
| 3612 | |
| 3613 // Clear mod-union table; it will be dirtied in the prologue of | |
| 3614 // CMS generation per each younger generation collection. | |
| 3615 | |
| 3616 assert(_modUnionTable.isAllClear(), | |
| 3617 "Was cleared in most recent final checkpoint phase" | |
| 3618 " or no bits are set in the gc_prologue before the start of the next " | |
| 3619 "subsequent marking phase."); | |
| 3620 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3621 assert(_ct->klass_rem_set()->mod_union_is_clear(), "Must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3622 |
| 0 | 3623 // Save the end of the used_region of the constituent generations |
| 3624 // to be used to limit the extent of sweep in each generation. | |
| 3625 save_sweep_limits(); | |
| 3626 if (UseAdaptiveSizePolicy) { | |
| 3627 size_policy()->checkpoint_roots_initial_end(gch->gc_cause()); | |
| 3628 } | |
| 3629 verify_overflow_empty(); | |
| 3630 } | |
| 3631 | |
| 3632 bool CMSCollector::markFromRoots(bool asynch) { | |
| 3633 // we might be tempted to assert that: | |
| 3634 // assert(asynch == !SafepointSynchronize::is_at_safepoint(), | |
| 3635 // "inconsistent argument?"); | |
| 3636 // However that wouldn't be right, because it's possible that | |
| 3637 // a safepoint is indeed in progress as a younger generation | |
| 3638 // stop-the-world GC happens even as we mark in this generation. | |
| 3639 assert(_collectorState == Marking, "inconsistent state?"); | |
| 3640 check_correct_thread_executing(); | |
| 3641 verify_overflow_empty(); | |
| 3642 | |
| 3643 bool res; | |
| 3644 if (asynch) { | |
| 3645 | |
| 3646 // Start the timers for adaptive size policy for the concurrent phases | |
| 3647 // Do it here so that the foreground MS can use the concurrent | |
| 3648 // timer since a foreground MS might has the sweep done concurrently | |
| 3649 // or STW. | |
| 3650 if (UseAdaptiveSizePolicy) { | |
| 3651 size_policy()->concurrent_marking_begin(); | |
| 3652 } | |
| 3653 | |
| 3654 // Weak ref discovery note: We may be discovering weak | |
| 3655 // refs in this generation concurrent (but interleaved) with | |
| 3656 // weak ref discovery by a younger generation collector. | |
| 3657 | |
| 3658 CMSTokenSyncWithLocks ts(true, bitMapLock()); | |
| 3659 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 3660 CMSPhaseAccounting pa(this, "mark", !PrintGCDetails); | |
| 3661 res = markFromRootsWork(asynch); | |
| 3662 if (res) { | |
| 3663 _collectorState = Precleaning; | |
| 3664 } else { // We failed and a foreground collection wants to take over | |
| 3665 assert(_foregroundGCIsActive, "internal state inconsistency"); | |
| 3666 assert(_restart_addr == NULL, "foreground will restart from scratch"); | |
| 3667 if (PrintGCDetails) { | |
| 3668 gclog_or_tty->print_cr("bailing out to foreground collection"); | |
| 3669 } | |
| 3670 } | |
| 3671 if (UseAdaptiveSizePolicy) { | |
| 3672 size_policy()->concurrent_marking_end(); | |
| 3673 } | |
| 3674 } else { | |
| 3675 assert(SafepointSynchronize::is_at_safepoint(), | |
| 3676 "inconsistent with asynch == false"); | |
| 3677 if (UseAdaptiveSizePolicy) { | |
| 3678 size_policy()->ms_collection_marking_begin(); | |
| 3679 } | |
| 3680 // already have locks | |
| 3681 res = markFromRootsWork(asynch); | |
| 3682 _collectorState = FinalMarking; | |
| 3683 if (UseAdaptiveSizePolicy) { | |
| 3684 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 3685 size_policy()->ms_collection_marking_end(gch->gc_cause()); | |
| 3686 } | |
| 3687 } | |
| 3688 verify_overflow_empty(); | |
| 3689 return res; | |
| 3690 } | |
| 3691 | |
| 3692 bool CMSCollector::markFromRootsWork(bool asynch) { | |
| 3693 // iterate over marked bits in bit map, doing a full scan and mark | |
| 3694 // from these roots using the following algorithm: | |
| 3695 // . if oop is to the right of the current scan pointer, | |
| 3696 // mark corresponding bit (we'll process it later) | |
| 3697 // . else (oop is to left of current scan pointer) | |
| 3698 // push oop on marking stack | |
| 3699 // . drain the marking stack | |
| 3700 | |
| 3701 // Note that when we do a marking step we need to hold the | |
| 3702 // bit map lock -- recall that direct allocation (by mutators) | |
| 3703 // and promotion (by younger generation collectors) is also | |
| 3704 // marking the bit map. [the so-called allocate live policy.] | |
| 3705 // Because the implementation of bit map marking is not | |
| 3706 // robust wrt simultaneous marking of bits in the same word, | |
| 3707 // we need to make sure that there is no such interference | |
| 3708 // between concurrent such updates. | |
| 3709 | |
| 3710 // already have locks | |
| 3711 assert_lock_strong(bitMapLock()); | |
| 3712 | |
| 3713 verify_work_stacks_empty(); | |
| 3714 verify_overflow_empty(); | |
| 3715 bool result = false; | |
| 1284 | 3716 if (CMSConcurrentMTEnabled && ConcGCThreads > 0) { |
| 0 | 3717 result = do_marking_mt(asynch); |
| 3718 } else { | |
| 3719 result = do_marking_st(asynch); | |
| 3720 } | |
| 3721 return result; | |
| 3722 } | |
| 3723 | |
| 3724 // Forward decl | |
| 3725 class CMSConcMarkingTask; | |
| 3726 | |
| 3727 class CMSConcMarkingTerminator: public ParallelTaskTerminator { | |
| 3728 CMSCollector* _collector; | |
| 3729 CMSConcMarkingTask* _task; | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3730 public: |
| 0 | 3731 virtual void yield(); |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3732 |
| 0 | 3733 // "n_threads" is the number of threads to be terminated. |
| 3734 // "queue_set" is a set of work queues of other threads. | |
| 3735 // "collector" is the CMS collector associated with this task terminator. | |
| 3736 // "yield" indicates whether we need the gang as a whole to yield. | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3737 CMSConcMarkingTerminator(int n_threads, TaskQueueSetSuper* queue_set, CMSCollector* collector) : |
| 0 | 3738 ParallelTaskTerminator(n_threads, queue_set), |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3739 _collector(collector) { } |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3740 |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3741 void set_task(CMSConcMarkingTask* task) { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3742 _task = task; |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3743 } |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3744 }; |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3745 |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3746 class CMSConcMarkingTerminatorTerminator: public TerminatorTerminator { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3747 CMSConcMarkingTask* _task; |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3748 public: |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3749 bool should_exit_termination(); |
| 0 | 3750 void set_task(CMSConcMarkingTask* task) { |
| 3751 _task = task; | |
| 3752 } | |
| 3753 }; | |
| 3754 | |
| 3755 // MT Concurrent Marking Task | |
| 3756 class CMSConcMarkingTask: public YieldingFlexibleGangTask { | |
| 3757 CMSCollector* _collector; | |
| 3758 int _n_workers; // requested/desired # workers | |
| 3759 bool _asynch; | |
| 3760 bool _result; | |
| 3761 CompactibleFreeListSpace* _cms_space; | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3762 char _pad_front[64]; // padding to ... |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3763 HeapWord* _global_finger; // ... avoid sharing cache line |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3764 char _pad_back[64]; |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3765 HeapWord* _restart_addr; |
| 0 | 3766 |
| 3767 // Exposed here for yielding support | |
| 3768 Mutex* const _bit_map_lock; | |
| 3769 | |
| 3770 // The per thread work queues, available here for stealing | |
| 3771 OopTaskQueueSet* _task_queues; | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3772 |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3773 // Termination (and yielding) support |
| 0 | 3774 CMSConcMarkingTerminator _term; |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3775 CMSConcMarkingTerminatorTerminator _term_term; |
| 0 | 3776 |
| 3777 public: | |
| 3778 CMSConcMarkingTask(CMSCollector* collector, | |
| 3779 CompactibleFreeListSpace* cms_space, | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3780 bool asynch, |
| 0 | 3781 YieldingFlexibleWorkGang* workers, |
| 3782 OopTaskQueueSet* task_queues): | |
| 3783 YieldingFlexibleGangTask("Concurrent marking done multi-threaded"), | |
| 3784 _collector(collector), | |
| 3785 _cms_space(cms_space), | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3786 _asynch(asynch), _n_workers(0), _result(true), |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3787 _task_queues(task_queues), |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3788 _term(_n_workers, task_queues, _collector), |
| 0 | 3789 _bit_map_lock(collector->bitMapLock()) |
| 3790 { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3791 _requested_size = _n_workers; |
| 0 | 3792 _term.set_task(this); |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3793 _term_term.set_task(this); |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3794 _restart_addr = _global_finger = _cms_space->bottom(); |
| 0 | 3795 } |
| 3796 | |
| 3797 | |
| 3798 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 3799 | |
| 3800 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 3801 | |
| 3802 HeapWord** global_finger_addr() { return &_global_finger; } | |
| 3803 | |
| 3804 CMSConcMarkingTerminator* terminator() { return &_term; } | |
| 3805 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3806 virtual void set_for_termination(int active_workers) { |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3807 terminator()->reset_for_reuse(active_workers); |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3808 } |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
3809 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3810 void work(uint worker_id); |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3811 bool should_yield() { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3812 return ConcurrentMarkSweepThread::should_yield() |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3813 && !_collector->foregroundGCIsActive() |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3814 && _asynch; |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3815 } |
| 0 | 3816 |
| 3817 virtual void coordinator_yield(); // stuff done by coordinator | |
| 3818 bool result() { return _result; } | |
| 3819 | |
| 3820 void reset(HeapWord* ra) { | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3821 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
|
3822 _restart_addr = _global_finger = ra; |
| 0 | 3823 _term.reset_for_reuse(); |
| 3824 } | |
| 3825 | |
| 3826 static bool get_work_from_overflow_stack(CMSMarkStack* ovflw_stk, | |
| 3827 OopTaskQueue* work_q); | |
| 3828 | |
| 3829 private: | |
| 3830 void do_scan_and_mark(int i, CompactibleFreeListSpace* sp); | |
| 3831 void do_work_steal(int i); | |
| 3832 void bump_global_finger(HeapWord* f); | |
| 3833 }; | |
| 3834 | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3835 bool CMSConcMarkingTerminatorTerminator::should_exit_termination() { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3836 assert(_task != NULL, "Error"); |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3837 return _task->yielding(); |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3838 // Note that we do not need the disjunct || _task->should_yield() above |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3839 // because we want terminating threads to yield only if the task |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3840 // is already in the midst of yielding, which happens only after at least one |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3841 // thread has yielded. |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3842 } |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3843 |
| 0 | 3844 void CMSConcMarkingTerminator::yield() { |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
3845 if (_task->should_yield()) { |
| 0 | 3846 _task->yield(); |
| 3847 } else { | |
| 3848 ParallelTaskTerminator::yield(); | |
| 3849 } | |
| 3850 } | |
| 3851 | |
| 3852 //////////////////////////////////////////////////////////////// | |
| 3853 // Concurrent Marking Algorithm Sketch | |
| 3854 //////////////////////////////////////////////////////////////// | |
| 3855 // Until all tasks exhausted (both spaces): | |
| 3856 // -- claim next available chunk | |
| 3857 // -- bump global finger via CAS | |
| 3858 // -- find first object that starts in this chunk | |
| 3859 // and start scanning bitmap from that position | |
| 3860 // -- scan marked objects for oops | |
| 3861 // -- CAS-mark target, and if successful: | |
| 3862 // . if target oop is above global finger (volatile read) | |
| 3863 // nothing to do | |
| 3864 // . if target oop is in chunk and above local finger | |
| 3865 // then nothing to do | |
| 3866 // . else push on work-queue | |
| 3867 // -- Deal with possible overflow issues: | |
| 3868 // . local work-queue overflow causes stuff to be pushed on | |
| 3869 // global (common) overflow queue | |
| 3870 // . always first empty local work queue | |
| 3871 // . then get a batch of oops from global work queue if any | |
| 3872 // . then do work stealing | |
| 3873 // -- When all tasks claimed (both spaces) | |
| 3874 // and local work queue empty, | |
| 3875 // then in a loop do: | |
| 3876 // . check global overflow stack; steal a batch of oops and trace | |
| 3877 // . try to steal from other threads oif GOS is empty | |
| 3878 // . if neither is available, offer termination | |
| 3879 // -- Terminate and return result | |
| 3880 // | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3881 void CMSConcMarkingTask::work(uint worker_id) { |
| 0 | 3882 elapsedTimer _timer; |
| 3883 ResourceMark rm; | |
| 3884 HandleMark hm; | |
| 3885 | |
| 3886 DEBUG_ONLY(_collector->verify_overflow_empty();) | |
| 3887 | |
| 3888 // Before we begin work, our work queue should be empty | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3889 assert(work_queue(worker_id)->size() == 0, "Expected to be empty"); |
| 0 | 3890 // Scan the bitmap covering _cms_space, tracing through grey objects. |
| 3891 _timer.start(); | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3892 do_scan_and_mark(worker_id, _cms_space); |
| 0 | 3893 _timer.stop(); |
| 3894 if (PrintCMSStatistics != 0) { | |
| 3895 gclog_or_tty->print_cr("Finished cms space scanning in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3896 worker_id, _timer.seconds()); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3897 // XXX: need xxx/xxx type of notation, two timers |
| 0 | 3898 } |
| 3899 | |
| 3900 // ... do work stealing | |
| 3901 _timer.reset(); | |
| 3902 _timer.start(); | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3903 do_work_steal(worker_id); |
| 0 | 3904 _timer.stop(); |
| 3905 if (PrintCMSStatistics != 0) { | |
| 3906 gclog_or_tty->print_cr("Finished work stealing in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3907 worker_id, _timer.seconds()); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3908 // XXX: need xxx/xxx type of notation, two timers |
| 0 | 3909 } |
| 3910 assert(_collector->_markStack.isEmpty(), "Should have been emptied"); | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3911 assert(work_queue(worker_id)->size() == 0, "Should have been emptied"); |
| 0 | 3912 // Note that under the current task protocol, the |
| 3913 // following assertion is true even of the spaces | |
| 3914 // expanded since the completion of the concurrent | |
| 3915 // marking. XXX This will likely change under a strict | |
| 3916 // ABORT semantics. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3917 // After perm removal the comparison was changed to |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3918 // greater than or equal to from strictly greater than. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3919 // Before perm removal the highest address sweep would |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3920 // have been at the end of perm gen but now is at the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3921 // end of the tenured gen. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
3922 assert(_global_finger >= _cms_space->end(), |
| 0 | 3923 "All tasks have been completed"); |
| 3924 DEBUG_ONLY(_collector->verify_overflow_empty();) | |
| 3925 } | |
| 3926 | |
| 3927 void CMSConcMarkingTask::bump_global_finger(HeapWord* f) { | |
| 3928 HeapWord* read = _global_finger; | |
| 3929 HeapWord* cur = read; | |
| 3930 while (f > read) { | |
| 3931 cur = read; | |
| 3932 read = (HeapWord*) Atomic::cmpxchg_ptr(f, &_global_finger, cur); | |
| 3933 if (cur == read) { | |
| 3934 // our cas succeeded | |
| 3935 assert(_global_finger >= f, "protocol consistency"); | |
| 3936 break; | |
| 3937 } | |
| 3938 } | |
| 3939 } | |
| 3940 | |
| 3941 // This is really inefficient, and should be redone by | |
| 3942 // using (not yet available) block-read and -write interfaces to the | |
| 3943 // stack and the work_queue. XXX FIX ME !!! | |
| 3944 bool CMSConcMarkingTask::get_work_from_overflow_stack(CMSMarkStack* ovflw_stk, | |
| 3945 OopTaskQueue* work_q) { | |
| 3946 // Fast lock-free check | |
| 3947 if (ovflw_stk->length() == 0) { | |
| 3948 return false; | |
| 3949 } | |
| 3950 assert(work_q->size() == 0, "Shouldn't steal"); | |
| 3951 MutexLockerEx ml(ovflw_stk->par_lock(), | |
| 3952 Mutex::_no_safepoint_check_flag); | |
| 3953 // Grab up to 1/4 the size of the work queue | |
|
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
3954 size_t num = MIN2((size_t)(work_q->max_elems() - work_q->size())/4, |
| 0 | 3955 (size_t)ParGCDesiredObjsFromOverflowList); |
| 3956 num = MIN2(num, ovflw_stk->length()); | |
| 3957 for (int i = (int) num; i > 0; i--) { | |
| 3958 oop cur = ovflw_stk->pop(); | |
| 3959 assert(cur != NULL, "Counted wrong?"); | |
| 3960 work_q->push(cur); | |
| 3961 } | |
| 3962 return num > 0; | |
| 3963 } | |
| 3964 | |
| 3965 void CMSConcMarkingTask::do_scan_and_mark(int i, CompactibleFreeListSpace* sp) { | |
| 3966 SequentialSubTasksDone* pst = sp->conc_par_seq_tasks(); | |
| 3967 int n_tasks = pst->n_tasks(); | |
| 3968 // We allow that there may be no tasks to do here because | |
| 3969 // we are restarting after a stack overflow. | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3970 assert(pst->valid() || n_tasks == 0, "Uninitialized use?"); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
3971 uint nth_task = 0; |
| 0 | 3972 |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3973 HeapWord* aligned_start = sp->bottom(); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3974 if (sp->used_region().contains(_restart_addr)) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3975 // 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
|
3976 // for this space. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3977 aligned_start = |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3978 (HeapWord*)align_size_down((uintptr_t)_restart_addr, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3979 CardTableModRefBS::card_size); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3980 } |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3981 |
| 0 | 3982 size_t chunk_size = sp->marking_task_size(); |
| 3983 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 3984 // Having claimed the nth task in this space, | |
| 3985 // compute the chunk that it corresponds to: | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
3986 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
|
3987 aligned_start + (nth_task+1)*chunk_size); |
| 0 | 3988 // Try and bump the global finger via a CAS; |
| 3989 // note that we need to do the global finger bump | |
| 3990 // _before_ taking the intersection below, because | |
| 3991 // the task corresponding to that region will be | |
| 3992 // deemed done even if the used_region() expands | |
| 3993 // because of allocation -- as it almost certainly will | |
| 3994 // during start-up while the threads yield in the | |
| 3995 // closure below. | |
| 3996 HeapWord* finger = span.end(); | |
| 3997 bump_global_finger(finger); // atomically | |
| 3998 // There are null tasks here corresponding to chunks | |
| 3999 // beyond the "top" address of the space. | |
| 4000 span = span.intersection(sp->used_region()); | |
| 4001 if (!span.is_empty()) { // Non-null task | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4002 HeapWord* prev_obj; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4003 assert(!span.contains(_restart_addr) || nth_task == 0, |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4004 "Inconsistency"); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4005 if (nth_task == 0) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4006 // 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
|
4007 if (span.contains(_restart_addr)) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4008 // 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
|
4009 // we might additionally skip a chunk prefix. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4010 prev_obj = _restart_addr; |
| 0 | 4011 } else { |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4012 prev_obj = span.start(); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4013 } |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4014 } else { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4015 // We want to skip the first object because |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4016 // 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
|
4017 // that _starts_ in this span; a fortiori, any |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4018 // object starting in an earlier span is scanned |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4019 // as part of an earlier claimed task. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4020 // 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
|
4021 // 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
|
4022 prev_obj = sp->block_start_careful(span.start()); |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4023 // 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
|
4024 // Printezis bits to avoid waiting for allocated |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4025 // objects to become initialized/parsable. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4026 while (prev_obj < span.start()) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4027 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
|
4028 if (sz > 0) { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4029 prev_obj += sz; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4030 } else { |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4031 // 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
|
4032 // scanning, but that appears unavoidable, short of |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4033 // locking the free list locks; see bug 6324141. |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4034 break; |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4035 } |
| 0 | 4036 } |
| 4037 } | |
| 4038 if (prev_obj < span.end()) { | |
| 4039 MemRegion my_span = MemRegion(prev_obj, span.end()); | |
| 4040 // Do the marking work within a non-empty span -- | |
| 4041 // the last argument to the constructor indicates whether the | |
| 4042 // iteration should be incremental with periodic yields. | |
| 4043 Par_MarkFromRootsClosure cl(this, _collector, my_span, | |
| 4044 &_collector->_markBitMap, | |
| 4045 work_queue(i), | |
| 4046 &_collector->_markStack, | |
| 4047 _asynch); | |
| 4048 _collector->_markBitMap.iterate(&cl, my_span.start(), my_span.end()); | |
| 4049 } // else nothing to do for this task | |
| 4050 } // else nothing to do for this task | |
| 4051 } | |
| 4052 // We'd be tempted to assert here that since there are no | |
| 4053 // more tasks left to claim in this space, the global_finger | |
| 4054 // must exceed space->top() and a fortiori space->end(). However, | |
| 4055 // that would not quite be correct because the bumping of | |
| 4056 // global_finger occurs strictly after the claiming of a task, | |
| 4057 // so by the time we reach here the global finger may not yet | |
| 4058 // have been bumped up by the thread that claimed the last | |
| 4059 // task. | |
| 4060 pst->all_tasks_completed(); | |
| 4061 } | |
| 4062 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4063 class Par_ConcMarkingClosure: public CMSOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4064 private: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4065 CMSCollector* _collector; |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4066 CMSConcMarkingTask* _task; |
| 0 | 4067 MemRegion _span; |
| 4068 CMSBitMap* _bit_map; | |
| 4069 CMSMarkStack* _overflow_stack; | |
| 4070 OopTaskQueue* _work_queue; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4071 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4072 DO_OOP_WORK_DEFN |
| 0 | 4073 public: |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4074 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4075 CMSBitMap* bit_map, CMSMarkStack* overflow_stack): |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4076 CMSOopClosure(collector->ref_processor()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4077 _collector(collector), |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4078 _task(task), |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4079 _span(collector->_span), |
| 0 | 4080 _work_queue(work_queue), |
| 4081 _bit_map(bit_map), | |
| 935 | 4082 _overflow_stack(overflow_stack) |
| 4083 { } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4084 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
|
4085 virtual void do_oop(narrowOop* p); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4086 |
| 0 | 4087 void trim_queue(size_t max); |
| 4088 void handle_stack_overflow(HeapWord* lost); | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4089 void do_yield_check() { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4090 if (_task->should_yield()) { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4091 _task->yield(); |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4092 } |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4093 } |
| 0 | 4094 }; |
| 4095 | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4096 // Grey object scanning during work stealing phase -- |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4097 // the salient assumption here is that any references |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4098 // 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
|
4099 // 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
|
4100 // 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
|
4101 // 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
|
4102 void Par_ConcMarkingClosure::do_oop(oop obj) { |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
4103 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
|
4104 HeapWord* addr = (HeapWord*)obj; |
| 0 | 4105 // Check if oop points into the CMS generation |
| 4106 // and is not marked | |
| 4107 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 4108 // a white object ... | |
| 4109 // If we manage to "claim" the object, by being the | |
| 4110 // first thread to mark it, then we push it on our | |
| 4111 // marking stack | |
| 4112 if (_bit_map->par_mark(addr)) { // ... now grey | |
| 4113 // push on work queue (grey set) | |
| 4114 bool simulate_overflow = false; | |
| 4115 NOT_PRODUCT( | |
| 4116 if (CMSMarkStackOverflowALot && | |
| 4117 _collector->simulate_overflow()) { | |
| 4118 // simulate a stack overflow | |
| 4119 simulate_overflow = true; | |
| 4120 } | |
| 4121 ) | |
| 4122 if (simulate_overflow || | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4123 !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { |
| 0 | 4124 // stack overflow |
| 4125 if (PrintCMSStatistics != 0) { | |
| 4126 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 4127 SIZE_FORMAT, _overflow_stack->capacity()); | |
| 4128 } | |
| 4129 // We cannot assert that the overflow stack is full because | |
| 4130 // it may have been emptied since. | |
| 4131 assert(simulate_overflow || | |
| 4132 _work_queue->size() == _work_queue->max_elems(), | |
| 4133 "Else push should have succeeded"); | |
| 4134 handle_stack_overflow(addr); | |
| 4135 } | |
| 4136 } // Else, some other thread got there first | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4137 do_yield_check(); |
| 0 | 4138 } |
| 4139 } | |
| 4140 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4141 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
|
4142 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
|
4143 |
| 0 | 4144 void Par_ConcMarkingClosure::trim_queue(size_t max) { |
| 4145 while (_work_queue->size() > max) { | |
| 4146 oop new_oop; | |
| 4147 if (_work_queue->pop_local(new_oop)) { | |
| 4148 assert(new_oop->is_oop(), "Should be an oop"); | |
| 4149 assert(_bit_map->isMarked((HeapWord*)new_oop), "Grey object"); | |
| 4150 assert(_span.contains((HeapWord*)new_oop), "Not in span"); | |
| 4151 new_oop->oop_iterate(this); // do_oop() above | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4152 do_yield_check(); |
| 0 | 4153 } |
| 4154 } | |
| 4155 } | |
| 4156 | |
| 4157 // Upon stack overflow, we discard (part of) the stack, | |
| 4158 // remembering the least address amongst those discarded | |
| 4159 // in CMSCollector's _restart_address. | |
| 4160 void Par_ConcMarkingClosure::handle_stack_overflow(HeapWord* lost) { | |
| 4161 // 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
|
4162 // workers from interfering with the work done below. |
| 0 | 4163 MutexLockerEx ml(_overflow_stack->par_lock(), |
| 4164 Mutex::_no_safepoint_check_flag); | |
| 4165 // Remember the least grey address discarded | |
| 4166 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost); | |
| 4167 _collector->lower_restart_addr(ra); | |
| 4168 _overflow_stack->reset(); // discard stack contents | |
| 4169 _overflow_stack->expand(); // expand the stack if possible | |
| 4170 } | |
| 4171 | |
| 4172 | |
| 4173 void CMSConcMarkingTask::do_work_steal(int i) { | |
| 4174 OopTaskQueue* work_q = work_queue(i); | |
| 4175 oop obj_to_scan; | |
| 4176 CMSBitMap* bm = &(_collector->_markBitMap); | |
| 4177 CMSMarkStack* ovflw = &(_collector->_markStack); | |
| 4178 int* seed = _collector->hash_seed(i); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4179 Par_ConcMarkingClosure cl(_collector, this, work_q, bm, ovflw); |
| 0 | 4180 while (true) { |
| 4181 cl.trim_queue(0); | |
| 4182 assert(work_q->size() == 0, "Should have been emptied above"); | |
| 4183 if (get_work_from_overflow_stack(ovflw, work_q)) { | |
| 4184 // Can't assert below because the work obtained from the | |
| 4185 // overflow stack may already have been stolen from us. | |
| 4186 // assert(work_q->size() > 0, "Work from overflow stack"); | |
| 4187 continue; | |
| 4188 } else if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 4189 assert(obj_to_scan->is_oop(), "Should be an oop"); | |
| 4190 assert(bm->isMarked((HeapWord*)obj_to_scan), "Grey object"); | |
| 4191 obj_to_scan->oop_iterate(&cl); | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4192 } else if (terminator()->offer_termination(&_term_term)) { |
| 0 | 4193 assert(work_q->size() == 0, "Impossible!"); |
| 4194 break; | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4195 } else if (yielding() || should_yield()) { |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1836
diff
changeset
|
4196 yield(); |
| 0 | 4197 } |
| 4198 } | |
| 4199 } | |
| 4200 | |
| 4201 // This is run by the CMS (coordinator) thread. | |
| 4202 void CMSConcMarkingTask::coordinator_yield() { | |
| 4203 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 4204 "CMS thread should hold CMS token"); | |
| 4205 // First give up the locks, then yield, then re-lock | |
| 4206 // We should probably use a constructor/destructor idiom to | |
| 4207 // do this unlock/lock or modify the MutexUnlocker class to | |
| 4208 // serve our purpose. XXX | |
| 4209 assert_lock_strong(_bit_map_lock); | |
| 4210 _bit_map_lock->unlock(); | |
| 4211 ConcurrentMarkSweepThread::desynchronize(true); | |
| 4212 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 4213 _collector->stopTimer(); | |
| 4214 if (PrintCMSStatistics != 0) { | |
| 4215 _collector->incrementYields(); | |
| 4216 } | |
| 4217 _collector->icms_wait(); | |
| 4218 | |
| 4219 // It is possible for whichever thread initiated the yield request | |
| 4220 // not to get a chance to wake up and take the bitmap lock between | |
| 4221 // this thread releasing it and reacquiring it. So, while the | |
| 4222 // should_yield() flag is on, let's sleep for a bit to give the | |
| 4223 // other thread a chance to wake up. The limit imposed on the number | |
| 4224 // of iterations is defensive, to avoid any unforseen circumstances | |
| 4225 // putting us into an infinite loop. Since it's always been this | |
| 4226 // (coordinator_yield()) method that was observed to cause the | |
| 4227 // problem, we are using a parameter (CMSCoordinatorYieldSleepCount) | |
| 4228 // which is by default non-zero. For the other seven methods that | |
| 4229 // also perform the yield operation, as are using a different | |
| 4230 // parameter (CMSYieldSleepCount) which is by default zero. This way we | |
| 4231 // can enable the sleeping for those methods too, if necessary. | |
| 4232 // See 6442774. | |
| 4233 // | |
| 4234 // We really need to reconsider the synchronization between the GC | |
| 4235 // thread and the yield-requesting threads in the future and we | |
| 4236 // should really use wait/notify, which is the recommended | |
| 4237 // way of doing this type of interaction. Additionally, we should | |
| 4238 // consolidate the eight methods that do the yield operation and they | |
| 4239 // are almost identical into one for better maintenability and | |
| 4240 // readability. See 6445193. | |
| 4241 // | |
| 4242 // Tony 2006.06.29 | |
| 4243 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
|
4244 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
4245 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 4246 os::sleep(Thread::current(), 1, false); |
| 4247 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 4248 } | |
| 4249 | |
| 4250 ConcurrentMarkSweepThread::synchronize(true); | |
| 4251 _bit_map_lock->lock_without_safepoint_check(); | |
| 4252 _collector->startTimer(); | |
| 4253 } | |
| 4254 | |
| 4255 bool CMSCollector::do_marking_mt(bool asynch) { | |
| 1284 | 4256 assert(ConcGCThreads > 0 && conc_workers() != NULL, "precondition"); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
4257 int num_workers = AdaptiveSizePolicy::calc_active_conc_workers( |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
4258 conc_workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
4259 conc_workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
4260 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
4261 conc_workers()->set_active_workers(num_workers); |
| 0 | 4262 |
| 4263 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); | |
| 4264 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4265 CMSConcMarkingTask tsk(this, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4266 cms_space, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4267 asynch, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4268 conc_workers(), |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4269 task_queues()); |
| 0 | 4270 |
| 4271 // Since the actual number of workers we get may be different | |
| 4272 // from the number we requested above, do we need to do anything different | |
| 4273 // below? In particular, may be we need to subclass the SequantialSubTasksDone | |
| 4274 // class?? XXX | |
| 4275 cms_space ->initialize_sequential_subtasks_for_marking(num_workers); | |
| 4276 | |
| 4277 // Refs discovery is already non-atomic. | |
| 4278 assert(!ref_processor()->discovery_is_atomic(), "Should be non-atomic"); | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4279 assert(ref_processor()->discovery_is_mt(), "Discovery should be MT"); |
| 0 | 4280 conc_workers()->start_task(&tsk); |
| 4281 while (tsk.yielded()) { | |
| 4282 tsk.coordinator_yield(); | |
| 4283 conc_workers()->continue_task(&tsk); | |
| 4284 } | |
| 4285 // If the task was aborted, _restart_addr will be non-NULL | |
| 4286 assert(tsk.completed() || _restart_addr != NULL, "Inconsistency"); | |
| 4287 while (_restart_addr != NULL) { | |
| 4288 // XXX For now we do not make use of ABORTED state and have not | |
| 4289 // yet implemented the right abort semantics (even in the original | |
| 4290 // single-threaded CMS case). That needs some more investigation | |
| 4291 // and is deferred for now; see CR# TBF. 07252005YSR. XXX | |
| 4292 assert(!CMSAbortSemantics || tsk.aborted(), "Inconsistency"); | |
| 4293 // If _restart_addr is non-NULL, a marking stack overflow | |
| 605 | 4294 // occurred; we need to do a fresh marking iteration from the |
| 0 | 4295 // indicated restart address. |
| 4296 if (_foregroundGCIsActive && asynch) { | |
| 4297 // We may be running into repeated stack overflows, having | |
| 4298 // reached the limit of the stack size, while making very | |
| 4299 // slow forward progress. It may be best to bail out and | |
| 4300 // let the foreground collector do its job. | |
| 4301 // Clear _restart_addr, so that foreground GC | |
| 4302 // works from scratch. This avoids the headache of | |
| 4303 // a "rescan" which would otherwise be needed because | |
| 4304 // of the dirty mod union table & card table. | |
| 4305 _restart_addr = NULL; | |
| 4306 return false; | |
| 4307 } | |
| 4308 // Adjust the task to restart from _restart_addr | |
| 4309 tsk.reset(_restart_addr); | |
| 4310 cms_space ->initialize_sequential_subtasks_for_marking(num_workers, | |
| 4311 _restart_addr); | |
| 4312 _restart_addr = NULL; | |
| 4313 // Get the workers going again | |
| 4314 conc_workers()->start_task(&tsk); | |
| 4315 while (tsk.yielded()) { | |
| 4316 tsk.coordinator_yield(); | |
| 4317 conc_workers()->continue_task(&tsk); | |
| 4318 } | |
| 4319 } | |
| 4320 assert(tsk.completed(), "Inconsistency"); | |
| 4321 assert(tsk.result() == true, "Inconsistency"); | |
| 4322 return true; | |
| 4323 } | |
| 4324 | |
| 4325 bool CMSCollector::do_marking_st(bool asynch) { | |
| 4326 ResourceMark rm; | |
| 4327 HandleMark hm; | |
| 4328 | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4329 // Temporarily make refs discovery single threaded (non-MT) |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4330 ReferenceProcessorMTDiscoveryMutator rp_mut_discovery(ref_processor(), false); |
| 0 | 4331 MarkFromRootsClosure markFromRootsClosure(this, _span, &_markBitMap, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4332 &_markStack, CMSYield && asynch); |
| 0 | 4333 // the last argument to iterate indicates whether the iteration |
| 4334 // should be incremental with periodic yields. | |
| 4335 _markBitMap.iterate(&markFromRootsClosure); | |
| 4336 // If _restart_addr is non-NULL, a marking stack overflow | |
| 605 | 4337 // occurred; we need to do a fresh iteration from the |
| 0 | 4338 // indicated restart address. |
| 4339 while (_restart_addr != NULL) { | |
| 4340 if (_foregroundGCIsActive && asynch) { | |
| 4341 // We may be running into repeated stack overflows, having | |
| 4342 // reached the limit of the stack size, while making very | |
| 4343 // slow forward progress. It may be best to bail out and | |
| 4344 // let the foreground collector do its job. | |
| 4345 // Clear _restart_addr, so that foreground GC | |
| 4346 // works from scratch. This avoids the headache of | |
| 4347 // a "rescan" which would otherwise be needed because | |
| 4348 // of the dirty mod union table & card table. | |
| 4349 _restart_addr = NULL; | |
| 4350 return false; // indicating failure to complete marking | |
| 4351 } | |
| 4352 // Deal with stack overflow: | |
| 4353 // we restart marking from _restart_addr | |
| 4354 HeapWord* ra = _restart_addr; | |
| 4355 markFromRootsClosure.reset(ra); | |
| 4356 _restart_addr = NULL; | |
| 4357 _markBitMap.iterate(&markFromRootsClosure, ra, _span.end()); | |
| 4358 } | |
| 4359 return true; | |
| 4360 } | |
| 4361 | |
| 4362 void CMSCollector::preclean() { | |
| 4363 check_correct_thread_executing(); | |
| 4364 assert(Thread::current()->is_ConcurrentGC_thread(), "Wrong thread"); | |
| 4365 verify_work_stacks_empty(); | |
| 4366 verify_overflow_empty(); | |
| 4367 _abort_preclean = false; | |
| 4368 if (CMSPrecleaningEnabled) { | |
| 4369 _eden_chunk_index = 0; | |
| 4370 size_t used = get_eden_used(); | |
| 4371 size_t capacity = get_eden_capacity(); | |
| 4372 // Don't start sampling unless we will get sufficiently | |
| 4373 // many samples. | |
| 4374 if (used < (capacity/(CMSScheduleRemarkSamplingRatio * 100) | |
| 4375 * CMSScheduleRemarkEdenPenetration)) { | |
| 4376 _start_sampling = true; | |
| 4377 } else { | |
| 4378 _start_sampling = false; | |
| 4379 } | |
| 4380 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 4381 CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails); | |
| 4382 preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1); | |
| 4383 } | |
| 4384 CMSTokenSync x(true); // is cms thread | |
| 4385 if (CMSPrecleaningEnabled) { | |
| 4386 sample_eden(); | |
| 4387 _collectorState = AbortablePreclean; | |
| 4388 } else { | |
| 4389 _collectorState = FinalMarking; | |
| 4390 } | |
| 4391 verify_work_stacks_empty(); | |
| 4392 verify_overflow_empty(); | |
| 4393 } | |
| 4394 | |
| 4395 // Try and schedule the remark such that young gen | |
| 4396 // occupancy is CMSScheduleRemarkEdenPenetration %. | |
| 4397 void CMSCollector::abortable_preclean() { | |
| 4398 check_correct_thread_executing(); | |
| 4399 assert(CMSPrecleaningEnabled, "Inconsistent control state"); | |
| 4400 assert(_collectorState == AbortablePreclean, "Inconsistent control state"); | |
| 4401 | |
| 4402 // If Eden's current occupancy is below this threshold, | |
| 4403 // immediately schedule the remark; else preclean | |
| 4404 // past the next scavenge in an effort to | |
| 4405 // schedule the pause as described avove. By choosing | |
| 4406 // CMSScheduleRemarkEdenSizeThreshold >= max eden size | |
| 4407 // we will never do an actual abortable preclean cycle. | |
| 4408 if (get_eden_used() > CMSScheduleRemarkEdenSizeThreshold) { | |
| 4409 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 4410 CMSPhaseAccounting pa(this, "abortable-preclean", !PrintGCDetails); | |
| 4411 // We need more smarts in the abortable preclean | |
| 4412 // loop below to deal with cases where allocation | |
| 4413 // in young gen is very very slow, and our precleaning | |
| 4414 // is running a losing race against a horde of | |
| 4415 // mutators intent on flooding us with CMS updates | |
| 4416 // (dirty cards). | |
| 4417 // One, admittedly dumb, strategy is to give up | |
| 4418 // after a certain number of abortable precleaning loops | |
| 4419 // or after a certain maximum time. We want to make | |
| 4420 // this smarter in the next iteration. | |
| 4421 // XXX FIX ME!!! YSR | |
| 4422 size_t loops = 0, workdone = 0, cumworkdone = 0, waited = 0; | |
| 4423 while (!(should_abort_preclean() || | |
| 4424 ConcurrentMarkSweepThread::should_terminate())) { | |
| 4425 workdone = preclean_work(CMSPrecleanRefLists2, CMSPrecleanSurvivors2); | |
| 4426 cumworkdone += workdone; | |
| 4427 loops++; | |
| 4428 // Voluntarily terminate abortable preclean phase if we have | |
| 4429 // been at it for too long. | |
| 4430 if ((CMSMaxAbortablePrecleanLoops != 0) && | |
| 4431 loops >= CMSMaxAbortablePrecleanLoops) { | |
| 4432 if (PrintGCDetails) { | |
| 4433 gclog_or_tty->print(" CMS: abort preclean due to loops "); | |
| 4434 } | |
| 4435 break; | |
| 4436 } | |
| 4437 if (pa.wallclock_millis() > CMSMaxAbortablePrecleanTime) { | |
| 4438 if (PrintGCDetails) { | |
| 4439 gclog_or_tty->print(" CMS: abort preclean due to time "); | |
| 4440 } | |
| 4441 break; | |
| 4442 } | |
| 4443 // If we are doing little work each iteration, we should | |
| 4444 // take a short break. | |
| 4445 if (workdone < CMSAbortablePrecleanMinWorkPerIteration) { | |
| 4446 // Sleep for some time, waiting for work to accumulate | |
| 4447 stopTimer(); | |
| 4448 cmsThread()->wait_on_cms_lock(CMSAbortablePrecleanWaitMillis); | |
| 4449 startTimer(); | |
| 4450 waited++; | |
| 4451 } | |
| 4452 } | |
| 4453 if (PrintCMSStatistics > 0) { | |
| 4454 gclog_or_tty->print(" [%d iterations, %d waits, %d cards)] ", | |
| 4455 loops, waited, cumworkdone); | |
| 4456 } | |
| 4457 } | |
| 4458 CMSTokenSync x(true); // is cms thread | |
| 4459 if (_collectorState != Idling) { | |
| 4460 assert(_collectorState == AbortablePreclean, | |
| 4461 "Spontaneous state transition?"); | |
| 4462 _collectorState = FinalMarking; | |
| 4463 } // Else, a foreground collection completed this CMS cycle. | |
| 4464 return; | |
| 4465 } | |
| 4466 | |
| 4467 // Respond to an Eden sampling opportunity | |
| 4468 void CMSCollector::sample_eden() { | |
| 4469 // Make sure a young gc cannot sneak in between our | |
| 4470 // reading and recording of a sample. | |
| 4471 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 4472 "Only the cms thread may collect Eden samples"); | |
| 4473 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 4474 "Should collect samples while holding CMS token"); | |
| 4475 if (!_start_sampling) { | |
| 4476 return; | |
| 4477 } | |
| 4478 if (_eden_chunk_array) { | |
| 4479 if (_eden_chunk_index < _eden_chunk_capacity) { | |
| 4480 _eden_chunk_array[_eden_chunk_index] = *_top_addr; // take sample | |
| 4481 assert(_eden_chunk_array[_eden_chunk_index] <= *_end_addr, | |
| 4482 "Unexpected state of Eden"); | |
| 4483 // We'd like to check that what we just sampled is an oop-start address; | |
| 4484 // however, we cannot do that here since the object may not yet have been | |
| 4485 // initialized. So we'll instead do the check when we _use_ this sample | |
| 4486 // later. | |
| 4487 if (_eden_chunk_index == 0 || | |
| 4488 (pointer_delta(_eden_chunk_array[_eden_chunk_index], | |
| 4489 _eden_chunk_array[_eden_chunk_index-1]) | |
| 4490 >= CMSSamplingGrain)) { | |
| 4491 _eden_chunk_index++; // commit sample | |
| 4492 } | |
| 4493 } | |
| 4494 } | |
| 4495 if ((_collectorState == AbortablePreclean) && !_abort_preclean) { | |
| 4496 size_t used = get_eden_used(); | |
| 4497 size_t capacity = get_eden_capacity(); | |
| 4498 assert(used <= capacity, "Unexpected state of Eden"); | |
| 4499 if (used > (capacity/100 * CMSScheduleRemarkEdenPenetration)) { | |
| 4500 _abort_preclean = true; | |
| 4501 } | |
| 4502 } | |
| 4503 } | |
| 4504 | |
| 4505 | |
| 4506 size_t CMSCollector::preclean_work(bool clean_refs, bool clean_survivor) { | |
| 4507 assert(_collectorState == Precleaning || | |
| 4508 _collectorState == AbortablePreclean, "incorrect state"); | |
| 4509 ResourceMark rm; | |
| 4510 HandleMark hm; | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4511 |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4512 // Precleaning is currently not MT but the reference processor |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4513 // may be set for MT. Disable it temporarily here. |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4514 ReferenceProcessor* rp = ref_processor(); |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4515 ReferenceProcessorMTDiscoveryMutator rp_mut_discovery(rp, false); |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
4516 |
| 0 | 4517 // Do one pass of scrubbing the discovered reference lists |
| 4518 // to remove any reference objects with strongly-reachable | |
| 4519 // referents. | |
| 4520 if (clean_refs) { | |
| 4521 CMSPrecleanRefsYieldClosure yield_cl(this); | |
| 4522 assert(rp->span().equals(_span), "Spans should be equal"); | |
| 4523 CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4524 &_markStack, true /* preclean */); |
| 0 | 4525 CMSDrainMarkingStackClosure complete_trace(this, |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4526 _span, &_markBitMap, &_markStack, |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
4527 &keep_alive, true /* preclean */); |
| 0 | 4528 |
| 4529 // We don't want this step to interfere with a young | |
| 4530 // collection because we don't want to take CPU | |
| 4531 // or memory bandwidth away from the young GC threads | |
| 4532 // (which may be as many as there are CPUs). | |
| 4533 // Note that we don't need to protect ourselves from | |
| 4534 // interference with mutators because they can't | |
| 4535 // manipulate the discovered reference lists nor affect | |
| 4536 // the computed reachability of the referents, the | |
| 4537 // only properties manipulated by the precleaning | |
| 4538 // of these reference lists. | |
| 4539 stopTimer(); | |
| 4540 CMSTokenSyncWithLocks x(true /* is cms thread */, | |
| 4541 bitMapLock()); | |
| 4542 startTimer(); | |
| 4543 sample_eden(); | |
| 935 | 4544 |
| 0 | 4545 // The following will yield to allow foreground |
| 4546 // collection to proceed promptly. XXX YSR: | |
| 4547 // The code in this method may need further | |
| 4548 // tweaking for better performance and some restructuring | |
| 4549 // for cleaner interfaces. | |
| 4550 rp->preclean_discovered_references( | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4551 rp->is_alive_non_header(), &keep_alive, &complete_trace, &yield_cl); |
| 0 | 4552 } |
| 4553 | |
| 4554 if (clean_survivor) { // preclean the active survivor space(s) | |
| 4555 assert(_young_gen->kind() == Generation::DefNew || | |
| 4556 _young_gen->kind() == Generation::ParNew || | |
| 4557 _young_gen->kind() == Generation::ASParNew, | |
| 4558 "incorrect type for cast"); | |
| 4559 DefNewGeneration* dng = (DefNewGeneration*)_young_gen; | |
| 4560 PushAndMarkClosure pam_cl(this, _span, ref_processor(), | |
| 4561 &_markBitMap, &_modUnionTable, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4562 &_markStack, true /* precleaning phase */); |
| 0 | 4563 stopTimer(); |
| 4564 CMSTokenSyncWithLocks ts(true /* is cms thread */, | |
| 4565 bitMapLock()); | |
| 4566 startTimer(); | |
| 4567 unsigned int before_count = | |
| 4568 GenCollectedHeap::heap()->total_collections(); | |
| 4569 SurvivorSpacePrecleanClosure | |
| 4570 sss_cl(this, _span, &_markBitMap, &_markStack, | |
| 4571 &pam_cl, before_count, CMSYield); | |
| 4572 dng->from()->object_iterate_careful(&sss_cl); | |
| 4573 dng->to()->object_iterate_careful(&sss_cl); | |
| 4574 } | |
| 4575 MarkRefsIntoAndScanClosure | |
| 4576 mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4577 &_markStack, this, CMSYield, |
| 0 | 4578 true /* precleaning phase */); |
| 4579 // CAUTION: The following closure has persistent state that may need to | |
| 4580 // be reset upon a decrease in the sequence of addresses it | |
| 4581 // processes. | |
| 4582 ScanMarkedObjectsAgainCarefullyClosure | |
| 4583 smoac_cl(this, _span, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4584 &_markBitMap, &_markStack, &mrias_cl, CMSYield); |
| 0 | 4585 |
| 4586 // Preclean dirty cards in ModUnionTable and CardTable using | |
| 4587 // appropriate convergence criterion; | |
| 4588 // repeat CMSPrecleanIter times unless we find that | |
| 4589 // we are losing. | |
| 4590 assert(CMSPrecleanIter < 10, "CMSPrecleanIter is too large"); | |
| 4591 assert(CMSPrecleanNumerator < CMSPrecleanDenominator, | |
| 4592 "Bad convergence multiplier"); | |
| 4593 assert(CMSPrecleanThreshold >= 100, | |
| 4594 "Unreasonably low CMSPrecleanThreshold"); | |
| 4595 | |
| 4596 size_t numIter, cumNumCards, lastNumCards, curNumCards; | |
| 4597 for (numIter = 0, cumNumCards = lastNumCards = curNumCards = 0; | |
| 4598 numIter < CMSPrecleanIter; | |
| 4599 numIter++, lastNumCards = curNumCards, cumNumCards += curNumCards) { | |
| 4600 curNumCards = preclean_mod_union_table(_cmsGen, &smoac_cl); | |
| 4601 if (Verbose && PrintGCDetails) { | |
| 4602 gclog_or_tty->print(" (modUnionTable: %d cards)", curNumCards); | |
| 4603 } | |
| 4604 // Either there are very few dirty cards, so re-mark | |
| 4605 // pause will be small anyway, or our pre-cleaning isn't | |
| 4606 // that much faster than the rate at which cards are being | |
| 4607 // dirtied, so we might as well stop and re-mark since | |
| 4608 // precleaning won't improve our re-mark time by much. | |
| 4609 if (curNumCards <= CMSPrecleanThreshold || | |
| 4610 (numIter > 0 && | |
| 4611 (curNumCards * CMSPrecleanDenominator > | |
| 4612 lastNumCards * CMSPrecleanNumerator))) { | |
| 4613 numIter++; | |
| 4614 cumNumCards += curNumCards; | |
| 4615 break; | |
| 4616 } | |
| 4617 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4618 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4619 preclean_klasses(&mrias_cl, _cmsGen->freelistLock()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4620 |
| 0 | 4621 curNumCards = preclean_card_table(_cmsGen, &smoac_cl); |
| 4622 cumNumCards += curNumCards; | |
| 4623 if (PrintGCDetails && PrintCMSStatistics != 0) { | |
| 4624 gclog_or_tty->print_cr(" (cardTable: %d cards, re-scanned %d cards, %d iterations)", | |
| 4625 curNumCards, cumNumCards, numIter); | |
| 4626 } | |
| 4627 return cumNumCards; // as a measure of useful work done | |
| 4628 } | |
| 4629 | |
| 4630 // PRECLEANING NOTES: | |
| 4631 // Precleaning involves: | |
| 4632 // . reading the bits of the modUnionTable and clearing the set bits. | |
| 4633 // . For the cards corresponding to the set bits, we scan the | |
| 4634 // objects on those cards. This means we need the free_list_lock | |
| 4635 // so that we can safely iterate over the CMS space when scanning | |
| 4636 // for oops. | |
| 4637 // . When we scan the objects, we'll be both reading and setting | |
| 4638 // marks in the marking bit map, so we'll need the marking bit map. | |
| 4639 // . For protecting _collector_state transitions, we take the CGC_lock. | |
| 4640 // Note that any races in the reading of of card table entries by the | |
| 4641 // CMS thread on the one hand and the clearing of those entries by the | |
| 4642 // VM thread or the setting of those entries by the mutator threads on the | |
| 4643 // other are quite benign. However, for efficiency it makes sense to keep | |
| 4644 // the VM thread from racing with the CMS thread while the latter is | |
| 4645 // dirty card info to the modUnionTable. We therefore also use the | |
| 4646 // CGC_lock to protect the reading of the card table and the mod union | |
| 4647 // table by the CM thread. | |
| 4648 // . We run concurrently with mutator updates, so scanning | |
| 4649 // needs to be done carefully -- we should not try to scan | |
| 4650 // potentially uninitialized objects. | |
| 4651 // | |
| 4652 // Locking strategy: While holding the CGC_lock, we scan over and | |
| 4653 // reset a maximal dirty range of the mod union / card tables, then lock | |
| 4654 // the free_list_lock and bitmap lock to do a full marking, then | |
| 4655 // release these locks; and repeat the cycle. This allows for a | |
| 4656 // certain amount of fairness in the sharing of these locks between | |
| 4657 // the CMS collector on the one hand, and the VM thread and the | |
| 4658 // mutators on the other. | |
| 4659 | |
| 4660 // NOTE: preclean_mod_union_table() and preclean_card_table() | |
| 4661 // further below are largely identical; if you need to modify | |
| 4662 // one of these methods, please check the other method too. | |
| 4663 | |
| 4664 size_t CMSCollector::preclean_mod_union_table( | |
| 4665 ConcurrentMarkSweepGeneration* gen, | |
| 4666 ScanMarkedObjectsAgainCarefullyClosure* cl) { | |
| 4667 verify_work_stacks_empty(); | |
| 4668 verify_overflow_empty(); | |
| 4669 | |
| 4670 // strategy: starting with the first card, accumulate contiguous | |
| 4671 // ranges of dirty cards; clear these cards, then scan the region | |
| 4672 // covered by these cards. | |
| 4673 | |
| 4674 // Since all of the MUT is committed ahead, we can just use | |
| 4675 // that, in case the generations expand while we are precleaning. | |
| 4676 // It might also be fine to just use the committed part of the | |
| 4677 // generation, but we might potentially miss cards when the | |
| 4678 // generation is rapidly expanding while we are in the midst | |
| 4679 // of precleaning. | |
| 4680 HeapWord* startAddr = gen->reserved().start(); | |
| 4681 HeapWord* endAddr = gen->reserved().end(); | |
| 4682 | |
| 4683 cl->setFreelistLock(gen->freelistLock()); // needed for yielding | |
| 4684 | |
| 4685 size_t numDirtyCards, cumNumDirtyCards; | |
| 4686 HeapWord *nextAddr, *lastAddr; | |
| 4687 for (cumNumDirtyCards = numDirtyCards = 0, | |
| 4688 nextAddr = lastAddr = startAddr; | |
| 4689 nextAddr < endAddr; | |
| 4690 nextAddr = lastAddr, cumNumDirtyCards += numDirtyCards) { | |
| 4691 | |
| 4692 ResourceMark rm; | |
| 4693 HandleMark hm; | |
| 4694 | |
| 4695 MemRegion dirtyRegion; | |
| 4696 { | |
| 4697 stopTimer(); | |
| 935 | 4698 // Potential yield point |
| 0 | 4699 CMSTokenSync ts(true); |
| 4700 startTimer(); | |
| 4701 sample_eden(); | |
| 4702 // Get dirty region starting at nextOffset (inclusive), | |
| 4703 // simultaneously clearing it. | |
| 4704 dirtyRegion = | |
| 4705 _modUnionTable.getAndClearMarkedRegion(nextAddr, endAddr); | |
| 4706 assert(dirtyRegion.start() >= nextAddr, | |
| 4707 "returned region inconsistent?"); | |
| 4708 } | |
| 4709 // Remember where the next search should begin. | |
| 4710 // The returned region (if non-empty) is a right open interval, | |
| 4711 // so lastOffset is obtained from the right end of that | |
| 4712 // interval. | |
| 4713 lastAddr = dirtyRegion.end(); | |
| 4714 // Should do something more transparent and less hacky XXX | |
| 4715 numDirtyCards = | |
| 4716 _modUnionTable.heapWordDiffToOffsetDiff(dirtyRegion.word_size()); | |
| 4717 | |
| 4718 // We'll scan the cards in the dirty region (with periodic | |
| 4719 // yields for foreground GC as needed). | |
| 4720 if (!dirtyRegion.is_empty()) { | |
| 4721 assert(numDirtyCards > 0, "consistency check"); | |
| 4722 HeapWord* stop_point = NULL; | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4723 stopTimer(); |
| 935 | 4724 // Potential yield point |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4725 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4726 bitMapLock()); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
4727 startTimer(); |
| 0 | 4728 { |
| 4729 verify_work_stacks_empty(); | |
| 4730 verify_overflow_empty(); | |
| 4731 sample_eden(); | |
| 4732 stop_point = | |
| 4733 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); | |
| 4734 } | |
| 4735 if (stop_point != NULL) { | |
| 4736 // The careful iteration stopped early either because it found an | |
| 4737 // uninitialized object, or because we were in the midst of an | |
| 4738 // "abortable preclean", which should now be aborted. Redirty | |
| 4739 // the bits corresponding to the partially-scanned or unscanned | |
| 4740 // cards. We'll either restart at the next block boundary or | |
| 4741 // abort the preclean. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4742 assert((_collectorState == AbortablePreclean && should_abort_preclean()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4743 "Should only be AbortablePreclean."); |
| 0 | 4744 _modUnionTable.mark_range(MemRegion(stop_point, dirtyRegion.end())); |
| 4745 if (should_abort_preclean()) { | |
| 4746 break; // out of preclean loop | |
| 4747 } else { | |
| 4748 // Compute the next address at which preclean should pick up; | |
| 4749 // might need bitMapLock in order to read P-bits. | |
| 4750 lastAddr = next_card_start_after_block(stop_point); | |
| 4751 } | |
| 4752 } | |
| 4753 } else { | |
| 4754 assert(lastAddr == endAddr, "consistency check"); | |
| 4755 assert(numDirtyCards == 0, "consistency check"); | |
| 4756 break; | |
| 4757 } | |
| 4758 } | |
| 4759 verify_work_stacks_empty(); | |
| 4760 verify_overflow_empty(); | |
| 4761 return cumNumDirtyCards; | |
| 4762 } | |
| 4763 | |
| 4764 // NOTE: preclean_mod_union_table() above and preclean_card_table() | |
| 4765 // below are largely identical; if you need to modify | |
| 4766 // one of these methods, please check the other method too. | |
| 4767 | |
| 4768 size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* gen, | |
| 4769 ScanMarkedObjectsAgainCarefullyClosure* cl) { | |
| 4770 // strategy: it's similar to precleamModUnionTable above, in that | |
| 4771 // we accumulate contiguous ranges of dirty cards, mark these cards | |
| 4772 // precleaned, then scan the region covered by these cards. | |
| 4773 HeapWord* endAddr = (HeapWord*)(gen->_virtual_space.high()); | |
| 4774 HeapWord* startAddr = (HeapWord*)(gen->_virtual_space.low()); | |
| 4775 | |
| 4776 cl->setFreelistLock(gen->freelistLock()); // needed for yielding | |
| 4777 | |
| 4778 size_t numDirtyCards, cumNumDirtyCards; | |
| 4779 HeapWord *lastAddr, *nextAddr; | |
| 4780 | |
| 4781 for (cumNumDirtyCards = numDirtyCards = 0, | |
| 4782 nextAddr = lastAddr = startAddr; | |
| 4783 nextAddr < endAddr; | |
| 4784 nextAddr = lastAddr, cumNumDirtyCards += numDirtyCards) { | |
| 4785 | |
| 4786 ResourceMark rm; | |
| 4787 HandleMark hm; | |
| 4788 | |
| 4789 MemRegion dirtyRegion; | |
| 4790 { | |
| 4791 // See comments in "Precleaning notes" above on why we | |
| 4792 // do this locking. XXX Could the locking overheads be | |
| 4793 // too high when dirty cards are sparse? [I don't think so.] | |
| 4794 stopTimer(); | |
| 4795 CMSTokenSync x(true); // is cms thread | |
| 4796 startTimer(); | |
| 4797 sample_eden(); | |
| 4798 // Get and clear dirty region from card table | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4799 dirtyRegion = _ct->ct_bs()->dirty_card_range_after_reset( |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4800 MemRegion(nextAddr, endAddr), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4801 true, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4802 CardTableModRefBS::precleaned_card_val()); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
4803 |
| 0 | 4804 assert(dirtyRegion.start() >= nextAddr, |
| 4805 "returned region inconsistent?"); | |
| 4806 } | |
| 4807 lastAddr = dirtyRegion.end(); | |
| 4808 numDirtyCards = | |
| 4809 dirtyRegion.word_size()/CardTableModRefBS::card_size_in_words; | |
| 4810 | |
| 4811 if (!dirtyRegion.is_empty()) { | |
| 4812 stopTimer(); | |
| 4813 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock()); | |
| 4814 startTimer(); | |
| 4815 sample_eden(); | |
| 4816 verify_work_stacks_empty(); | |
| 4817 verify_overflow_empty(); | |
| 4818 HeapWord* stop_point = | |
| 4819 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); | |
| 4820 if (stop_point != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4821 assert((_collectorState == AbortablePreclean && should_abort_preclean()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4822 "Should only be AbortablePreclean."); |
| 0 | 4823 _ct->ct_bs()->invalidate(MemRegion(stop_point, dirtyRegion.end())); |
| 4824 if (should_abort_preclean()) { | |
| 4825 break; // out of preclean loop | |
| 4826 } else { | |
| 4827 // Compute the next address at which preclean should pick up. | |
| 4828 lastAddr = next_card_start_after_block(stop_point); | |
| 4829 } | |
| 4830 } | |
| 4831 } else { | |
| 4832 break; | |
| 4833 } | |
| 4834 } | |
| 4835 verify_work_stacks_empty(); | |
| 4836 verify_overflow_empty(); | |
| 4837 return cumNumDirtyCards; | |
| 4838 } | |
| 4839 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4840 class PrecleanKlassClosure : public KlassClosure { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4841 CMKlassClosure _cm_klass_closure; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4842 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4843 PrecleanKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4844 void do_klass(Klass* k) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4845 if (k->has_accumulated_modified_oops()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4846 k->clear_accumulated_modified_oops(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4847 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4848 _cm_klass_closure.do_klass(k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4849 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4850 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4851 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4852 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4853 // The freelist lock is needed to prevent asserts, is it really needed? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4854 void CMSCollector::preclean_klasses(MarkRefsIntoAndScanClosure* cl, Mutex* freelistLock) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4855 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4856 cl->set_freelistLock(freelistLock); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4857 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4858 CMSTokenSyncWithLocks ts(true, freelistLock, bitMapLock()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4859 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4860 // SSS: Add equivalent to ScanMarkedObjectsAgainCarefullyClosure::do_yield_check and should_abort_preclean? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4861 // SSS: We should probably check if precleaning should be aborted, at suitable intervals? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4862 PrecleanKlassClosure preclean_klass_closure(cl); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4863 ClassLoaderDataGraph::classes_do(&preclean_klass_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4864 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4865 verify_work_stacks_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4866 verify_overflow_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4867 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
4868 |
| 0 | 4869 void CMSCollector::checkpointRootsFinal(bool asynch, |
| 4870 bool clear_all_soft_refs, bool init_mark_was_synchronous) { | |
| 4871 assert(_collectorState == FinalMarking, "incorrect state transition?"); | |
| 4872 check_correct_thread_executing(); | |
| 4873 // world is stopped at this checkpoint | |
| 4874 assert(SafepointSynchronize::is_at_safepoint(), | |
| 4875 "world should be stopped"); | |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
4876 TraceCMSMemoryManagerStats tms(_collectorState,GenCollectedHeap::heap()->gc_cause()); |
|
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
4877 |
| 0 | 4878 verify_work_stacks_empty(); |
| 4879 verify_overflow_empty(); | |
| 4880 | |
| 4881 SpecializationStats::clear(); | |
| 4882 if (PrintGCDetails) { | |
| 4883 gclog_or_tty->print("[YG occupancy: "SIZE_FORMAT" K ("SIZE_FORMAT" K)]", | |
| 4884 _young_gen->used() / K, | |
| 4885 _young_gen->capacity() / K); | |
| 4886 } | |
| 4887 if (asynch) { | |
| 4888 if (CMSScavengeBeforeRemark) { | |
| 4889 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 4890 // Temporarily set flag to false, GCH->do_collection will | |
| 4891 // expect it to be false and set to true | |
| 4892 FlagSetting fl(gch->_is_gc_active, false); | |
| 4893 NOT_PRODUCT(TraceTime t("Scavenge-Before-Remark", | |
| 4894 PrintGCDetails && Verbose, true, gclog_or_tty);) | |
| 4895 int level = _cmsGen->level() - 1; | |
| 4896 if (level >= 0) { | |
| 4897 gch->do_collection(true, // full (i.e. force, see below) | |
| 4898 false, // !clear_all_soft_refs | |
| 4899 0, // size | |
| 4900 false, // is_tlab | |
| 4901 level // max_level | |
| 4902 ); | |
| 4903 } | |
| 4904 } | |
| 4905 FreelistLocker x(this); | |
| 4906 MutexLockerEx y(bitMapLock(), | |
| 4907 Mutex::_no_safepoint_check_flag); | |
| 4908 assert(!init_mark_was_synchronous, "but that's impossible!"); | |
| 4909 checkpointRootsFinalWork(asynch, clear_all_soft_refs, false); | |
| 4910 } else { | |
| 4911 // already have all the locks | |
| 4912 checkpointRootsFinalWork(asynch, clear_all_soft_refs, | |
| 4913 init_mark_was_synchronous); | |
| 4914 } | |
| 4915 verify_work_stacks_empty(); | |
| 4916 verify_overflow_empty(); | |
| 4917 SpecializationStats::print(); | |
| 4918 } | |
| 4919 | |
| 4920 void CMSCollector::checkpointRootsFinalWork(bool asynch, | |
| 4921 bool clear_all_soft_refs, bool init_mark_was_synchronous) { | |
| 4922 | |
| 4923 NOT_PRODUCT(TraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, gclog_or_tty);) | |
| 4924 | |
| 4925 assert(haveFreelistLocks(), "must have free list locks"); | |
| 4926 assert_lock_strong(bitMapLock()); | |
| 4927 | |
| 4928 if (UseAdaptiveSizePolicy) { | |
| 4929 size_policy()->checkpoint_roots_final_begin(); | |
| 4930 } | |
| 4931 | |
| 4932 ResourceMark rm; | |
| 4933 HandleMark hm; | |
| 4934 | |
| 4935 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 4936 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
4937 if (should_unload_classes()) { |
| 0 | 4938 CodeCache::gc_prologue(); |
| 4939 } | |
| 4940 assert(haveFreelistLocks(), "must have free list locks"); | |
| 4941 assert_lock_strong(bitMapLock()); | |
| 4942 | |
| 4943 if (!init_mark_was_synchronous) { | |
| 4944 // We might assume that we need not fill TLAB's when | |
| 4945 // CMSScavengeBeforeRemark is set, because we may have just done | |
| 4946 // a scavenge which would have filled all TLAB's -- and besides | |
| 4947 // Eden would be empty. This however may not always be the case -- | |
| 4948 // for instance although we asked for a scavenge, it may not have | |
| 4949 // happened because of a JNI critical section. We probably need | |
| 4950 // a policy for deciding whether we can in that case wait until | |
| 4951 // the critical section releases and then do the remark following | |
| 4952 // the scavenge, and skip it here. In the absence of that policy, | |
| 4953 // or of an indication of whether the scavenge did indeed occur, | |
| 4954 // we cannot rely on TLAB's having been filled and must do | |
| 4955 // so here just in case a scavenge did not happen. | |
| 4956 gch->ensure_parsability(false); // fill TLAB's, but no need to retire them | |
| 4957 // Update the saved marks which may affect the root scans. | |
| 4958 gch->save_marks(); | |
| 4959 | |
| 4960 { | |
| 4961 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) | |
| 4962 | |
| 4963 // Note on the role of the mod union table: | |
| 4964 // Since the marker in "markFromRoots" marks concurrently with | |
| 4965 // mutators, it is possible for some reachable objects not to have been | |
| 4966 // scanned. For instance, an only reference to an object A was | |
| 4967 // placed in object B after the marker scanned B. Unless B is rescanned, | |
| 4968 // A would be collected. Such updates to references in marked objects | |
| 4969 // are detected via the mod union table which is the set of all cards | |
| 4970 // dirtied since the first checkpoint in this GC cycle and prior to | |
| 4971 // the most recent young generation GC, minus those cleaned up by the | |
| 4972 // concurrent precleaning. | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
4973 if (CMSParallelRemarkEnabled && CollectedHeap::use_parallel_gc_threads()) { |
| 0 | 4974 TraceTime t("Rescan (parallel) ", PrintGCDetails, false, gclog_or_tty); |
| 4975 do_remark_parallel(); | |
| 4976 } else { | |
| 4977 TraceTime t("Rescan (non-parallel) ", PrintGCDetails, false, | |
| 4978 gclog_or_tty); | |
| 4979 do_remark_non_parallel(); | |
| 4980 } | |
| 4981 } | |
| 4982 } else { | |
| 4983 assert(!asynch, "Can't have init_mark_was_synchronous in asynch mode"); | |
| 4984 // The initial mark was stop-world, so there's no rescanning to | |
| 4985 // do; go straight on to the next step below. | |
| 4986 } | |
| 4987 verify_work_stacks_empty(); | |
| 4988 verify_overflow_empty(); | |
| 4989 | |
| 4990 { | |
| 4991 NOT_PRODUCT(TraceTime ts("refProcessingWork", PrintGCDetails, false, gclog_or_tty);) | |
| 4992 refProcessingWork(asynch, clear_all_soft_refs); | |
| 4993 } | |
| 4994 verify_work_stacks_empty(); | |
| 4995 verify_overflow_empty(); | |
| 4996 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
4997 if (should_unload_classes()) { |
| 0 | 4998 CodeCache::gc_epilogue(); |
| 4999 } | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2137
diff
changeset
|
5000 JvmtiExport::gc_epilogue(); |
| 0 | 5001 |
| 5002 // If we encountered any (marking stack / work queue) overflow | |
| 5003 // events during the current CMS cycle, take appropriate | |
| 5004 // remedial measures, where possible, so as to try and avoid | |
| 5005 // recurrence of that condition. | |
| 5006 assert(_markStack.isEmpty(), "No grey objects"); | |
| 5007 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
|
5008 _ser_kac_ovflw + _ser_kac_preclean_ovflw; |
| 0 | 5009 if (ser_ovflw > 0) { |
| 5010 if (PrintCMSStatistics != 0) { | |
| 5011 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
|
5012 "(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
|
5013 ", kac_preclean="SIZE_FORMAT")", |
| 0 | 5014 _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
|
5015 _ser_kac_ovflw, _ser_kac_preclean_ovflw); |
| 0 | 5016 } |
| 5017 _markStack.expand(); | |
| 5018 _ser_pmc_remark_ovflw = 0; | |
| 5019 _ser_pmc_preclean_ovflw = 0; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
5020 _ser_kac_preclean_ovflw = 0; |
| 0 | 5021 _ser_kac_ovflw = 0; |
| 5022 } | |
| 5023 if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) { | |
| 5024 if (PrintCMSStatistics != 0) { | |
| 5025 gclog_or_tty->print_cr("Work queue overflow (benign) " | |
| 5026 "(pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT")", | |
| 5027 _par_pmc_remark_ovflw, _par_kac_ovflw); | |
| 5028 } | |
| 5029 _par_pmc_remark_ovflw = 0; | |
| 5030 _par_kac_ovflw = 0; | |
| 5031 } | |
| 5032 if (PrintCMSStatistics != 0) { | |
| 5033 if (_markStack._hit_limit > 0) { | |
| 5034 gclog_or_tty->print_cr(" (benign) Hit max stack size limit ("SIZE_FORMAT")", | |
| 5035 _markStack._hit_limit); | |
| 5036 } | |
| 5037 if (_markStack._failed_double > 0) { | |
| 5038 gclog_or_tty->print_cr(" (benign) Failed stack doubling ("SIZE_FORMAT")," | |
| 5039 " current capacity "SIZE_FORMAT, | |
| 5040 _markStack._failed_double, | |
| 5041 _markStack.capacity()); | |
| 5042 } | |
| 5043 } | |
| 5044 _markStack._hit_limit = 0; | |
| 5045 _markStack._failed_double = 0; | |
| 5046 | |
| 5047 if ((VerifyAfterGC || VerifyDuringGC) && | |
| 5048 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 5049 verify_after_remark(); | |
| 5050 } | |
| 5051 | |
| 5052 // Change under the freelistLocks. | |
| 5053 _collectorState = Sweeping; | |
| 5054 // Call isAllClear() under bitMapLock | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5055 assert(_modUnionTable.isAllClear(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5056 "Should be clear by end of the final marking"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5057 assert(_ct->klass_rem_set()->mod_union_is_clear(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5058 "Should be clear by end of the final marking"); |
| 0 | 5059 if (UseAdaptiveSizePolicy) { |
| 5060 size_policy()->checkpoint_roots_final_end(gch->gc_cause()); | |
| 5061 } | |
| 5062 } | |
| 5063 | |
| 5064 // Parallel remark task | |
| 5065 class CMSParRemarkTask: public AbstractGangTask { | |
| 5066 CMSCollector* _collector; | |
| 5067 int _n_workers; | |
| 5068 CompactibleFreeListSpace* _cms_space; | |
| 5069 | |
| 5070 // The per-thread work queues, available here for stealing. | |
| 5071 OopTaskQueueSet* _task_queues; | |
| 5072 ParallelTaskTerminator _term; | |
| 5073 | |
| 5074 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5075 // A value of 0 passed to n_workers will cause the number of |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5076 // workers to be taken from the active workers in the work gang. |
| 0 | 5077 CMSParRemarkTask(CMSCollector* collector, |
| 5078 CompactibleFreeListSpace* cms_space, | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5079 int n_workers, FlexibleWorkGang* workers, |
| 0 | 5080 OopTaskQueueSet* task_queues): |
| 5081 AbstractGangTask("Rescan roots and grey objects in parallel"), | |
| 5082 _collector(collector), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5083 _cms_space(cms_space), |
| 0 | 5084 _n_workers(n_workers), |
| 5085 _task_queues(task_queues), | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5086 _term(n_workers, task_queues) { } |
| 0 | 5087 |
| 5088 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 5089 | |
| 5090 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 5091 | |
| 5092 ParallelTaskTerminator* terminator() { return &_term; } | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5093 int n_workers() { return _n_workers; } |
| 0 | 5094 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5095 void work(uint worker_id); |
| 0 | 5096 |
| 5097 private: | |
| 5098 // Work method in support of parallel rescan ... of young gen spaces | |
| 5099 void do_young_space_rescan(int i, Par_MarkRefsIntoAndScanClosure* cl, | |
| 5100 ContiguousSpace* space, | |
| 5101 HeapWord** chunk_array, size_t chunk_top); | |
| 5102 | |
| 5103 // ... of dirty cards in old space | |
| 5104 void do_dirty_card_rescan_tasks(CompactibleFreeListSpace* sp, int i, | |
| 5105 Par_MarkRefsIntoAndScanClosure* cl); | |
| 5106 | |
| 5107 // ... work stealing for the above | |
| 5108 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed); | |
| 5109 }; | |
| 5110 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5111 class RemarkKlassClosure : public KlassClosure { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5112 CMKlassClosure _cm_klass_closure; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5113 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5114 RemarkKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5115 void do_klass(Klass* k) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5116 // Check if we have modified any oops in the Klass during the concurrent marking. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5117 if (k->has_accumulated_modified_oops()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5118 k->clear_accumulated_modified_oops(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5119 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5120 // We could have transfered the current modified marks to the accumulated marks, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5121 // like we do with the Card Table to Mod Union Table. But it's not really necessary. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5122 } else if (k->has_modified_oops()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5123 // Don't clear anything, this info is needed by the next young collection. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5124 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5125 // No modified oops in the Klass. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5126 return; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5127 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5128 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5129 // The klass has modified fields, need to scan the klass. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5130 _cm_klass_closure.do_klass(k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5131 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5132 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5133 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5134 // work_queue(i) is passed to the closure |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5135 // Par_MarkRefsIntoAndScanClosure. The "i" parameter |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5136 // also is passed to do_dirty_card_rescan_tasks() and to |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5137 // do_work_steal() to select the i-th task_queue. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5138 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5139 void CMSParRemarkTask::work(uint worker_id) { |
| 0 | 5140 elapsedTimer _timer; |
| 5141 ResourceMark rm; | |
| 5142 HandleMark hm; | |
| 5143 | |
| 5144 // ---------- rescan from roots -------------- | |
| 5145 _timer.start(); | |
| 5146 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 5147 Par_MarkRefsIntoAndScanClosure par_mrias_cl(_collector, | |
| 5148 _collector->_span, _collector->ref_processor(), | |
| 5149 &(_collector->_markBitMap), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5150 work_queue(worker_id)); |
| 0 | 5151 |
| 5152 // Rescan young gen roots first since these are likely | |
| 5153 // coarsely partitioned and may, on that account, constitute | |
| 5154 // the critical path; thus, it's best to start off that | |
| 5155 // work first. | |
| 5156 // ---------- young gen roots -------------- | |
| 5157 { | |
| 5158 DefNewGeneration* dng = _collector->_young_gen->as_DefNewGeneration(); | |
| 5159 EdenSpace* eden_space = dng->eden(); | |
| 5160 ContiguousSpace* from_space = dng->from(); | |
| 5161 ContiguousSpace* to_space = dng->to(); | |
| 5162 | |
| 5163 HeapWord** eca = _collector->_eden_chunk_array; | |
| 5164 size_t ect = _collector->_eden_chunk_index; | |
| 5165 HeapWord** sca = _collector->_survivor_chunk_array; | |
| 5166 size_t sct = _collector->_survivor_chunk_index; | |
| 5167 | |
| 5168 assert(ect <= _collector->_eden_chunk_capacity, "out of bounds"); | |
| 5169 assert(sct <= _collector->_survivor_chunk_capacity, "out of bounds"); | |
| 5170 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5171 do_young_space_rescan(worker_id, &par_mrias_cl, to_space, NULL, 0); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5172 do_young_space_rescan(worker_id, &par_mrias_cl, from_space, sca, sct); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5173 do_young_space_rescan(worker_id, &par_mrias_cl, eden_space, eca, ect); |
| 0 | 5174 |
| 5175 _timer.stop(); | |
| 5176 if (PrintCMSStatistics != 0) { | |
| 5177 gclog_or_tty->print_cr( | |
| 5178 "Finished young gen rescan work in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5179 worker_id, _timer.seconds()); |
| 0 | 5180 } |
| 5181 } | |
| 5182 | |
| 5183 // ---------- remaining roots -------------- | |
| 5184 _timer.reset(); | |
| 5185 _timer.start(); | |
| 5186 gch->gen_process_strong_roots(_collector->_cmsGen->level(), | |
| 5187 false, // yg was scanned above | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5188 false, // this is parallel code |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5189 false, // not scavenging |
| 0 | 5190 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5191 &par_mrias_cl, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5192 true, // walk all of code cache if (so & SO_CodeCache) |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5193 NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5194 NULL); // The dirty klasses will be handled below |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5195 assert(_collector->should_unload_classes() |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5196 || (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache), |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5197 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops"); |
| 0 | 5198 _timer.stop(); |
| 5199 if (PrintCMSStatistics != 0) { | |
| 5200 gclog_or_tty->print_cr( | |
| 5201 "Finished remaining root rescan work in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5202 worker_id, _timer.seconds()); |
| 0 | 5203 } |
| 5204 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5205 // ---------- unhandled CLD scanning ---------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5206 if (worker_id == 0) { // Single threaded at the moment. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5207 _timer.reset(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5208 _timer.start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5209 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5210 // Scan all new class loader data objects and new dependencies that were |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5211 // introduced during concurrent marking. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5212 ResourceMark rm; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5213 GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5214 for (int i = 0; i < array->length(); i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5215 par_mrias_cl.do_class_loader_data(array->at(i)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5216 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5217 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5218 // We don't need to keep track of new CLDs anymore. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5219 ClassLoaderDataGraph::remember_new_clds(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5220 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5221 _timer.stop(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5222 if (PrintCMSStatistics != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5223 gclog_or_tty->print_cr( |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5224 "Finished unhandled CLD scanning work in %dth thread: %3.3f sec", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5225 worker_id, _timer.seconds()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5226 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5227 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5228 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5229 // ---------- dirty klass scanning ---------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5230 if (worker_id == 0) { // Single threaded at the moment. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5231 _timer.reset(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5232 _timer.start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5233 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5234 // Scan all classes that was dirtied during the concurrent marking phase. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5235 RemarkKlassClosure remark_klass_closure(&par_mrias_cl); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5236 ClassLoaderDataGraph::classes_do(&remark_klass_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5237 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5238 _timer.stop(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5239 if (PrintCMSStatistics != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5240 gclog_or_tty->print_cr( |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5241 "Finished dirty klass scanning work in %dth thread: %3.3f sec", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5242 worker_id, _timer.seconds()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5243 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5244 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5245 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5246 // We might have added oops to ClassLoaderData::_handles during the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5247 // concurrent marking phase. These oops point to newly allocated objects |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5248 // that are guaranteed to be kept alive. Either by the direct allocation |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5249 // code, or when the young collector processes the strong roots. Hence, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5250 // we don't have to revisit the _handles block during the remark phase. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5251 |
| 0 | 5252 // ---------- rescan dirty cards ------------ |
| 5253 _timer.reset(); | |
| 5254 _timer.start(); | |
| 5255 | |
| 5256 // Do the rescan tasks for each of the two spaces | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5257 // (cms_space) in turn. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5258 // "worker_id" is passed to select the task_queue for "worker_id" |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5259 do_dirty_card_rescan_tasks(_cms_space, worker_id, &par_mrias_cl); |
| 0 | 5260 _timer.stop(); |
| 5261 if (PrintCMSStatistics != 0) { | |
| 5262 gclog_or_tty->print_cr( | |
| 5263 "Finished dirty card rescan work in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5264 worker_id, _timer.seconds()); |
| 0 | 5265 } |
| 5266 | |
| 5267 // ---------- steal work from other threads ... | |
| 5268 // ---------- ... and drain overflow list. | |
| 5269 _timer.reset(); | |
| 5270 _timer.start(); | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5271 do_work_steal(worker_id, &par_mrias_cl, _collector->hash_seed(worker_id)); |
| 0 | 5272 _timer.stop(); |
| 5273 if (PrintCMSStatistics != 0) { | |
| 5274 gclog_or_tty->print_cr( | |
| 5275 "Finished work stealing in %dth thread: %3.3f sec", | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5276 worker_id, _timer.seconds()); |
| 0 | 5277 } |
| 5278 } | |
| 5279 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5280 // Note that parameter "i" is not used. |
| 0 | 5281 void |
| 5282 CMSParRemarkTask::do_young_space_rescan(int i, | |
| 5283 Par_MarkRefsIntoAndScanClosure* cl, ContiguousSpace* space, | |
| 5284 HeapWord** chunk_array, size_t chunk_top) { | |
| 5285 // Until all tasks completed: | |
| 5286 // . claim an unclaimed task | |
| 5287 // . compute region boundaries corresponding to task claimed | |
| 5288 // using chunk_array | |
| 5289 // . par_oop_iterate(cl) over that region | |
| 5290 | |
| 5291 ResourceMark rm; | |
| 5292 HandleMark hm; | |
| 5293 | |
| 5294 SequentialSubTasksDone* pst = space->par_seq_tasks(); | |
| 5295 assert(pst->valid(), "Uninitialized use?"); | |
| 5296 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5297 uint nth_task = 0; |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5298 uint n_tasks = pst->n_tasks(); |
| 0 | 5299 |
| 5300 HeapWord *start, *end; | |
| 5301 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 5302 // We claimed task # nth_task; compute its boundaries. | |
| 5303 if (chunk_top == 0) { // no samples were taken | |
| 5304 assert(nth_task == 0 && n_tasks == 1, "Can have only 1 EdenSpace task"); | |
| 5305 start = space->bottom(); | |
| 5306 end = space->top(); | |
| 5307 } else if (nth_task == 0) { | |
| 5308 start = space->bottom(); | |
| 5309 end = chunk_array[nth_task]; | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5310 } else if (nth_task < (uint)chunk_top) { |
| 0 | 5311 assert(nth_task >= 1, "Control point invariant"); |
| 5312 start = chunk_array[nth_task - 1]; | |
| 5313 end = chunk_array[nth_task]; | |
| 5314 } else { | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5315 assert(nth_task == (uint)chunk_top, "Control point invariant"); |
| 0 | 5316 start = chunk_array[chunk_top - 1]; |
| 5317 end = space->top(); | |
| 5318 } | |
| 5319 MemRegion mr(start, end); | |
| 5320 // Verify that mr is in space | |
| 5321 assert(mr.is_empty() || space->used_region().contains(mr), | |
| 5322 "Should be in space"); | |
| 5323 // Verify that "start" is an object boundary | |
| 5324 assert(mr.is_empty() || oop(mr.start())->is_oop(), | |
| 5325 "Should be an oop"); | |
| 5326 space->par_oop_iterate(mr, cl); | |
| 5327 } | |
| 5328 pst->all_tasks_completed(); | |
| 5329 } | |
| 5330 | |
| 5331 void | |
| 5332 CMSParRemarkTask::do_dirty_card_rescan_tasks( | |
| 5333 CompactibleFreeListSpace* sp, int i, | |
| 5334 Par_MarkRefsIntoAndScanClosure* cl) { | |
| 5335 // Until all tasks completed: | |
| 5336 // . claim an unclaimed task | |
| 5337 // . compute region boundaries corresponding to task claimed | |
| 5338 // . transfer dirty bits ct->mut for that region | |
| 5339 // . apply rescanclosure to dirty mut bits for that region | |
| 5340 | |
| 5341 ResourceMark rm; | |
| 5342 HandleMark hm; | |
| 5343 | |
| 5344 OopTaskQueue* work_q = work_queue(i); | |
| 5345 ModUnionClosure modUnionClosure(&(_collector->_modUnionTable)); | |
| 5346 // CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! | |
| 5347 // CAUTION: This closure has state that persists across calls to | |
| 5348 // the work method dirty_range_iterate_clear() in that it has | |
| 5349 // imbedded in it a (subtype of) UpwardsObjectClosure. The | |
| 5350 // use of that state in the imbedded UpwardsObjectClosure instance | |
| 5351 // assumes that the cards are always iterated (even if in parallel | |
| 5352 // by several threads) in monotonically increasing order per each | |
| 5353 // thread. This is true of the implementation below which picks | |
| 5354 // card ranges (chunks) in monotonically increasing order globally | |
| 5355 // and, a-fortiori, in monotonically increasing order per thread | |
| 5356 // (the latter order being a subsequence of the former). | |
| 5357 // If the work code below is ever reorganized into a more chaotic | |
| 5358 // work-partitioning form than the current "sequential tasks" | |
| 5359 // paradigm, the use of that persistent state will have to be | |
| 5360 // revisited and modified appropriately. See also related | |
| 5361 // bug 4756801 work on which should examine this code to make | |
| 5362 // sure that the changes there do not run counter to the | |
| 5363 // assumptions made here and necessary for correctness and | |
| 5364 // efficiency. Note also that this code might yield inefficient | |
| 5365 // behaviour in the case of very large objects that span one or | |
| 5366 // more work chunks. Such objects would potentially be scanned | |
| 5367 // several times redundantly. Work on 4756801 should try and | |
| 5368 // address that performance anomaly if at all possible. XXX | |
| 5369 MemRegion full_span = _collector->_span; | |
| 5370 CMSBitMap* bm = &(_collector->_markBitMap); // shared | |
| 5371 MarkFromDirtyCardsClosure | |
| 5372 greyRescanClosure(_collector, full_span, // entire span of interest | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5373 sp, bm, work_q, cl); |
| 0 | 5374 |
| 5375 SequentialSubTasksDone* pst = sp->conc_par_seq_tasks(); | |
| 5376 assert(pst->valid(), "Uninitialized use?"); | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5377 uint nth_task = 0; |
| 0 | 5378 const int alignment = CardTableModRefBS::card_size * BitsPerWord; |
| 5379 MemRegion span = sp->used_region(); | |
| 5380 HeapWord* start_addr = span.start(); | |
| 5381 HeapWord* end_addr = (HeapWord*)round_to((intptr_t)span.end(), | |
| 5382 alignment); | |
| 5383 const size_t chunk_size = sp->rescan_task_size(); // in HeapWord units | |
| 5384 assert((HeapWord*)round_to((intptr_t)start_addr, alignment) == | |
| 5385 start_addr, "Check alignment"); | |
| 5386 assert((size_t)round_to((intptr_t)chunk_size, alignment) == | |
| 5387 chunk_size, "Check alignment"); | |
| 5388 | |
| 5389 while (!pst->is_task_claimed(/* reference */ nth_task)) { | |
| 5390 // Having claimed the nth_task, compute corresponding mem-region, | |
| 5391 // which is a-fortiori aligned correctly (i.e. at a MUT bopundary). | |
| 5392 // The alignment restriction ensures that we do not need any | |
| 5393 // synchronization with other gang-workers while setting or | |
| 5394 // clearing bits in thus chunk of the MUT. | |
| 5395 MemRegion this_span = MemRegion(start_addr + nth_task*chunk_size, | |
| 5396 start_addr + (nth_task+1)*chunk_size); | |
| 5397 // The last chunk's end might be way beyond end of the | |
| 5398 // used region. In that case pull back appropriately. | |
| 5399 if (this_span.end() > end_addr) { | |
| 5400 this_span.set_end(end_addr); | |
| 5401 assert(!this_span.is_empty(), "Program logic (calculation of n_tasks)"); | |
| 5402 } | |
| 5403 // Iterate over the dirty cards covering this chunk, marking them | |
| 5404 // precleaned, and setting the corresponding bits in the mod union | |
| 5405 // table. Since we have been careful to partition at Card and MUT-word | |
| 5406 // boundaries no synchronization is needed between parallel threads. | |
| 5407 _collector->_ct->ct_bs()->dirty_card_iterate(this_span, | |
| 5408 &modUnionClosure); | |
| 5409 | |
| 5410 // Having transferred these marks into the modUnionTable, | |
| 5411 // rescan the marked objects on the dirty cards in the modUnionTable. | |
| 5412 // Even if this is at a synchronous collection, the initial marking | |
| 5413 // may have been done during an asynchronous collection so there | |
| 5414 // may be dirty bits in the mod-union table. | |
| 5415 _collector->_modUnionTable.dirty_range_iterate_clear( | |
| 5416 this_span, &greyRescanClosure); | |
| 5417 _collector->_modUnionTable.verifyNoOneBitsInRange( | |
| 5418 this_span.start(), | |
| 5419 this_span.end()); | |
| 5420 } | |
| 5421 pst->all_tasks_completed(); // declare that i am done | |
| 5422 } | |
| 5423 | |
| 5424 // . see if we can share work_queues with ParNew? XXX | |
| 5425 void | |
| 5426 CMSParRemarkTask::do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, | |
| 5427 int* seed) { | |
| 5428 OopTaskQueue* work_q = work_queue(i); | |
| 5429 NOT_PRODUCT(int num_steals = 0;) | |
| 5430 oop obj_to_scan; | |
| 5431 CMSBitMap* bm = &(_collector->_markBitMap); | |
| 5432 | |
| 5433 while (true) { | |
| 5434 // Completely finish any left over work from (an) earlier round(s) | |
| 5435 cl->trim_queue(0); | |
|
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
5436 size_t num_from_overflow_list = MIN2((size_t)(work_q->max_elems() - work_q->size())/4, |
|
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
5437 (size_t)ParGCDesiredObjsFromOverflowList); |
| 0 | 5438 // Now check if there's any work in the overflow list |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5439 // Passing ParallelGCThreads as the third parameter, no_of_gc_threads, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5440 // only affects the number of attempts made to get work from the |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5441 // overflow list and does not affect the number of workers. Just |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5442 // pass ParallelGCThreads so this behavior is unchanged. |
| 0 | 5443 if (_collector->par_take_from_overflow_list(num_from_overflow_list, |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5444 work_q, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5445 ParallelGCThreads)) { |
| 0 | 5446 // found something in global overflow list; |
| 5447 // not yet ready to go stealing work from others. | |
| 5448 // We'd like to assert(work_q->size() != 0, ...) | |
| 5449 // because we just took work from the overflow list, | |
| 5450 // but of course we can't since all of that could have | |
| 5451 // been already stolen from us. | |
| 5452 // "He giveth and He taketh away." | |
| 5453 continue; | |
| 5454 } | |
| 5455 // Verify that we have no work before we resort to stealing | |
| 5456 assert(work_q->size() == 0, "Have work, shouldn't steal"); | |
| 5457 // Try to steal from other queues that have work | |
| 5458 if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 5459 NOT_PRODUCT(num_steals++;) | |
| 5460 assert(obj_to_scan->is_oop(), "Oops, not an oop!"); | |
| 5461 assert(bm->isMarked((HeapWord*)obj_to_scan), "Stole an unmarked oop?"); | |
| 5462 // Do scanning work | |
| 5463 obj_to_scan->oop_iterate(cl); | |
| 5464 // Loop around, finish this work, and try to steal some more | |
| 5465 } else if (terminator()->offer_termination()) { | |
| 5466 break; // nirvana from the infinite cycle | |
| 5467 } | |
| 5468 } | |
| 5469 NOT_PRODUCT( | |
| 5470 if (PrintCMSStatistics != 0) { | |
| 5471 gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); | |
| 5472 } | |
| 5473 ) | |
| 5474 assert(work_q->size() == 0 && _collector->overflow_list_is_empty(), | |
| 5475 "Else our work is not yet done"); | |
| 5476 } | |
| 5477 | |
| 5478 // Return a thread-local PLAB recording array, as appropriate. | |
| 5479 void* CMSCollector::get_data_recorder(int thr_num) { | |
| 5480 if (_survivor_plab_array != NULL && | |
| 5481 (CMSPLABRecordAlways || | |
| 5482 (_collectorState > Marking && _collectorState < FinalMarking))) { | |
| 5483 assert(thr_num < (int)ParallelGCThreads, "thr_num is out of bounds"); | |
| 5484 ChunkArray* ca = &_survivor_plab_array[thr_num]; | |
| 5485 ca->reset(); // clear it so that fresh data is recorded | |
| 5486 return (void*) ca; | |
| 5487 } else { | |
| 5488 return NULL; | |
| 5489 } | |
| 5490 } | |
| 5491 | |
| 5492 // Reset all the thread-local PLAB recording arrays | |
| 5493 void CMSCollector::reset_survivor_plab_arrays() { | |
| 5494 for (uint i = 0; i < ParallelGCThreads; i++) { | |
| 5495 _survivor_plab_array[i].reset(); | |
| 5496 } | |
| 5497 } | |
| 5498 | |
| 5499 // Merge the per-thread plab arrays into the global survivor chunk | |
| 5500 // array which will provide the partitioning of the survivor space | |
| 5501 // for CMS rescan. | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5502 void CMSCollector::merge_survivor_plab_arrays(ContiguousSpace* surv, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5503 int no_of_gc_threads) { |
| 0 | 5504 assert(_survivor_plab_array != NULL, "Error"); |
| 5505 assert(_survivor_chunk_array != NULL, "Error"); | |
| 5506 assert(_collectorState == FinalMarking, "Error"); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5507 for (int j = 0; j < no_of_gc_threads; j++) { |
| 0 | 5508 _cursor[j] = 0; |
| 5509 } | |
| 5510 HeapWord* top = surv->top(); | |
| 5511 size_t i; | |
| 5512 for (i = 0; i < _survivor_chunk_capacity; i++) { // all sca entries | |
| 5513 HeapWord* min_val = top; // Higher than any PLAB address | |
| 5514 uint min_tid = 0; // position of min_val this round | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5515 for (int j = 0; j < no_of_gc_threads; j++) { |
| 0 | 5516 ChunkArray* cur_sca = &_survivor_plab_array[j]; |
| 5517 if (_cursor[j] == cur_sca->end()) { | |
| 5518 continue; | |
| 5519 } | |
| 5520 assert(_cursor[j] < cur_sca->end(), "ctl pt invariant"); | |
| 5521 HeapWord* cur_val = cur_sca->nth(_cursor[j]); | |
| 5522 assert(surv->used_region().contains(cur_val), "Out of bounds value"); | |
| 5523 if (cur_val < min_val) { | |
| 5524 min_tid = j; | |
| 5525 min_val = cur_val; | |
| 5526 } else { | |
| 5527 assert(cur_val < top, "All recorded addresses should be less"); | |
| 5528 } | |
| 5529 } | |
| 5530 // At this point min_val and min_tid are respectively | |
| 5531 // the least address in _survivor_plab_array[j]->nth(_cursor[j]) | |
| 5532 // and the thread (j) that witnesses that address. | |
| 5533 // We record this address in the _survivor_chunk_array[i] | |
| 5534 // and increment _cursor[min_tid] prior to the next round i. | |
| 5535 if (min_val == top) { | |
| 5536 break; | |
| 5537 } | |
| 5538 _survivor_chunk_array[i] = min_val; | |
| 5539 _cursor[min_tid]++; | |
| 5540 } | |
| 5541 // We are all done; record the size of the _survivor_chunk_array | |
| 5542 _survivor_chunk_index = i; // exclusive: [0, i) | |
| 5543 if (PrintCMSStatistics > 0) { | |
| 5544 gclog_or_tty->print(" (Survivor:" SIZE_FORMAT "chunks) ", i); | |
| 5545 } | |
| 5546 // Verify that we used up all the recorded entries | |
| 5547 #ifdef ASSERT | |
| 5548 size_t total = 0; | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5549 for (int j = 0; j < no_of_gc_threads; j++) { |
| 0 | 5550 assert(_cursor[j] == _survivor_plab_array[j].end(), "Ctl pt invariant"); |
| 5551 total += _cursor[j]; | |
| 5552 } | |
| 5553 assert(total == _survivor_chunk_index, "Ctl Pt Invariant"); | |
| 5554 // Check that the merged array is in sorted order | |
| 5555 if (total > 0) { | |
| 5556 for (size_t i = 0; i < total - 1; i++) { | |
| 5557 if (PrintCMSStatistics > 0) { | |
| 5558 gclog_or_tty->print(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ", | |
| 5559 i, _survivor_chunk_array[i]); | |
| 5560 } | |
| 5561 assert(_survivor_chunk_array[i] < _survivor_chunk_array[i+1], | |
| 5562 "Not sorted"); | |
| 5563 } | |
| 5564 } | |
| 5565 #endif // ASSERT | |
| 5566 } | |
| 5567 | |
| 5568 // Set up the space's par_seq_tasks structure for work claiming | |
| 5569 // for parallel rescan of young gen. | |
| 5570 // See ParRescanTask where this is currently used. | |
| 5571 void | |
| 5572 CMSCollector:: | |
| 5573 initialize_sequential_subtasks_for_young_gen_rescan(int n_threads) { | |
| 5574 assert(n_threads > 0, "Unexpected n_threads argument"); | |
| 5575 DefNewGeneration* dng = (DefNewGeneration*)_young_gen; | |
| 5576 | |
| 5577 // Eden space | |
| 5578 { | |
| 5579 SequentialSubTasksDone* pst = dng->eden()->par_seq_tasks(); | |
| 5580 assert(!pst->valid(), "Clobbering existing data?"); | |
| 5581 // Each valid entry in [0, _eden_chunk_index) represents a task. | |
| 5582 size_t n_tasks = _eden_chunk_index + 1; | |
| 5583 assert(n_tasks == 1 || _eden_chunk_array != NULL, "Error"); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5584 // Sets the condition for completion of the subtask (how many threads |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5585 // need to finish in order to be done). |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5586 pst->set_n_threads(n_threads); |
| 0 | 5587 pst->set_n_tasks((int)n_tasks); |
| 5588 } | |
| 5589 | |
| 5590 // Merge the survivor plab arrays into _survivor_chunk_array | |
| 5591 if (_survivor_plab_array != NULL) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5592 merge_survivor_plab_arrays(dng->from(), n_threads); |
| 0 | 5593 } else { |
| 5594 assert(_survivor_chunk_index == 0, "Error"); | |
| 5595 } | |
| 5596 | |
| 5597 // To space | |
| 5598 { | |
| 5599 SequentialSubTasksDone* pst = dng->to()->par_seq_tasks(); | |
| 5600 assert(!pst->valid(), "Clobbering existing data?"); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5601 // Sets the condition for completion of the subtask (how many threads |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5602 // need to finish in order to be done). |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5603 pst->set_n_threads(n_threads); |
| 0 | 5604 pst->set_n_tasks(1); |
| 5605 assert(pst->valid(), "Error"); | |
| 5606 } | |
| 5607 | |
| 5608 // From space | |
| 5609 { | |
| 5610 SequentialSubTasksDone* pst = dng->from()->par_seq_tasks(); | |
| 5611 assert(!pst->valid(), "Clobbering existing data?"); | |
| 5612 size_t n_tasks = _survivor_chunk_index + 1; | |
| 5613 assert(n_tasks == 1 || _survivor_chunk_array != NULL, "Error"); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5614 // Sets the condition for completion of the subtask (how many threads |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5615 // need to finish in order to be done). |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5616 pst->set_n_threads(n_threads); |
| 0 | 5617 pst->set_n_tasks((int)n_tasks); |
| 5618 assert(pst->valid(), "Error"); | |
| 5619 } | |
| 5620 } | |
| 5621 | |
| 5622 // Parallel version of remark | |
| 5623 void CMSCollector::do_remark_parallel() { | |
| 5624 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5625 FlexibleWorkGang* workers = gch->workers(); |
| 0 | 5626 assert(workers != NULL, "Need parallel worker threads."); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5627 // Choose to use the number of GC workers most recently set |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5628 // into "active_workers". If active_workers is not set, set it |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5629 // to ParallelGCThreads. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5630 int n_workers = workers->active_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5631 if (n_workers == 0) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5632 assert(n_workers > 0, "Should have been set during scavenge"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5633 n_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5634 workers->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5635 } |
| 0 | 5636 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace(); |
| 5637 | |
| 5638 CMSParRemarkTask tsk(this, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5639 cms_space, |
| 0 | 5640 n_workers, workers, task_queues()); |
| 5641 | |
| 5642 // Set up for parallel process_strong_roots work. | |
| 5643 gch->set_par_threads(n_workers); | |
| 5644 // We won't be iterating over the cards in the card table updating | |
| 5645 // the younger_gen cards, so we shouldn't call the following else | |
| 5646 // the verification code as well as subsequent younger_refs_iterate | |
| 5647 // code would get confused. XXX | |
| 5648 // gch->rem_set()->prepare_for_younger_refs_iterate(true); // parallel | |
| 5649 | |
| 5650 // The young gen rescan work will not be done as part of | |
| 5651 // process_strong_roots (which currently doesn't knw how to | |
| 5652 // parallelize such a scan), but rather will be broken up into | |
| 5653 // a set of parallel tasks (via the sampling that the [abortable] | |
| 5654 // preclean phase did of EdenSpace, plus the [two] tasks of | |
| 5655 // scanning the [two] survivor spaces. Further fine-grain | |
| 5656 // parallelization of the scanning of the survivor spaces | |
| 5657 // themselves, and of precleaning of the younger gen itself | |
| 5658 // is deferred to the future. | |
| 5659 initialize_sequential_subtasks_for_young_gen_rescan(n_workers); | |
| 5660 | |
| 5661 // The dirty card rescan work is broken up into a "sequence" | |
| 5662 // of parallel tasks (per constituent space) that are dynamically | |
| 5663 // claimed by the parallel threads. | |
| 5664 cms_space->initialize_sequential_subtasks_for_rescan(n_workers); | |
| 5665 | |
| 5666 // It turns out that even when we're using 1 thread, doing the work in a | |
| 5667 // separate thread causes wide variance in run times. We can't help this | |
| 5668 // in the multi-threaded case, but we special-case n=1 here to get | |
| 5669 // repeatable measurements of the 1-thread overhead of the parallel code. | |
| 5670 if (n_workers > 1) { | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5671 // Make refs discovery MT-safe, if it isn't already: it may not |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5672 // necessarily be so, since it's possible that we are doing |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5673 // ST marking. |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5674 ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), true); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5675 GenCollectedHeap::StrongRootsScope srs(gch); |
| 0 | 5676 workers->run_task(&tsk); |
| 5677 } else { | |
|
4876
be649fefcdc2
7134655: Crash in reference processing when doing single-threaded remarking
stefank
parents:
4728
diff
changeset
|
5678 ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), false); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5679 GenCollectedHeap::StrongRootsScope srs(gch); |
| 0 | 5680 tsk.work(0); |
| 5681 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5682 |
| 0 | 5683 gch->set_par_threads(0); // 0 ==> non-parallel. |
| 5684 // restore, single-threaded for now, any preserved marks | |
| 5685 // as a result of work_q overflow | |
| 5686 restore_preserved_marks_if_any(); | |
| 5687 } | |
| 5688 | |
| 5689 // Non-parallel version of remark | |
| 5690 void CMSCollector::do_remark_non_parallel() { | |
| 5691 ResourceMark rm; | |
| 5692 HandleMark hm; | |
| 5693 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
4876
be649fefcdc2
7134655: Crash in reference processing when doing single-threaded remarking
stefank
parents:
4728
diff
changeset
|
5694 ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), false); |
|
be649fefcdc2
7134655: Crash in reference processing when doing single-threaded remarking
stefank
parents:
4728
diff
changeset
|
5695 |
| 0 | 5696 MarkRefsIntoAndScanClosure |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5697 mrias_cl(_span, ref_processor(), &_markBitMap, NULL /* not precleaning */, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5698 &_markStack, this, |
| 0 | 5699 false /* should_yield */, false /* not precleaning */); |
| 5700 MarkFromDirtyCardsClosure | |
| 5701 markFromDirtyCardsClosure(this, _span, | |
| 5702 NULL, // space is set further below | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5703 &_markBitMap, &_markStack, &mrias_cl); |
| 0 | 5704 { |
| 5705 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
|
5706 // 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
|
5707 // mod union table. |
| 0 | 5708 { |
| 5709 ModUnionClosure modUnionClosure(&_modUnionTable); | |
| 5710 _ct->ct_bs()->dirty_card_iterate( | |
| 5711 _cmsGen->used_region(), | |
| 5712 &modUnionClosure); | |
| 5713 } | |
| 5714 // Having transferred these marks into the modUnionTable, we just need | |
| 5715 // to rescan the marked objects on the dirty cards in the modUnionTable. | |
| 5716 // The initial marking may have been done during an asynchronous | |
| 5717 // collection so there may be dirty bits in the mod-union table. | |
| 5718 const int alignment = | |
| 5719 CardTableModRefBS::card_size * BitsPerWord; | |
| 5720 { | |
| 5721 // ... First handle dirty cards in CMS gen | |
| 5722 markFromDirtyCardsClosure.set_space(_cmsGen->cmsSpace()); | |
| 5723 MemRegion ur = _cmsGen->used_region(); | |
| 5724 HeapWord* lb = ur.start(); | |
| 5725 HeapWord* ub = (HeapWord*)round_to((intptr_t)ur.end(), alignment); | |
| 5726 MemRegion cms_span(lb, ub); | |
| 5727 _modUnionTable.dirty_range_iterate_clear(cms_span, | |
| 5728 &markFromDirtyCardsClosure); | |
| 5729 verify_work_stacks_empty(); | |
| 5730 if (PrintCMSStatistics != 0) { | |
| 5731 gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in cms gen) ", | |
| 5732 markFromDirtyCardsClosure.num_dirty_cards()); | |
| 5733 } | |
| 5734 } | |
| 5735 } | |
| 5736 if (VerifyDuringGC && | |
| 5737 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { | |
| 5738 HandleMark hm; // Discard invalid handles created during verification | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6787
diff
changeset
|
5739 Universe::verify(); |
| 0 | 5740 } |
| 5741 { | |
| 5742 TraceTime t("root rescan", PrintGCDetails, false, gclog_or_tty); | |
| 5743 | |
| 5744 verify_work_stacks_empty(); | |
| 5745 | |
| 5746 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5747 GenCollectedHeap::StrongRootsScope srs(gch); |
| 0 | 5748 gch->gen_process_strong_roots(_cmsGen->level(), |
| 5749 true, // younger gens as roots | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5750 false, // use the local StrongRootsScope |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5751 false, // not scavenging |
| 0 | 5752 SharedHeap::ScanningOption(roots_scanning_options()), |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5753 &mrias_cl, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5754 true, // walk code active on stacks |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5755 NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5756 NULL); // The dirty klasses will be handled below |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5757 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5758 assert(should_unload_classes() |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5759 || (roots_scanning_options() & SharedHeap::SO_CodeCache), |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
798
diff
changeset
|
5760 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops"); |
| 0 | 5761 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5762 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5763 { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5764 TraceTime t("visit unhandled CLDs", PrintGCDetails, false, gclog_or_tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5765 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5766 verify_work_stacks_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5767 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5768 // Scan all class loader data objects that might have been introduced |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5769 // during concurrent marking. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5770 ResourceMark rm; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5771 GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5772 for (int i = 0; i < array->length(); i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5773 mrias_cl.do_class_loader_data(array->at(i)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5774 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5775 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5776 // We don't need to keep track of new CLDs anymore. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5777 ClassLoaderDataGraph::remember_new_clds(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5778 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5779 verify_work_stacks_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5780 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5781 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5782 { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5783 TraceTime t("dirty klass scan", PrintGCDetails, false, gclog_or_tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5784 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5785 verify_work_stacks_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5786 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5787 RemarkKlassClosure remark_klass_closure(&mrias_cl); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5788 ClassLoaderDataGraph::classes_do(&remark_klass_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5789 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5790 verify_work_stacks_empty(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5791 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5792 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5793 // We might have added oops to ClassLoaderData::_handles during the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5794 // concurrent marking phase. These oops point to newly allocated objects |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5795 // that are guaranteed to be kept alive. Either by the direct allocation |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5796 // code, or when the young collector processes the strong roots. Hence, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5797 // we don't have to revisit the _handles block during the remark phase. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5798 |
| 0 | 5799 verify_work_stacks_empty(); |
| 5800 // Restore evacuated mark words, if any, used for overflow list links | |
| 5801 if (!CMSOverflowEarlyRestoration) { | |
| 5802 restore_preserved_marks_if_any(); | |
| 5803 } | |
| 5804 verify_overflow_empty(); | |
| 5805 } | |
| 5806 | |
| 5807 //////////////////////////////////////////////////////// | |
| 5808 // Parallel Reference Processing Task Proxy Class | |
| 5809 //////////////////////////////////////////////////////// | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5810 class CMSRefProcTaskProxy: public AbstractGangTaskWOopQueues { |
| 0 | 5811 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
| 5812 CMSCollector* _collector; | |
| 5813 CMSBitMap* _mark_bit_map; | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5814 const MemRegion _span; |
| 0 | 5815 ProcessTask& _task; |
| 5816 | |
| 5817 public: | |
| 5818 CMSRefProcTaskProxy(ProcessTask& task, | |
| 5819 CMSCollector* collector, | |
| 5820 const MemRegion& span, | |
| 5821 CMSBitMap* mark_bit_map, | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5822 AbstractWorkGang* workers, |
| 0 | 5823 OopTaskQueueSet* task_queues): |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5824 // XXX Should superclass AGTWOQ also know about AWG since it knows |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5825 // about the task_queues used by the AWG? Then it could initialize |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5826 // the terminator() object. See 6984287. The set_for_termination() |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5827 // below is a temporary band-aid for the regression in 6984287. |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5828 AbstractGangTaskWOopQueues("Process referents by policy in parallel", |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5829 task_queues), |
| 0 | 5830 _task(task), |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5831 _collector(collector), _span(span), _mark_bit_map(mark_bit_map) |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5832 { |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5833 assert(_collector->_span.equals(_span) && !_span.is_empty(), |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5834 "Inconsistency in _span"); |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5835 set_for_termination(workers->active_workers()); |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2365
diff
changeset
|
5836 } |
| 0 | 5837 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5838 OopTaskQueueSet* task_queues() { return queues(); } |
| 0 | 5839 |
| 5840 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); } | |
| 5841 | |
| 5842 void do_work_steal(int i, | |
| 5843 CMSParDrainMarkingStackClosure* drain, | |
| 5844 CMSParKeepAliveClosure* keep_alive, | |
| 5845 int* seed); | |
| 5846 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5847 virtual void work(uint worker_id); |
| 0 | 5848 }; |
| 5849 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5850 void CMSRefProcTaskProxy::work(uint worker_id) { |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5851 assert(_collector->_span.equals(_span), "Inconsistency in _span"); |
| 0 | 5852 CMSParKeepAliveClosure par_keep_alive(_collector, _span, |
| 935 | 5853 _mark_bit_map, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5854 work_queue(worker_id)); |
| 0 | 5855 CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span, |
| 935 | 5856 _mark_bit_map, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5857 work_queue(worker_id)); |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
5858 CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5859 _task.work(worker_id, is_alive_closure, par_keep_alive, par_drain_stack); |
| 0 | 5860 if (_task.marks_oops_alive()) { |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5861 do_work_steal(worker_id, &par_drain_stack, &par_keep_alive, |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5862 _collector->hash_seed(worker_id)); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5863 } |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5864 assert(work_queue(worker_id)->size() == 0, "work_queue should be empty"); |
| 0 | 5865 assert(_collector->_overflow_list == NULL, "non-empty _overflow_list"); |
| 5866 } | |
| 5867 | |
| 5868 class CMSRefEnqueueTaskProxy: public AbstractGangTask { | |
| 5869 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; | |
| 5870 EnqueueTask& _task; | |
| 5871 | |
| 5872 public: | |
| 5873 CMSRefEnqueueTaskProxy(EnqueueTask& task) | |
| 5874 : AbstractGangTask("Enqueue reference objects in parallel"), | |
| 5875 _task(task) | |
| 5876 { } | |
| 5877 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5878 virtual void work(uint worker_id) |
| 0 | 5879 { |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4128
diff
changeset
|
5880 _task.work(worker_id); |
| 0 | 5881 } |
| 5882 }; | |
| 5883 | |
| 5884 CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5885 MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue): |
| 0 | 5886 _span(span), |
| 5887 _bit_map(bit_map), | |
| 5888 _work_queue(work_queue), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5889 _mark_and_push(collector, span, bit_map, work_queue), |
| 0 | 5890 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4), |
| 5891 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))) | |
| 5892 { } | |
| 5893 | |
| 5894 // . see if we can share work_queues with ParNew? XXX | |
| 5895 void CMSRefProcTaskProxy::do_work_steal(int i, | |
| 5896 CMSParDrainMarkingStackClosure* drain, | |
| 5897 CMSParKeepAliveClosure* keep_alive, | |
| 5898 int* seed) { | |
| 5899 OopTaskQueue* work_q = work_queue(i); | |
| 5900 NOT_PRODUCT(int num_steals = 0;) | |
| 5901 oop obj_to_scan; | |
| 5902 | |
| 5903 while (true) { | |
| 5904 // Completely finish any left over work from (an) earlier round(s) | |
| 5905 drain->trim_queue(0); | |
|
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
5906 size_t num_from_overflow_list = MIN2((size_t)(work_q->max_elems() - work_q->size())/4, |
|
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
5907 (size_t)ParGCDesiredObjsFromOverflowList); |
| 0 | 5908 // Now check if there's any work in the overflow list |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5909 // Passing ParallelGCThreads as the third parameter, no_of_gc_threads, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5910 // only affects the number of attempts made to get work from the |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5911 // overflow list and does not affect the number of workers. Just |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5912 // pass ParallelGCThreads so this behavior is unchanged. |
| 0 | 5913 if (_collector->par_take_from_overflow_list(num_from_overflow_list, |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5914 work_q, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5915 ParallelGCThreads)) { |
| 0 | 5916 // Found something in global overflow list; |
| 5917 // not yet ready to go stealing work from others. | |
| 5918 // We'd like to assert(work_q->size() != 0, ...) | |
| 5919 // because we just took work from the overflow list, | |
| 5920 // but of course we can't, since all of that might have | |
| 5921 // been already stolen from us. | |
| 5922 continue; | |
| 5923 } | |
| 5924 // Verify that we have no work before we resort to stealing | |
| 5925 assert(work_q->size() == 0, "Have work, shouldn't steal"); | |
| 5926 // Try to steal from other queues that have work | |
| 5927 if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) { | |
| 5928 NOT_PRODUCT(num_steals++;) | |
| 5929 assert(obj_to_scan->is_oop(), "Oops, not an oop!"); | |
| 5930 assert(_mark_bit_map->isMarked((HeapWord*)obj_to_scan), "Stole an unmarked oop?"); | |
| 5931 // Do scanning work | |
| 5932 obj_to_scan->oop_iterate(keep_alive); | |
| 5933 // Loop around, finish this work, and try to steal some more | |
| 5934 } else if (terminator()->offer_termination()) { | |
| 5935 break; // nirvana from the infinite cycle | |
| 5936 } | |
| 5937 } | |
| 5938 NOT_PRODUCT( | |
| 5939 if (PrintCMSStatistics != 0) { | |
| 5940 gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); | |
| 5941 } | |
| 5942 ) | |
| 5943 } | |
| 5944 | |
| 5945 void CMSRefProcTaskExecutor::execute(ProcessTask& task) | |
| 5946 { | |
| 5947 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5948 FlexibleWorkGang* workers = gch->workers(); |
| 0 | 5949 assert(workers != NULL, "Need parallel worker threads."); |
| 5950 CMSRefProcTaskProxy rp_task(task, &_collector, | |
| 5951 _collector.ref_processor()->span(), | |
| 5952 _collector.markBitMap(), | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5953 workers, _collector.task_queues()); |
| 0 | 5954 workers->run_task(&rp_task); |
| 5955 } | |
| 5956 | |
| 5957 void CMSRefProcTaskExecutor::execute(EnqueueTask& task) | |
| 5958 { | |
| 5959 | |
| 5960 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5961 FlexibleWorkGang* workers = gch->workers(); |
| 0 | 5962 assert(workers != NULL, "Need parallel worker threads."); |
| 5963 CMSRefEnqueueTaskProxy enq_task(task); | |
| 5964 workers->run_task(&enq_task); | |
| 5965 } | |
| 5966 | |
| 5967 void CMSCollector::refProcessingWork(bool asynch, bool clear_all_soft_refs) { | |
| 5968 | |
| 5969 ResourceMark rm; | |
| 5970 HandleMark hm; | |
| 5971 | |
| 5972 ReferenceProcessor* rp = ref_processor(); | |
| 5973 assert(rp->span().equals(_span), "Spans should be equal"); | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5974 assert(!rp->enqueuing_is_done(), "Enqueuing should not be complete"); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5975 // Process weak references. |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
5976 rp->setup_policy(clear_all_soft_refs); |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5977 verify_work_stacks_empty(); |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
5978 |
| 0 | 5979 CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
5980 &_markStack, false /* !preclean */); |
| 0 | 5981 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this, |
| 5982 _span, &_markBitMap, &_markStack, | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
5983 &cmsKeepAliveClosure, false /* !preclean */); |
| 0 | 5984 { |
| 5985 TraceTime t("weak refs processing", PrintGCDetails, false, gclog_or_tty); | |
| 5986 if (rp->processing_is_mt()) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5987 // Set the degree of MT here. If the discovery is done MT, there |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5988 // may have been a different number of threads doing the discovery |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5989 // and a different number of discovered lists may have Ref objects. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5990 // That is OK as long as the Reference lists are balanced (see |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
5991 // balance_all_queues() and balance_queues()). |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5992 GenCollectedHeap* gch = GenCollectedHeap::heap(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5993 int active_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5994 FlexibleWorkGang* workers = gch->workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5995 if (workers != NULL) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5996 active_workers = workers->active_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5997 // The expectation is that active_workers will have already |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5998 // been set to a reasonable value. If it has not been set, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
5999 // investigate. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
6000 assert(active_workers > 0, "Should have been set during scavenge"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
6001 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
6002 rp->set_active_mt_degree(active_workers); |
| 0 | 6003 CMSRefProcTaskExecutor task_executor(*this); |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
6004 rp->process_discovered_references(&_is_alive_closure, |
| 0 | 6005 &cmsKeepAliveClosure, |
| 6006 &cmsDrainMarkingStackClosure, | |
| 6007 &task_executor); | |
| 6008 } else { | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
6009 rp->process_discovered_references(&_is_alive_closure, |
| 0 | 6010 &cmsKeepAliveClosure, |
| 6011 &cmsDrainMarkingStackClosure, | |
| 6012 NULL); | |
| 6013 } | |
| 6014 verify_work_stacks_empty(); | |
| 6015 } | |
| 6016 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6017 if (should_unload_classes()) { |
| 0 | 6018 { |
| 6019 TraceTime t("class unloading", PrintGCDetails, false, gclog_or_tty); | |
| 6020 | |
| 6021 // Follow SystemDictionary roots and unload classes | |
| 6022 bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure); | |
| 6023 | |
| 6024 // Follow CodeCache roots and unload any methods marked for unloading | |
|
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6755
diff
changeset
|
6025 CodeCache::do_unloading(&_is_alive_closure, purged_class); |
| 0 | 6026 |
| 6027 cmsDrainMarkingStackClosure.do_void(); | |
| 6028 verify_work_stacks_empty(); | |
| 6029 | |
| 6030 // Update subklass/sibling/implementor links in KlassKlass descendants | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6031 Klass::clean_weak_klass_links(&_is_alive_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6032 // Nothing should have been pushed onto the working stacks. |
| 0 | 6033 verify_work_stacks_empty(); |
| 6034 } | |
| 6035 | |
| 6036 { | |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6037 TraceTime t("scrub symbol table", PrintGCDetails, false, gclog_or_tty); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
6038 // Clean up unreferenced symbols in symbol table. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
6039 SymbolTable::unlink(); |
| 0 | 6040 } |
| 6041 } | |
| 6042 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6043 // CMS doesn't use the StringTable as hard roots when class unloading is turned off. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6044 // Need to check if we really scanned the StringTable. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6045 if ((roots_scanning_options() & SharedHeap::SO_Strings) == 0) { |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6046 TraceTime t("scrub string table", PrintGCDetails, false, gclog_or_tty); |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6047 // Now clean up stale oops in StringTable |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6048 StringTable::unlink(&_is_alive_closure); |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6049 } |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
6050 |
| 0 | 6051 verify_work_stacks_empty(); |
| 6052 // Restore any preserved marks as a result of mark stack or | |
| 6053 // work queue overflow | |
| 6054 restore_preserved_marks_if_any(); // done single-threaded for now | |
| 6055 | |
| 6056 rp->set_enqueuing_is_done(true); | |
| 6057 if (rp->processing_is_mt()) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
6058 rp->balance_all_queues(); |
| 0 | 6059 CMSRefProcTaskExecutor task_executor(*this); |
| 6060 rp->enqueue_discovered_references(&task_executor); | |
| 6061 } else { | |
| 6062 rp->enqueue_discovered_references(NULL); | |
| 6063 } | |
| 6064 rp->verify_no_references_recorded(); | |
| 6065 assert(!rp->discovery_enabled(), "should have been disabled"); | |
| 6066 } | |
| 6067 | |
| 6068 #ifndef PRODUCT | |
| 6069 void CMSCollector::check_correct_thread_executing() { | |
| 6070 Thread* t = Thread::current(); | |
| 6071 // Only the VM thread or the CMS thread should be here. | |
| 6072 assert(t->is_ConcurrentGC_thread() || t->is_VM_thread(), | |
| 6073 "Unexpected thread type"); | |
| 6074 // If this is the vm thread, the foreground process | |
| 6075 // should not be waiting. Note that _foregroundGCIsActive is | |
| 6076 // true while the foreground collector is waiting. | |
| 6077 if (_foregroundGCShouldWait) { | |
| 6078 // We cannot be the VM thread | |
| 6079 assert(t->is_ConcurrentGC_thread(), | |
| 6080 "Should be CMS thread"); | |
| 6081 } else { | |
| 6082 // We can be the CMS thread only if we are in a stop-world | |
| 6083 // phase of CMS collection. | |
| 6084 if (t->is_ConcurrentGC_thread()) { | |
| 6085 assert(_collectorState == InitialMarking || | |
| 6086 _collectorState == FinalMarking, | |
| 6087 "Should be a stop-world phase"); | |
| 6088 // The CMS thread should be holding the CMS_token. | |
| 6089 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6090 "Potential interference with concurrently " | |
| 6091 "executing VM thread"); | |
| 6092 } | |
| 6093 } | |
| 6094 } | |
| 6095 #endif | |
| 6096 | |
| 6097 void CMSCollector::sweep(bool asynch) { | |
| 6098 assert(_collectorState == Sweeping, "just checking"); | |
| 6099 check_correct_thread_executing(); | |
| 6100 verify_work_stacks_empty(); | |
| 6101 verify_overflow_empty(); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6102 increment_sweep_count(); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
6103 TraceCMSMemoryManagerStats tms(_collectorState,GenCollectedHeap::heap()->gc_cause()); |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
6104 |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6105 _inter_sweep_timer.stop(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6106 _inter_sweep_estimate.sample(_inter_sweep_timer.seconds()); |
| 0 | 6107 size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free()); |
| 6108 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6109 assert(!_intra_sweep_timer.is_active(), "Should not be active"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6110 _intra_sweep_timer.reset(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6111 _intra_sweep_timer.start(); |
| 0 | 6112 if (asynch) { |
| 6113 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 6114 CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6115 // First sweep the old gen |
| 0 | 6116 { |
| 6117 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(), | |
| 6118 bitMapLock()); | |
| 6119 sweepWork(_cmsGen, asynch); | |
| 6120 } | |
| 6121 | |
| 6122 // Update Universe::_heap_*_at_gc figures. | |
| 6123 // We need all the free list locks to make the abstract state | |
| 6124 // transition from Sweeping to Resetting. See detailed note | |
| 6125 // further below. | |
| 6126 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6127 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock()); |
| 0 | 6128 // Update heap occupancy information which is used as |
| 6129 // input to soft ref clearing policy at the next gc. | |
| 6130 Universe::update_heap_info_at_gc(); | |
| 6131 _collectorState = Resizing; | |
| 6132 } | |
| 6133 } else { | |
| 6134 // already have needed locks | |
| 6135 sweepWork(_cmsGen, asynch); | |
| 6136 // Update heap occupancy information which is used as | |
| 6137 // input to soft ref clearing policy at the next gc. | |
| 6138 Universe::update_heap_info_at_gc(); | |
| 6139 _collectorState = Resizing; | |
| 6140 } | |
| 6141 verify_work_stacks_empty(); | |
| 6142 verify_overflow_empty(); | |
| 6143 | |
|
8784
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8740
diff
changeset
|
6144 if (should_unload_classes()) { |
|
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8740
diff
changeset
|
6145 ClassLoaderDataGraph::purge(); |
|
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8740
diff
changeset
|
6146 } |
|
79af1312fc2c
8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents:
8740
diff
changeset
|
6147 |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6148 _intra_sweep_timer.stop(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6149 _intra_sweep_estimate.sample(_intra_sweep_timer.seconds()); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6150 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6151 _inter_sweep_timer.reset(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6152 _inter_sweep_timer.start(); |
| 0 | 6153 |
| 4911 | 6154 // We need to use a monotonically non-deccreasing time in ms |
| 6155 // or we will see time-warp warnings and os::javaTimeMillis() | |
| 6156 // does not guarantee monotonicity. | |
| 6157 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; | |
| 6158 update_time_of_last_gc(now); | |
| 0 | 6159 |
| 6160 // NOTE on abstract state transitions: | |
| 6161 // Mutators allocate-live and/or mark the mod-union table dirty | |
| 6162 // based on the state of the collection. The former is done in | |
| 6163 // the interval [Marking, Sweeping] and the latter in the interval | |
| 6164 // [Marking, Sweeping). Thus the transitions into the Marking state | |
| 6165 // and out of the Sweeping state must be synchronously visible | |
| 6166 // globally to the mutators. | |
| 6167 // The transition into the Marking state happens with the world | |
| 6168 // stopped so the mutators will globally see it. Sweeping is | |
| 6169 // done asynchronously by the background collector so the transition | |
| 6170 // from the Sweeping state to the Resizing state must be done | |
| 6171 // under the freelistLock (as is the check for whether to | |
| 6172 // allocate-live and whether to dirty the mod-union table). | |
| 6173 assert(_collectorState == Resizing, "Change of collector state to" | |
| 6174 " Resizing must be done under the freelistLocks (plural)"); | |
| 6175 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
6176 // Now that sweeping has been completed, we clear |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
6177 // the incremental_collection_failed flag, |
| 0 | 6178 // thus inviting a younger gen collection to promote into |
| 6179 // this generation. If such a promotion may still fail, | |
| 6180 // the flag will be set again when a young collection is | |
| 6181 // attempted. | |
| 6182 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1837
diff
changeset
|
6183 gch->clear_incremental_collection_failed(); // Worth retrying as fresh space may have been freed up |
| 0 | 6184 gch->update_full_collections_completed(_collection_count_start); |
| 6185 } | |
| 6186 | |
| 6187 // FIX ME!!! Looks like this belongs in CFLSpace, with | |
| 6188 // CMSGen merely delegating to it. | |
| 6189 void ConcurrentMarkSweepGeneration::setNearLargestChunk() { | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6190 double nearLargestPercent = FLSLargestBlockCoalesceProximity; |
| 0 | 6191 HeapWord* minAddr = _cmsSpace->bottom(); |
| 6192 HeapWord* largestAddr = | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
6193 (HeapWord*) _cmsSpace->dictionary()->find_largest_dict(); |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6194 if (largestAddr == NULL) { |
| 0 | 6195 // The dictionary appears to be empty. In this case |
| 6196 // try to coalesce at the end of the heap. | |
| 6197 largestAddr = _cmsSpace->end(); | |
| 6198 } | |
| 6199 size_t largestOffset = pointer_delta(largestAddr, minAddr); | |
| 6200 size_t nearLargestOffset = | |
| 6201 (size_t)((double)largestOffset * nearLargestPercent) - MinChunkSize; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6202 if (PrintFLSStatistics != 0) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6203 gclog_or_tty->print_cr( |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6204 "CMS: Large Block: " PTR_FORMAT ";" |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6205 " Proximity: " PTR_FORMAT " -> " PTR_FORMAT, |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6206 largestAddr, |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6207 _cmsSpace->nearLargestChunk(), minAddr + nearLargestOffset); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6208 } |
| 0 | 6209 _cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset); |
| 6210 } | |
| 6211 | |
| 6212 bool ConcurrentMarkSweepGeneration::isNearLargestChunk(HeapWord* addr) { | |
| 6213 return addr >= _cmsSpace->nearLargestChunk(); | |
| 6214 } | |
| 6215 | |
| 6216 FreeChunk* ConcurrentMarkSweepGeneration::find_chunk_at_end() { | |
| 6217 return _cmsSpace->find_chunk_at_end(); | |
| 6218 } | |
| 6219 | |
| 6220 void ConcurrentMarkSweepGeneration::update_gc_stats(int current_level, | |
| 6221 bool full) { | |
| 6222 // The next lower level has been collected. Gather any statistics | |
| 6223 // that are of interest at this point. | |
| 6224 if (!full && (current_level + 1) == level()) { | |
| 6225 // Gather statistics on the young generation collection. | |
| 6226 collector()->stats().record_gc0_end(used()); | |
| 6227 } | |
| 6228 } | |
| 6229 | |
| 6230 CMSAdaptiveSizePolicy* ConcurrentMarkSweepGeneration::size_policy() { | |
| 6231 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 6232 assert(gch->kind() == CollectedHeap::GenCollectedHeap, | |
| 6233 "Wrong type of heap"); | |
| 6234 CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*) | |
| 6235 gch->gen_policy()->size_policy(); | |
| 6236 assert(sp->is_gc_cms_adaptive_size_policy(), | |
| 6237 "Wrong type of size policy"); | |
| 6238 return sp; | |
| 6239 } | |
| 6240 | |
| 6241 void ConcurrentMarkSweepGeneration::rotate_debug_collection_type() { | |
| 6242 if (PrintGCDetails && Verbose) { | |
| 6243 gclog_or_tty->print("Rotate from %d ", _debug_collection_type); | |
| 6244 } | |
| 6245 _debug_collection_type = (CollectionTypes) (_debug_collection_type + 1); | |
| 6246 _debug_collection_type = | |
| 6247 (CollectionTypes) (_debug_collection_type % Unknown_collection_type); | |
| 6248 if (PrintGCDetails && Verbose) { | |
| 6249 gclog_or_tty->print_cr("to %d ", _debug_collection_type); | |
| 6250 } | |
| 6251 } | |
| 6252 | |
| 6253 void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* gen, | |
| 6254 bool asynch) { | |
| 6255 // We iterate over the space(s) underlying this generation, | |
| 6256 // checking the mark bit map to see if the bits corresponding | |
| 6257 // to specific blocks are marked or not. Blocks that are | |
| 6258 // marked are live and are not swept up. All remaining blocks | |
| 6259 // are swept up, with coalescing on-the-fly as we sweep up | |
| 6260 // contiguous free and/or garbage blocks: | |
| 6261 // We need to ensure that the sweeper synchronizes with allocators | |
| 6262 // and stop-the-world collectors. In particular, the following | |
| 6263 // locks are used: | |
| 6264 // . CMS token: if this is held, a stop the world collection cannot occur | |
| 6265 // . freelistLock: if this is held no allocation can occur from this | |
| 6266 // generation by another thread | |
| 6267 // . bitMapLock: if this is held, no other thread can access or update | |
| 6268 // | |
| 6269 | |
| 6270 // Note that we need to hold the freelistLock if we use | |
| 6271 // block iterate below; else the iterator might go awry if | |
| 6272 // a mutator (or promotion) causes block contents to change | |
| 6273 // (for instance if the allocator divvies up a block). | |
| 6274 // If we hold the free list lock, for all practical purposes | |
| 6275 // young generation GC's can't occur (they'll usually need to | |
| 6276 // promote), so we might as well prevent all young generation | |
| 6277 // GC's while we do a sweeping step. For the same reason, we might | |
| 6278 // as well take the bit map lock for the entire duration | |
| 6279 | |
| 6280 // check that we hold the requisite locks | |
| 6281 assert(have_cms_token(), "Should hold cms token"); | |
| 6282 assert( (asynch && ConcurrentMarkSweepThread::cms_thread_has_cms_token()) | |
| 6283 || (!asynch && ConcurrentMarkSweepThread::vm_thread_has_cms_token()), | |
| 6284 "Should possess CMS token to sweep"); | |
| 6285 assert_lock_strong(gen->freelistLock()); | |
| 6286 assert_lock_strong(bitMapLock()); | |
| 6287 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6288 assert(!_inter_sweep_timer.is_active(), "Was switched off in an outer context"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6289 assert(_intra_sweep_timer.is_active(), "Was switched on in an outer context"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6290 gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6291 _inter_sweep_estimate.padded_average(), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6292 _intra_sweep_estimate.padded_average()); |
| 0 | 6293 gen->setNearLargestChunk(); |
| 6294 | |
| 6295 { | |
| 6296 SweepClosure sweepClosure(this, gen, &_markBitMap, | |
| 6297 CMSYield && asynch); | |
| 6298 gen->cmsSpace()->blk_iterate_careful(&sweepClosure); | |
| 6299 // We need to free-up/coalesce garbage/blocks from a | |
| 6300 // co-terminal free run. This is done in the SweepClosure | |
| 6301 // destructor; so, do not remove this scope, else the | |
| 6302 // end-of-sweep-census below will be off by a little bit. | |
| 6303 } | |
| 6304 gen->cmsSpace()->sweep_completed(); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1085
diff
changeset
|
6305 gen->cmsSpace()->endSweepFLCensus(sweep_count()); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6306 if (should_unload_classes()) { // unloaded classes this cycle, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6307 _concurrent_cycles_since_last_unload = 0; // ... reset count |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6308 } else { // did not unload classes, |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6309 _concurrent_cycles_since_last_unload++; // ... increment count |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
9
diff
changeset
|
6310 } |
| 0 | 6311 } |
| 6312 | |
| 6313 // Reset CMS data structures (for now just the marking bit map) | |
| 6314 // preparatory for the next cycle. | |
| 6315 void CMSCollector::reset(bool asynch) { | |
| 6316 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 6317 CMSAdaptiveSizePolicy* sp = size_policy(); | |
| 6318 AdaptiveSizePolicyOutput(sp, gch->total_collections()); | |
| 6319 if (asynch) { | |
| 6320 CMSTokenSyncWithLocks ts(true, bitMapLock()); | |
| 6321 | |
| 6322 // If the state is not "Resetting", the foreground thread | |
| 6323 // has done a collection and the resetting. | |
| 6324 if (_collectorState != Resetting) { | |
| 6325 assert(_collectorState == Idling, "The state should only change" | |
| 6326 " because the foreground collector has finished the collection"); | |
| 6327 return; | |
| 6328 } | |
| 6329 | |
| 6330 // Clear the mark bitmap (no grey objects to start with) | |
| 6331 // for the next cycle. | |
| 6332 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
| 6333 CMSPhaseAccounting cmspa(this, "reset", !PrintGCDetails); | |
| 6334 | |
| 6335 HeapWord* curAddr = _markBitMap.startWord(); | |
| 6336 while (curAddr < _markBitMap.endWord()) { | |
| 6337 size_t remaining = pointer_delta(_markBitMap.endWord(), curAddr); | |
| 6338 MemRegion chunk(curAddr, MIN2(CMSBitMapYieldQuantum, remaining)); | |
| 6339 _markBitMap.clear_large_range(chunk); | |
| 6340 if (ConcurrentMarkSweepThread::should_yield() && | |
| 6341 !foregroundGCIsActive() && | |
| 6342 CMSYield) { | |
| 6343 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6344 "CMS thread should hold CMS token"); | |
| 6345 assert_lock_strong(bitMapLock()); | |
| 6346 bitMapLock()->unlock(); | |
| 6347 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6348 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6349 stopTimer(); | |
| 6350 if (PrintCMSStatistics != 0) { | |
| 6351 incrementYields(); | |
| 6352 } | |
| 6353 icms_wait(); | |
| 6354 | |
| 6355 // See the comment in coordinator_yield() | |
| 6356 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
|
6357 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6358 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 6359 os::sleep(Thread::current(), 1, false); |
| 6360 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6361 } | |
| 6362 | |
| 6363 ConcurrentMarkSweepThread::synchronize(true); | |
| 6364 bitMapLock()->lock_without_safepoint_check(); | |
| 6365 startTimer(); | |
| 6366 } | |
| 6367 curAddr = chunk.end(); | |
| 6368 } | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
6369 // A successful mostly concurrent collection has been done. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
6370 // Because only the full (i.e., concurrent mode failure) collections |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
6371 // are being measured for gc overhead limits, clean the "near" flag |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
6372 // and count. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1289
diff
changeset
|
6373 sp->reset_gc_overhead_limit_count(); |
| 0 | 6374 _collectorState = Idling; |
| 6375 } else { | |
| 6376 // already have the lock | |
| 6377 assert(_collectorState == Resetting, "just checking"); | |
| 6378 assert_lock_strong(bitMapLock()); | |
| 6379 _markBitMap.clear_all(); | |
| 6380 _collectorState = Idling; | |
| 6381 } | |
| 6382 | |
| 6383 // Stop incremental mode after a cycle completes, so that any future cycles | |
| 6384 // are triggered by allocation. | |
| 6385 stop_icms(); | |
| 6386 | |
| 6387 NOT_PRODUCT( | |
| 6388 if (RotateCMSCollectionTypes) { | |
| 6389 _cmsGen->rotate_debug_collection_type(); | |
| 6390 } | |
| 6391 ) | |
| 6392 } | |
| 6393 | |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6028
diff
changeset
|
6394 void CMSCollector::do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause) { |
| 0 | 6395 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); |
| 6396 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6028
diff
changeset
|
6397 TraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, gclog_or_tty); |
| 0 | 6398 TraceCollectorStats tcs(counters()); |
| 6399 | |
| 6400 switch (op) { | |
| 6401 case CMS_op_checkpointRootsInitial: { | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1994
diff
changeset
|
6402 SvcGCMarker sgcm(SvcGCMarker::OTHER); |
| 0 | 6403 checkpointRootsInitial(true); // asynch |
| 6404 if (PrintGC) { | |
| 6405 _cmsGen->printOccupancy("initial-mark"); | |
| 6406 } | |
| 6407 break; | |
| 6408 } | |
| 6409 case CMS_op_checkpointRootsFinal: { | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1994
diff
changeset
|
6410 SvcGCMarker sgcm(SvcGCMarker::OTHER); |
| 0 | 6411 checkpointRootsFinal(true, // asynch |
| 6412 false, // !clear_all_soft_refs | |
| 6413 false); // !init_mark_was_synchronous | |
| 6414 if (PrintGC) { | |
| 6415 _cmsGen->printOccupancy("remark"); | |
| 6416 } | |
| 6417 break; | |
| 6418 } | |
| 6419 default: | |
| 6420 fatal("No such CMS_op"); | |
| 6421 } | |
| 6422 } | |
| 6423 | |
| 6424 #ifndef PRODUCT | |
| 6425 size_t const CMSCollector::skip_header_HeapWords() { | |
| 6426 return FreeChunk::header_size(); | |
| 6427 } | |
| 6428 | |
| 6429 // Try and collect here conditions that should hold when | |
| 6430 // CMS thread is exiting. The idea is that the foreground GC | |
| 6431 // thread should not be blocked if it wants to terminate | |
| 6432 // the CMS thread and yet continue to run the VM for a while | |
| 6433 // after that. | |
| 6434 void CMSCollector::verify_ok_to_terminate() const { | |
| 6435 assert(Thread::current()->is_ConcurrentGC_thread(), | |
| 6436 "should be called by CMS thread"); | |
| 6437 assert(!_foregroundGCShouldWait, "should be false"); | |
| 6438 // We could check here that all the various low-level locks | |
| 6439 // are not held by the CMS thread, but that is overkill; see | |
| 6440 // also CMSThread::verify_ok_to_terminate() where the CGC_lock | |
| 6441 // is checked. | |
| 6442 } | |
| 6443 #endif | |
| 6444 | |
| 6445 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
|
6446 assert(_markBitMap.isMarked(addr) && _markBitMap.isMarked(addr + 1), |
|
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
452
diff
changeset
|
6447 "missing Printezis mark?"); |
| 0 | 6448 HeapWord* nextOneAddr = _markBitMap.getNextMarkedWordAddress(addr + 2); |
| 6449 size_t size = pointer_delta(nextOneAddr + 1, addr); | |
| 6450 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6451 "alignment problem"); | |
| 6452 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6453 return size; | |
| 6454 } | |
| 6455 | |
| 6456 // A variant of the above (block_size_using_printezis_bits()) except | |
| 6457 // that we return 0 if the P-bits are not yet set. | |
| 6458 size_t CMSCollector::block_size_if_printezis_bits(HeapWord* addr) const { | |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
6459 if (_markBitMap.isMarked(addr + 1)) { |
|
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
6460 assert(_markBitMap.isMarked(addr), "P-bit can be set only for marked objects"); |
| 0 | 6461 HeapWord* nextOneAddr = _markBitMap.getNextMarkedWordAddress(addr + 2); |
| 6462 size_t size = pointer_delta(nextOneAddr + 1, addr); | |
| 6463 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6464 "alignment problem"); | |
| 6465 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6466 return size; | |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
6467 } |
|
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
6468 return 0; |
| 0 | 6469 } |
| 6470 | |
| 6471 HeapWord* CMSCollector::next_card_start_after_block(HeapWord* addr) const { | |
| 6472 size_t sz = 0; | |
| 6473 oop p = (oop)addr; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6474 if (p->klass_or_null() != NULL) { |
| 0 | 6475 sz = CompactibleFreeListSpace::adjustObjectSize(p->size()); |
| 6476 } else { | |
| 6477 sz = block_size_using_printezis_bits(addr); | |
| 6478 } | |
| 6479 assert(sz > 0, "size must be nonzero"); | |
| 6480 HeapWord* next_block = addr + sz; | |
| 6481 HeapWord* next_card = (HeapWord*)round_to((uintptr_t)next_block, | |
| 6482 CardTableModRefBS::card_size); | |
| 6483 assert(round_down((uintptr_t)addr, CardTableModRefBS::card_size) < | |
| 6484 round_down((uintptr_t)next_card, CardTableModRefBS::card_size), | |
| 6485 "must be different cards"); | |
| 6486 return next_card; | |
| 6487 } | |
| 6488 | |
| 6489 | |
| 6490 // CMS Bit Map Wrapper ///////////////////////////////////////// | |
| 6491 | |
| 6492 // Construct a CMS bit map infrastructure, but don't create the | |
| 6493 // bit vector itself. That is done by a separate call CMSBitMap::allocate() | |
| 6494 // further below. | |
| 6495 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
|
6496 _bm(), |
| 0 | 6497 _shifter(shifter), |
| 6498 _lock(mutex_rank >= 0 ? new Mutex(mutex_rank, mutex_name, true) : NULL) | |
| 6499 { | |
| 6500 _bmStartWord = 0; | |
| 6501 _bmWordSize = 0; | |
| 6502 } | |
| 6503 | |
| 6504 bool CMSBitMap::allocate(MemRegion mr) { | |
| 6505 _bmStartWord = mr.start(); | |
| 6506 _bmWordSize = mr.word_size(); | |
| 6507 ReservedSpace brs(ReservedSpace::allocation_align_size_up( | |
| 6508 (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1)); | |
| 6509 if (!brs.is_reserved()) { | |
| 6510 warning("CMS bit map allocation failure"); | |
| 6511 return false; | |
| 6512 } | |
| 6513 // For now we'll just commit all of the bit map up fromt. | |
| 6514 // Later on we'll try to be more parsimonious with swap. | |
| 6515 if (!_virtual_space.initialize(brs, brs.size())) { | |
| 6516 warning("CMS bit map backing store failure"); | |
| 6517 return false; | |
| 6518 } | |
| 6519 assert(_virtual_space.committed_size() == brs.size(), | |
| 6520 "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
|
6521 _bm.set_map((BitMap::bm_word_t*)_virtual_space.low()); |
| 0 | 6522 assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >= |
| 6523 _bmWordSize, "inconsistency in bit map sizing"); | |
| 6524 _bm.set_size(_bmWordSize >> _shifter); | |
| 6525 | |
| 6526 // bm.clear(); // can we rely on getting zero'd memory? verify below | |
| 6527 assert(isAllClear(), | |
| 6528 "Expected zero'd memory from ReservedSpace constructor"); | |
| 6529 assert(_bm.size() == heapWordDiffToOffsetDiff(sizeInWords()), | |
| 6530 "consistency check"); | |
| 6531 return true; | |
| 6532 } | |
| 6533 | |
| 6534 void CMSBitMap::dirty_range_iterate_clear(MemRegion mr, MemRegionClosure* cl) { | |
| 6535 HeapWord *next_addr, *end_addr, *last_addr; | |
| 6536 assert_locked(); | |
| 6537 assert(covers(mr), "out-of-range error"); | |
| 6538 // XXX assert that start and end are appropriately aligned | |
| 6539 for (next_addr = mr.start(), end_addr = mr.end(); | |
| 6540 next_addr < end_addr; next_addr = last_addr) { | |
| 6541 MemRegion dirty_region = getAndClearMarkedRegion(next_addr, end_addr); | |
| 6542 last_addr = dirty_region.end(); | |
| 6543 if (!dirty_region.is_empty()) { | |
| 6544 cl->do_MemRegion(dirty_region); | |
| 6545 } else { | |
| 6546 assert(last_addr == end_addr, "program logic"); | |
| 6547 return; | |
| 6548 } | |
| 6549 } | |
| 6550 } | |
| 6551 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
6552 void CMSBitMap::print_on_error(outputStream* st, const char* prefix) const { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
6553 _bm.print_on_error(st, prefix); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
6554 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
6555 |
| 0 | 6556 #ifndef PRODUCT |
| 6557 void CMSBitMap::assert_locked() const { | |
| 6558 CMSLockVerifier::assert_locked(lock()); | |
| 6559 } | |
| 6560 | |
| 6561 bool CMSBitMap::covers(MemRegion mr) const { | |
| 6562 // assert(_bm.map() == _virtual_space.low(), "map inconsistency"); | |
| 6563 assert((size_t)_bm.size() == (_bmWordSize >> _shifter), | |
| 6564 "size inconsistency"); | |
| 6565 return (mr.start() >= _bmStartWord) && | |
| 6566 (mr.end() <= endWord()); | |
| 6567 } | |
| 6568 | |
| 6569 bool CMSBitMap::covers(HeapWord* start, size_t size) const { | |
| 6570 return (start >= _bmStartWord && (start + size) <= endWord()); | |
| 6571 } | |
| 6572 | |
| 6573 void CMSBitMap::verifyNoOneBitsInRange(HeapWord* left, HeapWord* right) { | |
| 6574 // verify that there are no 1 bits in the interval [left, right) | |
| 6575 FalseBitMapClosure falseBitMapClosure; | |
| 6576 iterate(&falseBitMapClosure, left, right); | |
| 6577 } | |
| 6578 | |
| 6579 void CMSBitMap::region_invariant(MemRegion mr) | |
| 6580 { | |
| 6581 assert_locked(); | |
| 6582 // mr = mr.intersection(MemRegion(_bmStartWord, _bmWordSize)); | |
| 6583 assert(!mr.is_empty(), "unexpected empty region"); | |
| 6584 assert(covers(mr), "mr should be covered by bit map"); | |
| 6585 // convert address range into offset range | |
| 6586 size_t start_ofs = heapWordToOffset(mr.start()); | |
| 6587 // Make sure that end() is appropriately aligned | |
| 6588 assert(mr.end() == (HeapWord*)round_to((intptr_t)mr.end(), | |
| 6589 (1 << (_shifter+LogHeapWordSize))), | |
| 6590 "Misaligned mr.end()"); | |
| 6591 size_t end_ofs = heapWordToOffset(mr.end()); | |
| 6592 assert(end_ofs > start_ofs, "Should mark at least one bit"); | |
| 6593 } | |
| 6594 | |
| 6595 #endif | |
| 6596 | |
| 6597 bool CMSMarkStack::allocate(size_t size) { | |
| 6598 // allocate a stack of the requisite depth | |
| 6599 ReservedSpace rs(ReservedSpace::allocation_align_size_up( | |
| 6600 size * sizeof(oop))); | |
| 6601 if (!rs.is_reserved()) { | |
| 6602 warning("CMSMarkStack allocation failure"); | |
| 6603 return false; | |
| 6604 } | |
| 6605 if (!_virtual_space.initialize(rs, rs.size())) { | |
| 6606 warning("CMSMarkStack backing store failure"); | |
| 6607 return false; | |
| 6608 } | |
| 6609 assert(_virtual_space.committed_size() == rs.size(), | |
| 6610 "didn't reserve backing store for all of CMS stack?"); | |
| 6611 _base = (oop*)(_virtual_space.low()); | |
| 6612 _index = 0; | |
| 6613 _capacity = size; | |
| 6614 NOT_PRODUCT(_max_depth = 0); | |
| 6615 return true; | |
| 6616 } | |
| 6617 | |
| 6618 // XXX FIX ME !!! In the MT case we come in here holding a | |
| 6619 // leaf lock. For printing we need to take a further lock | |
| 6620 // which has lower rank. We need to recallibrate the two | |
| 6621 // lock-ranks involved in order to be able to rpint the | |
| 6622 // messages below. (Or defer the printing to the caller. | |
| 6623 // For now we take the expedient path of just disabling the | |
| 6624 // messages for the problematic case.) | |
| 6625 void CMSMarkStack::expand() { | |
| 1284 | 6626 assert(_capacity <= MarkStackSizeMax, "stack bigger than permitted"); |
| 6627 if (_capacity == MarkStackSizeMax) { | |
| 0 | 6628 if (_hit_limit++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { |
| 6629 // We print a warning message only once per CMS cycle. | |
| 6630 gclog_or_tty->print_cr(" (benign) Hit CMSMarkStack max size limit"); | |
| 6631 } | |
| 6632 return; | |
| 6633 } | |
| 6634 // Double capacity if possible | |
| 1284 | 6635 size_t new_capacity = MIN2(_capacity*2, MarkStackSizeMax); |
| 0 | 6636 // Do not give up existing stack until we have managed to |
| 6637 // get the double capacity that we desired. | |
| 6638 ReservedSpace rs(ReservedSpace::allocation_align_size_up( | |
| 6639 new_capacity * sizeof(oop))); | |
| 6640 if (rs.is_reserved()) { | |
| 6641 // Release the backing store associated with old stack | |
| 6642 _virtual_space.release(); | |
| 6643 // Reinitialize virtual space for new stack | |
| 6644 if (!_virtual_space.initialize(rs, rs.size())) { | |
| 6645 fatal("Not enough swap for expanded marking stack"); | |
| 6646 } | |
| 6647 _base = (oop*)(_virtual_space.low()); | |
| 6648 _index = 0; | |
| 6649 _capacity = new_capacity; | |
| 6650 } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { | |
| 6651 // Failed to double capacity, continue; | |
| 6652 // we print a detail message only once per CMS cycle. | |
| 6653 gclog_or_tty->print(" (benign) Failed to expand marking stack from "SIZE_FORMAT"K to " | |
| 6654 SIZE_FORMAT"K", | |
| 6655 _capacity / K, new_capacity / K); | |
| 6656 } | |
| 6657 } | |
| 6658 | |
| 6659 | |
| 6660 // Closures | |
| 6661 // XXX: there seems to be a lot of code duplication here; | |
| 6662 // should refactor and consolidate common code. | |
| 6663 | |
| 6664 // This closure is used to mark refs into the CMS generation in | |
| 6665 // the CMS bit map. Called at the first checkpoint. This closure | |
| 6666 // assumes that we do not need to re-mark dirty cards; if the CMS | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6667 // generation on which this is used is not an oldest |
| 0 | 6668 // generation then this will lose younger_gen cards! |
| 6669 | |
| 6670 MarkRefsIntoClosure::MarkRefsIntoClosure( | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
6671 MemRegion span, CMSBitMap* bitMap): |
| 0 | 6672 _span(span), |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
6673 _bitMap(bitMap) |
| 0 | 6674 { |
| 6675 assert(_ref_processor == NULL, "deliberately left NULL"); | |
| 6676 assert(_bitMap->covers(_span), "_bitMap/_span mismatch"); | |
| 6677 } | |
| 6678 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6679 void MarkRefsIntoClosure::do_oop(oop obj) { |
| 0 | 6680 // 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
|
6681 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
|
6682 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6683 if (_span.contains(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6684 // 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
|
6685 _bitMap->mark(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6686 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6687 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6688 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6689 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
|
6690 void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); } |
| 0 | 6691 |
| 6692 // A variant of the above, used for CMS marking verification. | |
| 6693 MarkRefsIntoVerifyClosure::MarkRefsIntoVerifyClosure( | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
6694 MemRegion span, CMSBitMap* verification_bm, CMSBitMap* cms_bm): |
| 0 | 6695 _span(span), |
| 6696 _verification_bm(verification_bm), | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
6697 _cms_bm(cms_bm) |
|
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
6698 { |
| 0 | 6699 assert(_ref_processor == NULL, "deliberately left NULL"); |
| 6700 assert(_verification_bm->covers(_span), "_verification_bm/_span mismatch"); | |
| 6701 } | |
| 6702 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6703 void MarkRefsIntoVerifyClosure::do_oop(oop obj) { |
| 0 | 6704 // 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
|
6705 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
|
6706 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6707 if (_span.contains(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6708 _verification_bm->mark(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6709 if (!_cms_bm->isMarked(addr)) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6710 oop(addr)->print(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6711 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
|
6712 fatal("... aborting"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6713 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6714 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6715 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6716 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6717 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
|
6718 void MarkRefsIntoVerifyClosure::do_oop(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); } |
| 0 | 6719 |
| 6720 ////////////////////////////////////////////////// | |
| 6721 // MarkRefsIntoAndScanClosure | |
| 6722 ////////////////////////////////////////////////// | |
| 6723 | |
| 6724 MarkRefsIntoAndScanClosure::MarkRefsIntoAndScanClosure(MemRegion span, | |
| 6725 ReferenceProcessor* rp, | |
| 6726 CMSBitMap* bit_map, | |
| 6727 CMSBitMap* mod_union_table, | |
| 6728 CMSMarkStack* mark_stack, | |
| 6729 CMSCollector* collector, | |
| 6730 bool should_yield, | |
| 6731 bool concurrent_precleaning): | |
| 6732 _collector(collector), | |
| 6733 _span(span), | |
| 6734 _bit_map(bit_map), | |
| 6735 _mark_stack(mark_stack), | |
| 6736 _pushAndMarkClosure(collector, span, rp, bit_map, mod_union_table, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6737 mark_stack, concurrent_precleaning), |
| 0 | 6738 _yield(should_yield), |
| 6739 _concurrent_precleaning(concurrent_precleaning), | |
| 6740 _freelistLock(NULL) | |
| 6741 { | |
| 6742 _ref_processor = rp; | |
| 6743 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 6744 } | |
| 6745 | |
| 6746 // This closure is used to mark refs into the CMS generation at the | |
| 6747 // second (final) checkpoint, and to scan and transitively follow | |
| 6748 // the unmarked oops. It is also used during the concurrent precleaning | |
| 6749 // phase while scanning objects on dirty cards in the CMS generation. | |
| 6750 // The marks are made in the marking bit map and the marking stack is | |
| 6751 // used for keeping the (newly) grey objects during the scan. | |
| 6752 // 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
|
6753 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
|
6754 if (obj != NULL) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6755 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
|
6756 HeapWord* addr = (HeapWord*)obj; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6757 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
|
6758 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
|
6759 "overflow list should be empty"); |
| 0 | 6760 if (_span.contains(addr) && |
| 6761 !_bit_map->isMarked(addr)) { | |
| 6762 // mark bit map (object is now grey) | |
| 6763 _bit_map->mark(addr); | |
| 6764 // push on marking stack (stack should be empty), and drain the | |
| 6765 // stack by applying this closure to the oops in the oops popped | |
| 6766 // 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
|
6767 bool res = _mark_stack->push(obj); |
| 0 | 6768 assert(res, "Should have space to push on empty stack"); |
| 6769 do { | |
| 6770 oop new_oop = _mark_stack->pop(); | |
| 6771 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 6772 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 6773 "only grey objects on this stack"); | |
| 6774 // iterate over the oops in this oop, marking and pushing | |
| 6775 // the ones in CMS heap (i.e. in _span). | |
| 6776 new_oop->oop_iterate(&_pushAndMarkClosure); | |
| 6777 // check if it's time to yield | |
| 6778 do_yield_check(); | |
| 6779 } while (!_mark_stack->isEmpty() || | |
| 6780 (!_concurrent_precleaning && take_from_overflow_list())); | |
| 6781 // if marking stack is empty, and we are not doing this | |
| 6782 // during precleaning, then check the overflow list | |
| 6783 } | |
| 6784 assert(_mark_stack->isEmpty(), "post-condition (eager drainage)"); | |
| 6785 assert(_collector->overflow_list_is_empty(), | |
| 6786 "overflow list was drained above"); | |
| 6787 // We could restore evacuated mark words, if any, used for | |
| 6788 // overflow list links here because the overflow list is | |
| 6789 // provably empty here. That would reduce the maximum | |
| 6790 // size requirements for preserved_{oop,mark}_stack. | |
| 6791 // But we'll just postpone it until we are all done | |
| 6792 // so we can just stream through. | |
| 6793 if (!_concurrent_precleaning && CMSOverflowEarlyRestoration) { | |
| 6794 _collector->restore_preserved_marks_if_any(); | |
| 6795 assert(_collector->no_preserved_marks(), "No preserved marks"); | |
| 6796 } | |
| 6797 assert(!CMSOverflowEarlyRestoration || _collector->no_preserved_marks(), | |
| 6798 "All preserved marks should have been restored above"); | |
| 6799 } | |
| 6800 } | |
| 6801 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6802 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
|
6803 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
|
6804 |
| 0 | 6805 void MarkRefsIntoAndScanClosure::do_yield_work() { |
| 6806 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6807 "CMS thread should hold CMS token"); | |
| 6808 assert_lock_strong(_freelistLock); | |
| 6809 assert_lock_strong(_bit_map->lock()); | |
| 6810 // relinquish the free_list_lock and bitMaplock() | |
| 6811 _bit_map->lock()->unlock(); | |
| 6812 _freelistLock->unlock(); | |
| 6813 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6814 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6815 _collector->stopTimer(); | |
| 6816 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6817 if (PrintCMSStatistics != 0) { | |
| 6818 _collector->incrementYields(); | |
| 6819 } | |
| 6820 _collector->icms_wait(); | |
| 6821 | |
| 6822 // 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
|
6823 for (unsigned i = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6824 i < CMSYieldSleepCount && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6825 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6826 !CMSCollector::foregroundGCIsActive(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6827 ++i) { |
| 0 | 6828 os::sleep(Thread::current(), 1, false); |
| 6829 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6830 } | |
| 6831 | |
| 6832 ConcurrentMarkSweepThread::synchronize(true); | |
| 6833 _freelistLock->lock_without_safepoint_check(); | |
| 6834 _bit_map->lock()->lock_without_safepoint_check(); | |
| 6835 _collector->startTimer(); | |
| 6836 } | |
| 6837 | |
| 6838 /////////////////////////////////////////////////////////// | |
| 6839 // Par_MarkRefsIntoAndScanClosure: a parallel version of | |
| 6840 // MarkRefsIntoAndScanClosure | |
| 6841 /////////////////////////////////////////////////////////// | |
| 6842 Par_MarkRefsIntoAndScanClosure::Par_MarkRefsIntoAndScanClosure( | |
| 6843 CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6844 CMSBitMap* bit_map, OopTaskQueue* work_queue): |
| 0 | 6845 _span(span), |
| 6846 _bit_map(bit_map), | |
| 6847 _work_queue(work_queue), | |
| 6848 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4), | |
| 6849 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6850 _par_pushAndMarkClosure(collector, span, rp, bit_map, work_queue) |
| 0 | 6851 { |
| 6852 _ref_processor = rp; | |
| 6853 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 6854 } | |
| 6855 | |
| 6856 // This closure is used to mark refs into the CMS generation at the | |
| 6857 // second (final) checkpoint, and to scan and transitively follow | |
| 6858 // the unmarked oops. The marks are made in the marking bit map and | |
| 6859 // the work_queue is used for keeping the (newly) grey objects during | |
| 6860 // the scan phase whence they are also available for stealing by parallel | |
| 6861 // threads. Since the marking bit map is shared, updates are | |
| 6862 // synchronized (via CAS). | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6863 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
|
6864 if (obj != NULL) { |
| 0 | 6865 // Ignore mark word because this could be an already marked oop |
| 6866 // 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
|
6867 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
|
6868 HeapWord* addr = (HeapWord*)obj; |
| 0 | 6869 if (_span.contains(addr) && |
| 6870 !_bit_map->isMarked(addr)) { | |
| 6871 // mark bit map (object will become grey): | |
| 6872 // It is possible for several threads to be | |
| 6873 // trying to "claim" this object concurrently; | |
| 6874 // the unique thread that succeeds in marking the | |
| 6875 // object first will do the subsequent push on | |
| 6876 // to the work queue (or overflow list). | |
| 6877 if (_bit_map->par_mark(addr)) { | |
| 6878 // push on work_queue (which may not be empty), and trim the | |
| 6879 // queue to an appropriate length by applying this closure to | |
| 6880 // the oops in the oops popped from the stack (i.e. blacken the | |
| 6881 // grey objects) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6882 bool res = _work_queue->push(obj); |
| 0 | 6883 assert(res, "Low water mark should be less than capacity?"); |
| 6884 trim_queue(_low_water_mark); | |
| 6885 } // Else, another thread claimed the object | |
| 6886 } | |
| 6887 } | |
| 6888 } | |
| 6889 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6890 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
|
6891 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
|
6892 |
| 0 | 6893 // This closure is used to rescan the marked objects on the dirty cards |
| 6894 // in the mod union table and the card table proper. | |
| 6895 size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m( | |
| 6896 oop p, MemRegion mr) { | |
| 6897 | |
| 6898 size_t size = 0; | |
| 6899 HeapWord* addr = (HeapWord*)p; | |
| 6900 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 6901 assert(_span.contains(addr), "we are scanning the CMS generation"); | |
| 6902 // check if it's time to yield | |
| 6903 if (do_yield_check()) { | |
| 6904 // We yielded for some foreground stop-world work, | |
| 6905 // and we have been asked to abort this ongoing preclean cycle. | |
| 6906 return 0; | |
| 6907 } | |
| 6908 if (_bitMap->isMarked(addr)) { | |
| 6909 // it's marked; is it potentially uninitialized? | |
| 187 | 6910 if (p->klass_or_null() != NULL) { |
| 0 | 6911 // an initialized object; ignore mark word in verification below |
| 6912 // since we are running concurrent with mutators | |
| 6913 assert(p->is_oop(true), "should be an oop"); | |
| 6914 if (p->is_objArray()) { | |
| 6915 // objArrays are precisely marked; restrict scanning | |
| 6916 // to dirty cards only. | |
| 187 | 6917 size = CompactibleFreeListSpace::adjustObjectSize( |
| 6918 p->oop_iterate(_scanningClosure, mr)); | |
| 0 | 6919 } else { |
| 6920 // A non-array may have been imprecisely marked; we need | |
| 6921 // to scan object in its entirety. | |
| 6922 size = CompactibleFreeListSpace::adjustObjectSize( | |
| 6923 p->oop_iterate(_scanningClosure)); | |
| 6924 } | |
| 9152 | 6925 #ifdef ASSERT |
| 0 | 6926 size_t direct_size = |
| 6927 CompactibleFreeListSpace::adjustObjectSize(p->size()); | |
| 6928 assert(size == direct_size, "Inconsistency in size"); | |
| 6929 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 6930 if (!_bitMap->isMarked(addr+1)) { | |
| 6931 _bitMap->verifyNoOneBitsInRange(addr+2, addr+size); | |
| 6932 } else { | |
| 6933 _bitMap->verifyNoOneBitsInRange(addr+2, addr+size-1); | |
| 6934 assert(_bitMap->isMarked(addr+size-1), | |
| 6935 "inconsistent Printezis mark"); | |
| 6936 } | |
| 9152 | 6937 #endif // ASSERT |
| 0 | 6938 } else { |
| 6939 // an unitialized object | |
| 6940 assert(_bitMap->isMarked(addr+1), "missing Printezis mark?"); | |
| 6941 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2); | |
| 6942 size = pointer_delta(nextOneAddr + 1, addr); | |
| 6943 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 6944 "alignment problem"); | |
| 6945 // Note that pre-cleaning needn't redirty the card. OopDesc::set_klass() | |
| 6946 // will dirty the card when the klass pointer is installed in the | |
| 6947 // object (signalling the completion of initialization). | |
| 6948 } | |
| 6949 } else { | |
| 6950 // Either a not yet marked object or an uninitialized object | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
6951 if (p->klass_or_null() == NULL) { |
| 0 | 6952 // An uninitialized object, skip to the next card, since |
| 6953 // we may not be able to read its P-bits yet. | |
| 6954 assert(size == 0, "Initial value"); | |
| 6955 } else { | |
| 6956 // An object not (yet) reached by marking: we merely need to | |
| 6957 // compute its size so as to go look at the next block. | |
| 6958 assert(p->is_oop(true), "should be an oop"); | |
| 6959 size = CompactibleFreeListSpace::adjustObjectSize(p->size()); | |
| 6960 } | |
| 6961 } | |
| 6962 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 6963 return size; | |
| 6964 } | |
| 6965 | |
| 6966 void ScanMarkedObjectsAgainCarefullyClosure::do_yield_work() { | |
| 6967 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 6968 "CMS thread should hold CMS token"); | |
| 6969 assert_lock_strong(_freelistLock); | |
| 6970 assert_lock_strong(_bitMap->lock()); | |
| 6971 // relinquish the free_list_lock and bitMaplock() | |
| 6972 _bitMap->lock()->unlock(); | |
| 6973 _freelistLock->unlock(); | |
| 6974 ConcurrentMarkSweepThread::desynchronize(true); | |
| 6975 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6976 _collector->stopTimer(); | |
| 6977 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 6978 if (PrintCMSStatistics != 0) { | |
| 6979 _collector->incrementYields(); | |
| 6980 } | |
| 6981 _collector->icms_wait(); | |
| 6982 | |
| 6983 // See the comment in coordinator_yield() | |
| 6984 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
|
6985 ConcurrentMarkSweepThread::should_yield() && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
6986 !CMSCollector::foregroundGCIsActive(); ++i) { |
| 0 | 6987 os::sleep(Thread::current(), 1, false); |
| 6988 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 6989 } | |
| 6990 | |
| 6991 ConcurrentMarkSweepThread::synchronize(true); | |
| 6992 _freelistLock->lock_without_safepoint_check(); | |
| 6993 _bitMap->lock()->lock_without_safepoint_check(); | |
| 6994 _collector->startTimer(); | |
| 6995 } | |
| 6996 | |
| 6997 | |
| 6998 ////////////////////////////////////////////////////////////////// | |
| 6999 // SurvivorSpacePrecleanClosure | |
| 7000 ////////////////////////////////////////////////////////////////// | |
| 7001 // This (single-threaded) closure is used to preclean the oops in | |
| 7002 // the survivor spaces. | |
| 7003 size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) { | |
| 7004 | |
| 7005 HeapWord* addr = (HeapWord*)p; | |
| 7006 DEBUG_ONLY(_collector->verify_work_stacks_empty();) | |
| 7007 assert(!_span.contains(addr), "we are scanning the survivor spaces"); | |
| 187 | 7008 assert(p->klass_or_null() != NULL, "object should be initializd"); |
| 0 | 7009 // an initialized object; ignore mark word in verification below |
| 7010 // since we are running concurrent with mutators | |
| 7011 assert(p->is_oop(true), "should be an oop"); | |
| 7012 // Note that we do not yield while we iterate over | |
| 7013 // the interior oops of p, pushing the relevant ones | |
| 7014 // on our marking stack. | |
| 7015 size_t size = p->oop_iterate(_scanning_closure); | |
| 7016 do_yield_check(); | |
| 7017 // Observe that below, we do not abandon the preclean | |
| 7018 // phase as soon as we should; rather we empty the | |
| 7019 // marking stack before returning. This is to satisfy | |
| 7020 // some existing assertions. In general, it may be a | |
| 7021 // good idea to abort immediately and complete the marking | |
| 7022 // from the grey objects at a later time. | |
| 7023 while (!_mark_stack->isEmpty()) { | |
| 7024 oop new_oop = _mark_stack->pop(); | |
| 7025 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 7026 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 7027 "only grey objects on this stack"); | |
| 7028 // iterate over the oops in this oop, marking and pushing | |
| 7029 // the ones in CMS heap (i.e. in _span). | |
| 7030 new_oop->oop_iterate(_scanning_closure); | |
| 7031 // check if it's time to yield | |
| 7032 do_yield_check(); | |
| 7033 } | |
| 7034 unsigned int after_count = | |
| 7035 GenCollectedHeap::heap()->total_collections(); | |
| 7036 bool abort = (_before_count != after_count) || | |
| 7037 _collector->should_abort_preclean(); | |
| 7038 return abort ? 0 : size; | |
| 7039 } | |
| 7040 | |
| 7041 void SurvivorSpacePrecleanClosure::do_yield_work() { | |
| 7042 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 7043 "CMS thread should hold CMS token"); | |
| 7044 assert_lock_strong(_bit_map->lock()); | |
| 7045 // Relinquish the bit map lock | |
| 7046 _bit_map->lock()->unlock(); | |
| 7047 ConcurrentMarkSweepThread::desynchronize(true); | |
| 7048 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7049 _collector->stopTimer(); | |
| 7050 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 7051 if (PrintCMSStatistics != 0) { | |
| 7052 _collector->incrementYields(); | |
| 7053 } | |
| 7054 _collector->icms_wait(); | |
| 7055 | |
| 7056 // See the comment in coordinator_yield() | |
| 7057 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 7058 ConcurrentMarkSweepThread::should_yield() && | |
| 7059 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 7060 os::sleep(Thread::current(), 1, false); | |
| 7061 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7062 } | |
| 7063 | |
| 7064 ConcurrentMarkSweepThread::synchronize(true); | |
| 7065 _bit_map->lock()->lock_without_safepoint_check(); | |
| 7066 _collector->startTimer(); | |
| 7067 } | |
| 7068 | |
| 7069 // This closure is used to rescan the marked objects on the dirty cards | |
| 7070 // in the mod union table and the card table proper. In the parallel | |
| 7071 // case, although the bitMap is shared, we do a single read so the | |
| 7072 // isMarked() query is "safe". | |
| 7073 bool ScanMarkedObjectsAgainClosure::do_object_bm(oop p, MemRegion mr) { | |
| 7074 // Ignore mark word because we are running concurrent with mutators | |
| 7075 assert(p->is_oop_or_null(true), "expected an oop or null"); | |
| 7076 HeapWord* addr = (HeapWord*)p; | |
| 7077 assert(_span.contains(addr), "we are scanning the CMS generation"); | |
| 7078 bool is_obj_array = false; | |
| 9152 | 7079 #ifdef ASSERT |
| 0 | 7080 if (!_parallel) { |
| 7081 assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)"); | |
| 7082 assert(_collector->overflow_list_is_empty(), | |
| 7083 "overflow list should be empty"); | |
| 7084 | |
| 7085 } | |
| 9152 | 7086 #endif // ASSERT |
| 0 | 7087 if (_bit_map->isMarked(addr)) { |
| 7088 // Obj arrays are precisely marked, non-arrays are not; | |
| 7089 // so we scan objArrays precisely and non-arrays in their | |
| 7090 // entirety. | |
| 7091 if (p->is_objArray()) { | |
| 7092 is_obj_array = true; | |
| 7093 if (_parallel) { | |
| 7094 p->oop_iterate(_par_scan_closure, mr); | |
| 7095 } else { | |
| 7096 p->oop_iterate(_scan_closure, mr); | |
| 7097 } | |
| 7098 } else { | |
| 7099 if (_parallel) { | |
| 7100 p->oop_iterate(_par_scan_closure); | |
| 7101 } else { | |
| 7102 p->oop_iterate(_scan_closure); | |
| 7103 } | |
| 7104 } | |
| 7105 } | |
| 9152 | 7106 #ifdef ASSERT |
| 0 | 7107 if (!_parallel) { |
| 7108 assert(_mark_stack->isEmpty(), "post-condition (eager drainage)"); | |
| 7109 assert(_collector->overflow_list_is_empty(), | |
| 7110 "overflow list should be empty"); | |
| 7111 | |
| 7112 } | |
| 9152 | 7113 #endif // ASSERT |
| 0 | 7114 return is_obj_array; |
| 7115 } | |
| 7116 | |
| 7117 MarkFromRootsClosure::MarkFromRootsClosure(CMSCollector* collector, | |
| 7118 MemRegion span, | |
| 7119 CMSBitMap* bitMap, CMSMarkStack* markStack, | |
| 7120 bool should_yield, bool verifying): | |
| 7121 _collector(collector), | |
| 7122 _span(span), | |
| 7123 _bitMap(bitMap), | |
| 7124 _mut(&collector->_modUnionTable), | |
| 7125 _markStack(markStack), | |
| 7126 _yield(should_yield), | |
| 7127 _skipBits(0) | |
| 7128 { | |
| 7129 assert(_markStack->isEmpty(), "stack should be empty"); | |
| 7130 _finger = _bitMap->startWord(); | |
| 7131 _threshold = _finger; | |
| 7132 assert(_collector->_restart_addr == NULL, "Sanity check"); | |
| 7133 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 7134 DEBUG_ONLY(_verifying = verifying;) | |
| 7135 } | |
| 7136 | |
| 7137 void MarkFromRootsClosure::reset(HeapWord* addr) { | |
| 7138 assert(_markStack->isEmpty(), "would cause duplicates on stack"); | |
| 7139 assert(_span.contains(addr), "Out of bounds _finger?"); | |
| 7140 _finger = addr; | |
| 7141 _threshold = (HeapWord*)round_to( | |
| 7142 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 7143 } | |
| 7144 | |
| 7145 // Should revisit to see if this should be restructured for | |
| 7146 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7147 bool MarkFromRootsClosure::do_bit(size_t offset) { |
| 0 | 7148 if (_skipBits > 0) { |
| 7149 _skipBits--; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7150 return true; |
| 0 | 7151 } |
| 7152 // convert offset into a HeapWord* | |
| 7153 HeapWord* addr = _bitMap->startWord() + offset; | |
| 7154 assert(_bitMap->endWord() && addr < _bitMap->endWord(), | |
| 7155 "address out of range"); | |
| 7156 assert(_bitMap->isMarked(addr), "tautology"); | |
| 7157 if (_bitMap->isMarked(addr+1)) { | |
| 7158 // this is an allocated but not yet initialized object | |
| 7159 assert(_skipBits == 0, "tautology"); | |
| 7160 _skipBits = 2; // skip next two marked bits ("Printezis-marks") | |
| 7161 oop p = oop(addr); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7162 if (p->klass_or_null() == NULL) { |
| 0 | 7163 DEBUG_ONLY(if (!_verifying) {) |
| 7164 // We re-dirty the cards on which this object lies and increase | |
| 7165 // the _threshold so that we'll come back to scan this object | |
| 7166 // during the preclean or remark phase. (CMSCleanOnEnter) | |
| 7167 if (CMSCleanOnEnter) { | |
| 7168 size_t sz = _collector->block_size_using_printezis_bits(addr); | |
| 7169 HeapWord* end_card_addr = (HeapWord*)round_to( | |
| 7170 (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
|
7171 MemRegion redirty_range = MemRegion(addr, end_card_addr); |
| 0 | 7172 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
| 7173 // Bump _threshold to end_card_addr; note that | |
| 7174 // _threshold cannot possibly exceed end_card_addr, anyhow. | |
| 7175 // This prevents future clearing of the card as the scan proceeds | |
| 7176 // to the right. | |
| 7177 assert(_threshold <= end_card_addr, | |
| 7178 "Because we are just scanning into this object"); | |
| 7179 if (_threshold < end_card_addr) { | |
| 7180 _threshold = end_card_addr; | |
| 7181 } | |
| 187 | 7182 if (p->klass_or_null() != NULL) { |
| 0 | 7183 // Redirty the range of cards... |
| 7184 _mut->mark_range(redirty_range); | |
| 7185 } // ...else the setting of klass will dirty the card anyway. | |
| 7186 } | |
| 7187 DEBUG_ONLY(}) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7188 return true; |
| 0 | 7189 } |
| 7190 } | |
| 7191 scanOopsInOop(addr); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7192 return true; |
| 0 | 7193 } |
| 7194 | |
| 7195 // We take a break if we've been at this for a while, | |
| 7196 // so as to avoid monopolizing the locks involved. | |
| 7197 void MarkFromRootsClosure::do_yield_work() { | |
| 7198 // First give up the locks, then yield, then re-lock | |
| 7199 // We should probably use a constructor/destructor idiom to | |
| 7200 // do this unlock/lock or modify the MutexUnlocker class to | |
| 7201 // serve our purpose. XXX | |
| 7202 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 7203 "CMS thread should hold CMS token"); | |
| 7204 assert_lock_strong(_bitMap->lock()); | |
| 7205 _bitMap->lock()->unlock(); | |
| 7206 ConcurrentMarkSweepThread::desynchronize(true); | |
| 7207 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7208 _collector->stopTimer(); | |
| 7209 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 7210 if (PrintCMSStatistics != 0) { | |
| 7211 _collector->incrementYields(); | |
| 7212 } | |
| 7213 _collector->icms_wait(); | |
| 7214 | |
| 7215 // See the comment in coordinator_yield() | |
| 7216 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 7217 ConcurrentMarkSweepThread::should_yield() && | |
| 7218 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 7219 os::sleep(Thread::current(), 1, false); | |
| 7220 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7221 } | |
| 7222 | |
| 7223 ConcurrentMarkSweepThread::synchronize(true); | |
| 7224 _bitMap->lock()->lock_without_safepoint_check(); | |
| 7225 _collector->startTimer(); | |
| 7226 } | |
| 7227 | |
| 7228 void MarkFromRootsClosure::scanOopsInOop(HeapWord* ptr) { | |
| 7229 assert(_bitMap->isMarked(ptr), "expected bit to be set"); | |
| 7230 assert(_markStack->isEmpty(), | |
| 7231 "should drain stack to limit stack usage"); | |
| 7232 // 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
|
7233 oop obj = oop(ptr); |
| 0 | 7234 // Ignore mark word in verification below, since we |
| 7235 // 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
|
7236 assert(obj->is_oop(true), "should be an oop"); |
| 0 | 7237 assert(_finger <= ptr, "_finger runneth ahead"); |
| 7238 // 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
|
7239 _finger = ptr + obj->size(); |
| 0 | 7240 assert(_finger > ptr, "we just incremented it above"); |
| 7241 // On large heaps, it may take us some time to get through | |
| 7242 // the marking phase (especially if running iCMS). During | |
| 7243 // this time it's possible that a lot of mutations have | |
| 7244 // accumulated in the card table and the mod union table -- | |
| 7245 // these mutation records are redundant until we have | |
| 7246 // actually traced into the corresponding card. | |
| 7247 // Here, we check whether advancing the finger would make | |
| 7248 // us cross into a new card, and if so clear corresponding | |
| 7249 // cards in the MUT (preclean them in the card-table in the | |
| 7250 // future). | |
| 7251 | |
| 7252 DEBUG_ONLY(if (!_verifying) {) | |
| 7253 // The clean-on-enter optimization is disabled by default, | |
| 7254 // until we fix 6178663. | |
| 7255 if (CMSCleanOnEnter && (_finger > _threshold)) { | |
| 7256 // [_threshold, _finger) represents the interval | |
| 7257 // of cards to be cleared in MUT (or precleaned in card table). | |
| 7258 // The set of cards to be cleared is all those that overlap | |
| 7259 // with the interval [_threshold, _finger); note that | |
| 7260 // _threshold is always kept card-aligned but _finger isn't | |
| 7261 // always card-aligned. | |
| 7262 HeapWord* old_threshold = _threshold; | |
| 7263 assert(old_threshold == (HeapWord*)round_to( | |
| 7264 (intptr_t)old_threshold, CardTableModRefBS::card_size), | |
| 7265 "_threshold should always be card-aligned"); | |
| 7266 _threshold = (HeapWord*)round_to( | |
| 7267 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 7268 MemRegion mr(old_threshold, _threshold); | |
| 7269 assert(!mr.is_empty(), "Control point invariant"); | |
| 7270 assert(_span.contains(mr), "Should clear within span"); | |
| 7271 _mut->clear_range(mr); | |
| 7272 } | |
| 7273 DEBUG_ONLY(}) | |
| 7274 // Note: the finger doesn't advance while we drain | |
| 7275 // the stack below. | |
| 7276 PushOrMarkClosure pushOrMarkClosure(_collector, | |
| 7277 _span, _bitMap, _markStack, | |
| 7278 _finger, this); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7279 bool res = _markStack->push(obj); |
| 0 | 7280 assert(res, "Empty non-zero size stack should have space for single push"); |
| 7281 while (!_markStack->isEmpty()) { | |
| 7282 oop new_oop = _markStack->pop(); | |
| 7283 // Skip verifying header mark word below because we are | |
| 7284 // running concurrent with mutators. | |
| 7285 assert(new_oop->is_oop(true), "Oops! expected to pop an oop"); | |
| 7286 // now scan this oop's oops | |
| 7287 new_oop->oop_iterate(&pushOrMarkClosure); | |
| 7288 do_yield_check(); | |
| 7289 } | |
| 7290 assert(_markStack->isEmpty(), "tautology, emphasizing post-condition"); | |
| 7291 } | |
| 7292 | |
| 7293 Par_MarkFromRootsClosure::Par_MarkFromRootsClosure(CMSConcMarkingTask* task, | |
| 7294 CMSCollector* collector, MemRegion span, | |
| 7295 CMSBitMap* bit_map, | |
| 7296 OopTaskQueue* work_queue, | |
| 7297 CMSMarkStack* overflow_stack, | |
| 7298 bool should_yield): | |
| 7299 _collector(collector), | |
| 7300 _whole_span(collector->_span), | |
| 7301 _span(span), | |
| 7302 _bit_map(bit_map), | |
| 7303 _mut(&collector->_modUnionTable), | |
| 7304 _work_queue(work_queue), | |
| 7305 _overflow_stack(overflow_stack), | |
| 7306 _yield(should_yield), | |
| 7307 _skip_bits(0), | |
| 7308 _task(task) | |
| 7309 { | |
| 7310 assert(_work_queue->size() == 0, "work_queue should be empty"); | |
| 7311 _finger = span.start(); | |
| 7312 _threshold = _finger; // XXX Defer clear-on-enter optimization for now | |
| 7313 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 7314 } | |
| 7315 | |
| 7316 // Should revisit to see if this should be restructured for | |
| 7317 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7318 bool Par_MarkFromRootsClosure::do_bit(size_t offset) { |
| 0 | 7319 if (_skip_bits > 0) { |
| 7320 _skip_bits--; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7321 return true; |
| 0 | 7322 } |
| 7323 // convert offset into a HeapWord* | |
| 7324 HeapWord* addr = _bit_map->startWord() + offset; | |
| 7325 assert(_bit_map->endWord() && addr < _bit_map->endWord(), | |
| 7326 "address out of range"); | |
| 7327 assert(_bit_map->isMarked(addr), "tautology"); | |
| 7328 if (_bit_map->isMarked(addr+1)) { | |
| 7329 // this is an allocated object that might not yet be initialized | |
| 7330 assert(_skip_bits == 0, "tautology"); | |
| 7331 _skip_bits = 2; // skip next two marked bits ("Printezis-marks") | |
| 7332 oop p = oop(addr); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7333 if (p->klass_or_null() == NULL) { |
| 0 | 7334 // in the case of Clean-on-Enter optimization, redirty card |
| 7335 // and avoid clearing card by increasing the threshold. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7336 return true; |
| 0 | 7337 } |
| 7338 } | |
| 7339 scan_oops_in_oop(addr); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7340 return true; |
| 0 | 7341 } |
| 7342 | |
| 7343 void Par_MarkFromRootsClosure::scan_oops_in_oop(HeapWord* ptr) { | |
| 7344 assert(_bit_map->isMarked(ptr), "expected bit to be set"); | |
| 7345 // Should we assert that our work queue is empty or | |
| 7346 // below some drain limit? | |
| 7347 assert(_work_queue->size() == 0, | |
| 7348 "should drain stack to limit stack usage"); | |
| 7349 // 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
|
7350 oop obj = oop(ptr); |
| 0 | 7351 // Ignore mark word in verification below, since we |
| 7352 // 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
|
7353 assert(obj->is_oop(true), "should be an oop"); |
| 0 | 7354 assert(_finger <= ptr, "_finger runneth ahead"); |
| 7355 // 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
|
7356 _finger = ptr + obj->size(); |
| 0 | 7357 assert(_finger > ptr, "we just incremented it above"); |
| 7358 // On large heaps, it may take us some time to get through | |
| 7359 // the marking phase (especially if running iCMS). During | |
| 7360 // this time it's possible that a lot of mutations have | |
| 7361 // accumulated in the card table and the mod union table -- | |
| 7362 // these mutation records are redundant until we have | |
| 7363 // actually traced into the corresponding card. | |
| 7364 // Here, we check whether advancing the finger would make | |
| 7365 // us cross into a new card, and if so clear corresponding | |
| 7366 // cards in the MUT (preclean them in the card-table in the | |
| 7367 // future). | |
| 7368 | |
| 7369 // The clean-on-enter optimization is disabled by default, | |
| 7370 // until we fix 6178663. | |
| 7371 if (CMSCleanOnEnter && (_finger > _threshold)) { | |
| 7372 // [_threshold, _finger) represents the interval | |
| 7373 // of cards to be cleared in MUT (or precleaned in card table). | |
| 7374 // The set of cards to be cleared is all those that overlap | |
| 7375 // with the interval [_threshold, _finger); note that | |
| 7376 // _threshold is always kept card-aligned but _finger isn't | |
| 7377 // always card-aligned. | |
| 7378 HeapWord* old_threshold = _threshold; | |
| 7379 assert(old_threshold == (HeapWord*)round_to( | |
| 7380 (intptr_t)old_threshold, CardTableModRefBS::card_size), | |
| 7381 "_threshold should always be card-aligned"); | |
| 7382 _threshold = (HeapWord*)round_to( | |
| 7383 (intptr_t)_finger, CardTableModRefBS::card_size); | |
| 7384 MemRegion mr(old_threshold, _threshold); | |
| 7385 assert(!mr.is_empty(), "Control point invariant"); | |
| 7386 assert(_span.contains(mr), "Should clear within span"); // _whole_span ?? | |
| 7387 _mut->clear_range(mr); | |
| 7388 } | |
| 7389 | |
| 7390 // Note: the local finger doesn't advance while we drain | |
| 7391 // the stack below, but the global finger sure can and will. | |
| 7392 HeapWord** gfa = _task->global_finger_addr(); | |
| 7393 Par_PushOrMarkClosure pushOrMarkClosure(_collector, | |
| 7394 _span, _bit_map, | |
| 7395 _work_queue, | |
| 7396 _overflow_stack, | |
| 7397 _finger, | |
| 7398 gfa, this); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7399 bool res = _work_queue->push(obj); // overflow could occur here |
| 0 | 7400 assert(res, "Will hold once we use workqueues"); |
| 7401 while (true) { | |
| 7402 oop new_oop; | |
| 7403 if (!_work_queue->pop_local(new_oop)) { | |
| 7404 // We emptied our work_queue; check if there's stuff that can | |
| 7405 // be gotten from the overflow stack. | |
| 7406 if (CMSConcMarkingTask::get_work_from_overflow_stack( | |
| 7407 _overflow_stack, _work_queue)) { | |
| 7408 do_yield_check(); | |
| 7409 continue; | |
| 7410 } else { // done | |
| 7411 break; | |
| 7412 } | |
| 7413 } | |
| 7414 // Skip verifying header mark word below because we are | |
| 7415 // running concurrent with mutators. | |
| 7416 assert(new_oop->is_oop(true), "Oops! expected to pop an oop"); | |
| 7417 // now scan this oop's oops | |
| 7418 new_oop->oop_iterate(&pushOrMarkClosure); | |
| 7419 do_yield_check(); | |
| 7420 } | |
| 7421 assert(_work_queue->size() == 0, "tautology, emphasizing post-condition"); | |
| 7422 } | |
| 7423 | |
| 7424 // Yield in response to a request from VM Thread or | |
| 7425 // from mutators. | |
| 7426 void Par_MarkFromRootsClosure::do_yield_work() { | |
| 7427 assert(_task != NULL, "sanity"); | |
| 7428 _task->yield(); | |
| 7429 } | |
| 7430 | |
| 7431 // A variant of the above used for verifying CMS marking work. | |
| 7432 MarkFromRootsVerifyClosure::MarkFromRootsVerifyClosure(CMSCollector* collector, | |
| 7433 MemRegion span, | |
| 7434 CMSBitMap* verification_bm, CMSBitMap* cms_bm, | |
| 7435 CMSMarkStack* mark_stack): | |
| 7436 _collector(collector), | |
| 7437 _span(span), | |
| 7438 _verification_bm(verification_bm), | |
| 7439 _cms_bm(cms_bm), | |
| 7440 _mark_stack(mark_stack), | |
| 7441 _pam_verify_closure(collector, span, verification_bm, cms_bm, | |
| 7442 mark_stack) | |
| 7443 { | |
| 7444 assert(_mark_stack->isEmpty(), "stack should be empty"); | |
| 7445 _finger = _verification_bm->startWord(); | |
| 7446 assert(_collector->_restart_addr == NULL, "Sanity check"); | |
| 7447 assert(_span.contains(_finger), "Out of bounds _finger?"); | |
| 7448 } | |
| 7449 | |
| 7450 void MarkFromRootsVerifyClosure::reset(HeapWord* addr) { | |
| 7451 assert(_mark_stack->isEmpty(), "would cause duplicates on stack"); | |
| 7452 assert(_span.contains(addr), "Out of bounds _finger?"); | |
| 7453 _finger = addr; | |
| 7454 } | |
| 7455 | |
| 7456 // Should revisit to see if this should be restructured for | |
| 7457 // greater efficiency. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7458 bool MarkFromRootsVerifyClosure::do_bit(size_t offset) { |
| 0 | 7459 // convert offset into a HeapWord* |
| 7460 HeapWord* addr = _verification_bm->startWord() + offset; | |
| 7461 assert(_verification_bm->endWord() && addr < _verification_bm->endWord(), | |
| 7462 "address out of range"); | |
| 7463 assert(_verification_bm->isMarked(addr), "tautology"); | |
| 7464 assert(_cms_bm->isMarked(addr), "tautology"); | |
| 7465 | |
| 7466 assert(_mark_stack->isEmpty(), | |
| 7467 "should drain stack to limit stack usage"); | |
| 7468 // 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
|
7469 oop obj = oop(addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7470 assert(obj->is_oop(), "should be an oop"); |
| 0 | 7471 assert(_finger <= addr, "_finger runneth ahead"); |
| 7472 // 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
|
7473 _finger = addr + obj->size(); |
| 0 | 7474 assert(_finger > addr, "we just incremented it above"); |
| 7475 // Note: the finger doesn't advance while we drain | |
| 7476 // the stack below. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7477 bool res = _mark_stack->push(obj); |
| 0 | 7478 assert(res, "Empty non-zero size stack should have space for single push"); |
| 7479 while (!_mark_stack->isEmpty()) { | |
| 7480 oop new_oop = _mark_stack->pop(); | |
| 7481 assert(new_oop->is_oop(), "Oops! expected to pop an oop"); | |
| 7482 // now scan this oop's oops | |
| 7483 new_oop->oop_iterate(&_pam_verify_closure); | |
| 7484 } | |
| 7485 assert(_mark_stack->isEmpty(), "tautology, emphasizing post-condition"); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7486 return true; |
| 0 | 7487 } |
| 7488 | |
| 7489 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure( | |
| 7490 CMSCollector* collector, MemRegion span, | |
| 7491 CMSBitMap* verification_bm, CMSBitMap* cms_bm, | |
| 7492 CMSMarkStack* mark_stack): | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7493 CMSOopClosure(collector->ref_processor()), |
| 0 | 7494 _collector(collector), |
| 7495 _span(span), | |
| 7496 _verification_bm(verification_bm), | |
| 7497 _cms_bm(cms_bm), | |
| 7498 _mark_stack(mark_stack) | |
| 7499 { } | |
| 7500 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7501 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
|
7502 void PushAndMarkVerifyClosure::do_oop(narrowOop* p) { PushAndMarkVerifyClosure::do_oop_work(p); } |
| 0 | 7503 |
| 7504 // Upon stack overflow, we discard (part of) the stack, | |
| 7505 // remembering the least address amongst those discarded | |
| 7506 // in CMSCollector's _restart_address. | |
| 7507 void PushAndMarkVerifyClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7508 // Remember the least grey address discarded | |
| 7509 HeapWord* ra = (HeapWord*)_mark_stack->least_value(lost); | |
| 7510 _collector->lower_restart_addr(ra); | |
| 7511 _mark_stack->reset(); // discard stack contents | |
| 7512 _mark_stack->expand(); // expand the stack if possible | |
| 7513 } | |
| 7514 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7515 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
|
7516 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
|
7517 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7518 if (_span.contains(addr) && !_verification_bm->isMarked(addr)) { |
| 7519 // Oop lies in _span and isn't yet grey or black | |
| 7520 _verification_bm->mark(addr); // now grey | |
| 7521 if (!_cms_bm->isMarked(addr)) { | |
| 7522 oop(addr)->print(); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7523 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
|
7524 addr); |
| 0 | 7525 fatal("... aborting"); |
| 7526 } | |
| 7527 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7528 if (!_mark_stack->push(obj)) { // stack overflow |
| 0 | 7529 if (PrintCMSStatistics != 0) { |
| 7530 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7531 SIZE_FORMAT, _mark_stack->capacity()); | |
| 7532 } | |
| 7533 assert(_mark_stack->isFull(), "Else push should have succeeded"); | |
| 7534 handle_stack_overflow(addr); | |
| 7535 } | |
| 7536 // anything including and to the right of _finger | |
| 7537 // will be scanned as we iterate over the remainder of the | |
| 7538 // bit map | |
| 7539 } | |
| 7540 } | |
| 7541 | |
| 7542 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector, | |
| 7543 MemRegion span, | |
| 7544 CMSBitMap* bitMap, CMSMarkStack* markStack, | |
| 7545 HeapWord* finger, MarkFromRootsClosure* parent) : | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7546 CMSOopClosure(collector->ref_processor()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7547 _collector(collector), |
| 0 | 7548 _span(span), |
| 7549 _bitMap(bitMap), | |
| 7550 _markStack(markStack), | |
| 7551 _finger(finger), | |
| 935 | 7552 _parent(parent) |
| 0 | 7553 { } |
| 7554 | |
| 7555 Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector, | |
| 7556 MemRegion span, | |
| 7557 CMSBitMap* bit_map, | |
| 7558 OopTaskQueue* work_queue, | |
| 7559 CMSMarkStack* overflow_stack, | |
| 7560 HeapWord* finger, | |
| 7561 HeapWord** global_finger_addr, | |
| 7562 Par_MarkFromRootsClosure* parent) : | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7563 CMSOopClosure(collector->ref_processor()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7564 _collector(collector), |
| 0 | 7565 _whole_span(collector->_span), |
| 7566 _span(span), | |
| 7567 _bit_map(bit_map), | |
| 7568 _work_queue(work_queue), | |
| 7569 _overflow_stack(overflow_stack), | |
| 7570 _finger(finger), | |
| 7571 _global_finger_addr(global_finger_addr), | |
| 935 | 7572 _parent(parent) |
| 0 | 7573 { } |
| 7574 | |
|
340
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
7575 // Assumes thread-safe access by callers, who are |
|
ebeb6490b814
6722116: CMS: Incorrect overflow handling when using parallel concurrent marking
ysr
parents:
283
diff
changeset
|
7576 // responsible for mutual exclusion. |
| 0 | 7577 void CMSCollector::lower_restart_addr(HeapWord* low) { |
| 7578 assert(_span.contains(low), "Out of bounds addr"); | |
| 7579 if (_restart_addr == NULL) { | |
| 7580 _restart_addr = low; | |
| 7581 } else { | |
| 7582 _restart_addr = MIN2(_restart_addr, low); | |
| 7583 } | |
| 7584 } | |
| 7585 | |
| 7586 // Upon stack overflow, we discard (part of) the stack, | |
| 7587 // remembering the least address amongst those discarded | |
| 7588 // in CMSCollector's _restart_address. | |
| 7589 void PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7590 // Remember the least grey address discarded | |
| 7591 HeapWord* ra = (HeapWord*)_markStack->least_value(lost); | |
| 7592 _collector->lower_restart_addr(ra); | |
| 7593 _markStack->reset(); // discard stack contents | |
| 7594 _markStack->expand(); // expand the stack if possible | |
| 7595 } | |
| 7596 | |
| 7597 // Upon stack overflow, we discard (part of) the stack, | |
| 7598 // remembering the least address amongst those discarded | |
| 7599 // in CMSCollector's _restart_address. | |
| 7600 void Par_PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { | |
| 7601 // 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
|
7602 // workers from interfering with the work done below. |
| 0 | 7603 MutexLockerEx ml(_overflow_stack->par_lock(), |
| 7604 Mutex::_no_safepoint_check_flag); | |
| 7605 // Remember the least grey address discarded | |
| 7606 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost); | |
| 7607 _collector->lower_restart_addr(ra); | |
| 7608 _overflow_stack->reset(); // discard stack contents | |
| 7609 _overflow_stack->expand(); // expand the stack if possible | |
| 7610 } | |
| 7611 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7612 void CMKlassClosure::do_klass(Klass* k) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7613 assert(_oop_closure != NULL, "Not initialized?"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7614 k->oops_do(_oop_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7615 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7616 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7617 void PushOrMarkClosure::do_oop(oop obj) { |
| 0 | 7618 // 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
|
7619 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
|
7620 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7621 if (_span.contains(addr) && !_bitMap->isMarked(addr)) { |
| 7622 // Oop lies in _span and isn't yet grey or black | |
| 7623 _bitMap->mark(addr); // now grey | |
| 7624 if (addr < _finger) { | |
| 7625 // the bit map iteration has already either passed, or | |
| 7626 // sampled, this bit in the bit map; we'll need to | |
| 7627 // use the marking stack to scan this oop's oops. | |
| 7628 bool simulate_overflow = false; | |
| 7629 NOT_PRODUCT( | |
| 7630 if (CMSMarkStackOverflowALot && | |
| 7631 _collector->simulate_overflow()) { | |
| 7632 // simulate a stack overflow | |
| 7633 simulate_overflow = true; | |
| 7634 } | |
| 7635 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7636 if (simulate_overflow || !_markStack->push(obj)) { // stack overflow |
| 0 | 7637 if (PrintCMSStatistics != 0) { |
| 7638 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7639 SIZE_FORMAT, _markStack->capacity()); | |
| 7640 } | |
| 7641 assert(simulate_overflow || _markStack->isFull(), "Else push should have succeeded"); | |
| 7642 handle_stack_overflow(addr); | |
| 7643 } | |
| 7644 } | |
| 7645 // anything including and to the right of _finger | |
| 7646 // will be scanned as we iterate over the remainder of the | |
| 7647 // bit map | |
| 7648 do_yield_check(); | |
| 7649 } | |
| 7650 } | |
| 7651 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7652 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
|
7653 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
|
7654 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7655 void Par_PushOrMarkClosure::do_oop(oop obj) { |
| 0 | 7656 // 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
|
7657 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
|
7658 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7659 if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) { |
| 7660 // Oop lies in _span and isn't yet grey or black | |
| 7661 // We read the global_finger (volatile read) strictly after marking oop | |
| 7662 bool res = _bit_map->par_mark(addr); // now grey | |
| 7663 volatile HeapWord** gfa = (volatile HeapWord**)_global_finger_addr; | |
| 7664 // Should we push this marked oop on our stack? | |
| 7665 // -- if someone else marked it, nothing to do | |
| 7666 // -- if target oop is above global finger nothing to do | |
| 7667 // -- if target oop is in chunk and above local finger | |
| 7668 // then nothing to do | |
| 7669 // -- else push on work queue | |
| 7670 if ( !res // someone else marked it, they will deal with it | |
| 7671 || (addr >= *gfa) // will be scanned in a later task | |
| 7672 || (_span.contains(addr) && addr >= _finger)) { // later in this chunk | |
| 7673 return; | |
| 7674 } | |
| 7675 // the bit map iteration has already either passed, or | |
| 7676 // sampled, this bit in the bit map; we'll need to | |
| 7677 // use the marking stack to scan this oop's oops. | |
| 7678 bool simulate_overflow = false; | |
| 7679 NOT_PRODUCT( | |
| 7680 if (CMSMarkStackOverflowALot && | |
| 7681 _collector->simulate_overflow()) { | |
| 7682 // simulate a stack overflow | |
| 7683 simulate_overflow = true; | |
| 7684 } | |
| 7685 ) | |
| 7686 if (simulate_overflow || | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7687 !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { |
| 0 | 7688 // stack overflow |
| 7689 if (PrintCMSStatistics != 0) { | |
| 7690 gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " | |
| 7691 SIZE_FORMAT, _overflow_stack->capacity()); | |
| 7692 } | |
| 7693 // We cannot assert that the overflow stack is full because | |
| 7694 // it may have been emptied since. | |
| 7695 assert(simulate_overflow || | |
| 7696 _work_queue->size() == _work_queue->max_elems(), | |
| 7697 "Else push should have succeeded"); | |
| 7698 handle_stack_overflow(addr); | |
| 7699 } | |
| 7700 do_yield_check(); | |
| 7701 } | |
| 7702 } | |
| 7703 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7704 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
|
7705 void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
| 0 | 7706 |
| 7707 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector, | |
| 7708 MemRegion span, | |
| 7709 ReferenceProcessor* rp, | |
| 7710 CMSBitMap* bit_map, | |
| 7711 CMSBitMap* mod_union_table, | |
| 7712 CMSMarkStack* mark_stack, | |
| 7713 bool concurrent_precleaning): | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7714 CMSOopClosure(rp), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7715 _collector(collector), |
| 0 | 7716 _span(span), |
| 7717 _bit_map(bit_map), | |
| 7718 _mod_union_table(mod_union_table), | |
| 7719 _mark_stack(mark_stack), | |
| 935 | 7720 _concurrent_precleaning(concurrent_precleaning) |
| 0 | 7721 { |
| 7722 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 7723 } | |
| 7724 | |
| 7725 // Grey object rescan during pre-cleaning and second checkpoint phases -- | |
| 7726 // 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
|
7727 void PushAndMarkClosure::do_oop(oop obj) { |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7728 // Ignore mark word verification. If during concurrent precleaning, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7729 // the object monitor may be locked. If during the checkpoint |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7730 // 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
|
7731 // 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
|
7732 // the mark word may be NULL). |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
7733 assert(obj->is_oop_or_null(true /* ignore mark word */), |
| 0 | 7734 "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
|
7735 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7736 // Check if oop points into the CMS generation |
| 7737 // and is not marked | |
| 7738 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 7739 // a white object ... | |
| 7740 _bit_map->mark(addr); // ... now grey | |
| 7741 // push on the marking stack (grey set) | |
| 7742 bool simulate_overflow = false; | |
| 7743 NOT_PRODUCT( | |
| 7744 if (CMSMarkStackOverflowALot && | |
| 7745 _collector->simulate_overflow()) { | |
| 7746 // simulate a stack overflow | |
| 7747 simulate_overflow = true; | |
| 7748 } | |
| 7749 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7750 if (simulate_overflow || !_mark_stack->push(obj)) { |
| 0 | 7751 if (_concurrent_precleaning) { |
|
283
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7752 // During precleaning we can just dirty the appropriate card(s) |
| 0 | 7753 // 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
|
7754 // 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
|
7755 // 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
|
7756 // 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
|
7757 // dirty cards. |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7758 // 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
|
7759 // 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
|
7760 // are required. |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7761 if (obj->is_objArray()) { |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7762 size_t sz = obj->size(); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7763 HeapWord* end_card_addr = (HeapWord*)round_to( |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7764 (intptr_t)(addr+sz), CardTableModRefBS::card_size); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7765 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
|
7766 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7767 _mod_union_table->mark_range(redirty_range); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7768 } else { |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7769 _mod_union_table->mark(addr); |
|
9199f248b0ee
6722112: CMS: Incorrect encoding of overflown object arrays during concurrent precleaning
ysr
parents:
271
diff
changeset
|
7770 } |
| 0 | 7771 _collector->_ser_pmc_preclean_ovflw++; |
| 7772 } else { | |
| 7773 // During the remark phase, we need to remember this oop | |
| 7774 // in the overflow list. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7775 _collector->push_on_overflow_list(obj); |
| 0 | 7776 _collector->_ser_pmc_remark_ovflw++; |
| 7777 } | |
| 7778 } | |
| 7779 } | |
| 7780 } | |
| 7781 | |
| 7782 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector, | |
| 7783 MemRegion span, | |
| 7784 ReferenceProcessor* rp, | |
| 7785 CMSBitMap* bit_map, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7786 OopTaskQueue* work_queue): |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7787 CMSOopClosure(rp), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
7788 _collector(collector), |
| 0 | 7789 _span(span), |
| 7790 _bit_map(bit_map), | |
| 935 | 7791 _work_queue(work_queue) |
| 0 | 7792 { |
| 7793 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); | |
| 7794 } | |
| 7795 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7796 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
|
7797 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
|
7798 |
| 0 | 7799 // Grey object rescan during second checkpoint phase -- |
| 7800 // the parallel version. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7801 void Par_PushAndMarkClosure::do_oop(oop obj) { |
| 0 | 7802 // In the assert below, we ignore the mark word because |
| 7803 // this oop may point to an already visited object that is | |
| 7804 // on the overflow stack (in which case the mark word has | |
| 7805 // been hijacked for chaining into the overflow stack -- | |
| 7806 // if this is the last object in the overflow stack then | |
| 7807 // its mark word will be NULL). Because this object may | |
| 7808 // have been subsequently popped off the global overflow | |
| 7809 // stack, and the mark word possibly restored to the prototypical | |
| 7810 // value, by the time we get to examined this failing assert in | |
| 7811 // the debugger, is_oop_or_null(false) may subsequently start | |
| 7812 // to hold. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7813 assert(obj->is_oop_or_null(true), |
| 0 | 7814 "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
|
7815 HeapWord* addr = (HeapWord*)obj; |
| 0 | 7816 // Check if oop points into the CMS generation |
| 7817 // and is not marked | |
| 7818 if (_span.contains(addr) && !_bit_map->isMarked(addr)) { | |
| 7819 // a white object ... | |
| 7820 // If we manage to "claim" the object, by being the | |
| 7821 // first thread to mark it, then we push it on our | |
| 7822 // marking stack | |
| 7823 if (_bit_map->par_mark(addr)) { // ... now grey | |
| 7824 // push on work queue (grey set) | |
| 7825 bool simulate_overflow = false; | |
| 7826 NOT_PRODUCT( | |
| 7827 if (CMSMarkStackOverflowALot && | |
| 7828 _collector->par_simulate_overflow()) { | |
| 7829 // simulate a stack overflow | |
| 7830 simulate_overflow = true; | |
| 7831 } | |
| 7832 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7833 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
|
7834 _collector->par_push_on_overflow_list(obj); |
| 0 | 7835 _collector->_par_pmc_remark_ovflw++; // imprecise OK: no need to CAS |
| 7836 } | |
| 7837 } // Else, some other thread got there first | |
| 7838 } | |
| 7839 } | |
| 7840 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
7841 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
|
7842 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
|
7843 |
| 0 | 7844 void CMSPrecleanRefsYieldClosure::do_yield_work() { |
| 7845 Mutex* bml = _collector->bitMapLock(); | |
| 7846 assert_lock_strong(bml); | |
| 7847 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 7848 "CMS thread should hold CMS token"); | |
| 7849 | |
| 7850 bml->unlock(); | |
| 7851 ConcurrentMarkSweepThread::desynchronize(true); | |
| 7852 | |
| 7853 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7854 | |
| 7855 _collector->stopTimer(); | |
| 7856 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 7857 if (PrintCMSStatistics != 0) { | |
| 7858 _collector->incrementYields(); | |
| 7859 } | |
| 7860 _collector->icms_wait(); | |
| 7861 | |
| 7862 // See the comment in coordinator_yield() | |
| 7863 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 7864 ConcurrentMarkSweepThread::should_yield() && | |
| 7865 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 7866 os::sleep(Thread::current(), 1, false); | |
| 7867 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 7868 } | |
| 7869 | |
| 7870 ConcurrentMarkSweepThread::synchronize(true); | |
| 7871 bml->lock(); | |
| 7872 | |
| 7873 _collector->startTimer(); | |
| 7874 } | |
| 7875 | |
| 7876 bool CMSPrecleanRefsYieldClosure::should_return() { | |
| 7877 if (ConcurrentMarkSweepThread::should_yield()) { | |
| 7878 do_yield_work(); | |
| 7879 } | |
| 7880 return _collector->foregroundGCIsActive(); | |
| 7881 } | |
| 7882 | |
| 7883 void MarkFromDirtyCardsClosure::do_MemRegion(MemRegion mr) { | |
| 7884 assert(((size_t)mr.start())%CardTableModRefBS::card_size_in_words == 0, | |
| 7885 "mr should be aligned to start at a card boundary"); | |
| 7886 // We'd like to assert: | |
| 7887 // assert(mr.word_size()%CardTableModRefBS::card_size_in_words == 0, | |
| 7888 // "mr should be a range of cards"); | |
| 7889 // However, that would be too strong in one case -- the last | |
| 7890 // partition ends at _unallocated_block which, in general, can be | |
| 7891 // an arbitrary boundary, not necessarily card aligned. | |
| 7892 if (PrintCMSStatistics != 0) { | |
| 7893 _num_dirty_cards += | |
| 7894 mr.word_size()/CardTableModRefBS::card_size_in_words; | |
| 7895 } | |
| 7896 _space->object_iterate_mem(mr, &_scan_cl); | |
| 7897 } | |
| 7898 | |
| 7899 SweepClosure::SweepClosure(CMSCollector* collector, | |
| 7900 ConcurrentMarkSweepGeneration* g, | |
| 7901 CMSBitMap* bitMap, bool should_yield) : | |
| 7902 _collector(collector), | |
| 7903 _g(g), | |
| 7904 _sp(g->cmsSpace()), | |
| 7905 _limit(_sp->sweep_limit()), | |
| 7906 _freelistLock(_sp->freelistLock()), | |
| 7907 _bitMap(bitMap), | |
| 7908 _yield(should_yield), | |
| 7909 _inFreeRange(false), // No free range at beginning of sweep | |
| 7910 _freeRangeInFreeLists(false), // No free range at beginning of sweep | |
| 7911 _lastFreeRangeCoalesced(false), | |
| 7912 _freeFinger(g->used_region().start()) | |
| 7913 { | |
| 7914 NOT_PRODUCT( | |
| 7915 _numObjectsFreed = 0; | |
| 7916 _numWordsFreed = 0; | |
| 7917 _numObjectsLive = 0; | |
| 7918 _numWordsLive = 0; | |
| 7919 _numObjectsAlreadyFree = 0; | |
| 7920 _numWordsAlreadyFree = 0; | |
| 7921 _last_fc = NULL; | |
| 7922 | |
| 7923 _sp->initializeIndexedFreeListArrayReturnedBytes(); | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
7924 _sp->dictionary()->initialize_dict_returned_bytes(); |
| 0 | 7925 ) |
| 7926 assert(_limit >= _sp->bottom() && _limit <= _sp->end(), | |
| 7927 "sweep _limit out of bounds"); | |
| 7928 if (CMSTraceSweeper) { | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7929 gclog_or_tty->print_cr("\n====================\nStarting new sweep with limit " PTR_FORMAT, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7930 _limit); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7931 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7932 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7933 |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7934 void SweepClosure::print_on(outputStream* st) const { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7935 tty->print_cr("_sp = [" PTR_FORMAT "," PTR_FORMAT ")", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7936 _sp->bottom(), _sp->end()); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7937 tty->print_cr("_limit = " PTR_FORMAT, _limit); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7938 tty->print_cr("_freeFinger = " PTR_FORMAT, _freeFinger); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7939 NOT_PRODUCT(tty->print_cr("_last_fc = " PTR_FORMAT, _last_fc);) |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7940 tty->print_cr("_inFreeRange = %d, _freeRangeInFreeLists = %d, _lastFreeRangeCoalesced = %d", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7941 _inFreeRange, _freeRangeInFreeLists, _lastFreeRangeCoalesced); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7942 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7943 |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7944 #ifndef PRODUCT |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7945 // Assertion checking only: no useful work in product mode -- |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7946 // however, if any of the flags below become product flags, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7947 // you may need to review this code to see if it needs to be |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7948 // enabled in product mode. |
| 0 | 7949 SweepClosure::~SweepClosure() { |
| 7950 assert_lock_strong(_freelistLock); | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
7951 assert(_limit >= _sp->bottom() && _limit <= _sp->end(), |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
7952 "sweep _limit out of bounds"); |
| 0 | 7953 if (inFreeRange()) { |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7954 warning("inFreeRange() should have been reset; dumping state of SweepClosure"); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7955 print(); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7956 ShouldNotReachHere(); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7957 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7958 if (Verbose && PrintGC) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7959 gclog_or_tty->print("Collected "SIZE_FORMAT" objects, " SIZE_FORMAT " bytes", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7960 _numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7961 gclog_or_tty->print_cr("\nLive "SIZE_FORMAT" objects, " |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7962 SIZE_FORMAT" bytes " |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7963 "Already free "SIZE_FORMAT" objects, "SIZE_FORMAT" bytes", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7964 _numObjectsLive, _numWordsLive*sizeof(HeapWord), |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7965 _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7966 size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7967 * sizeof(HeapWord); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7968 gclog_or_tty->print_cr("Total sweep: "SIZE_FORMAT" bytes", totalBytes); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7969 |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7970 if (PrintCMSStatistics && CMSVerifyReturnedBytes) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7971 size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
7972 size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes(); |
|
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
7973 size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes; |
|
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
7974 gclog_or_tty->print("Returned "SIZE_FORMAT" bytes", returned_bytes); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7975 gclog_or_tty->print(" Indexed List Returned "SIZE_FORMAT" bytes", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7976 indexListReturnedBytes); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7977 gclog_or_tty->print_cr(" Dictionary Returned "SIZE_FORMAT" bytes", |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
7978 dict_returned_bytes); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7979 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7980 } |
| 0 | 7981 if (CMSTraceSweeper) { |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7982 gclog_or_tty->print_cr("end of sweep with _limit = " PTR_FORMAT "\n================", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7983 _limit); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7984 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7985 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
7986 #endif // PRODUCT |
| 0 | 7987 |
| 7988 void SweepClosure::initialize_free_range(HeapWord* freeFinger, | |
| 7989 bool freeRangeInFreeLists) { | |
| 7990 if (CMSTraceSweeper) { | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
7991 gclog_or_tty->print("---- Start free range at 0x%x with free block (%d)\n", |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
7992 freeFinger, freeRangeInFreeLists); |
| 0 | 7993 } |
| 7994 assert(!inFreeRange(), "Trampling existing free range"); | |
| 7995 set_inFreeRange(true); | |
| 7996 set_lastFreeRangeCoalesced(false); | |
| 7997 | |
| 7998 set_freeFinger(freeFinger); | |
| 7999 set_freeRangeInFreeLists(freeRangeInFreeLists); | |
| 8000 if (CMSTestInFreeList) { | |
| 8001 if (freeRangeInFreeLists) { | |
| 8002 FreeChunk* fc = (FreeChunk*) freeFinger; | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8003 assert(fc->is_free(), "A chunk on the free list should be free."); |
| 0 | 8004 assert(fc->size() > 0, "Free range should have a size"); |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8005 assert(_sp->verify_chunk_in_free_list(fc), "Chunk is not in free lists"); |
| 0 | 8006 } |
| 8007 } | |
| 8008 } | |
| 8009 | |
| 8010 // Note that the sweeper runs concurrently with mutators. Thus, | |
| 8011 // it is possible for direct allocation in this generation to happen | |
| 8012 // in the middle of the sweep. Note that the sweeper also coalesces | |
| 8013 // contiguous free blocks. Thus, unless the sweeper and the allocator | |
| 8014 // synchronize appropriately freshly allocated blocks may get swept up. | |
| 8015 // This is accomplished by the sweeper locking the free lists while | |
| 8016 // it is sweeping. Thus blocks that are determined to be free are | |
| 8017 // indeed free. There is however one additional complication: | |
| 8018 // blocks that have been allocated since the final checkpoint and | |
| 8019 // mark, will not have been marked and so would be treated as | |
| 8020 // unreachable and swept up. To prevent this, the allocator marks | |
| 8021 // the bit map when allocating during the sweep phase. This leads, | |
| 8022 // however, to a further complication -- objects may have been allocated | |
| 8023 // but not yet initialized -- in the sense that the header isn't yet | |
| 8024 // installed. The sweeper can not then determine the size of the block | |
| 8025 // in order to skip over it. To deal with this case, we use a technique | |
| 8026 // (due to Printezis) to encode such uninitialized block sizes in the | |
| 8027 // bit map. Since the bit map uses a bit per every HeapWord, but the | |
| 8028 // CMS generation has a minimum object size of 3 HeapWords, it follows | |
| 8029 // that "normal marks" won't be adjacent in the bit map (there will | |
| 8030 // always be at least two 0 bits between successive 1 bits). We make use | |
| 8031 // of these "unused" bits to represent uninitialized blocks -- the bit | |
| 8032 // corresponding to the start of the uninitialized object and the next | |
| 8033 // bit are both set. Finally, a 1 bit marks the end of the object that | |
| 8034 // started with the two consecutive 1 bits to indicate its potentially | |
| 8035 // uninitialized state. | |
| 8036 | |
| 8037 size_t SweepClosure::do_blk_careful(HeapWord* addr) { | |
| 8038 FreeChunk* fc = (FreeChunk*)addr; | |
| 8039 size_t res; | |
| 8040 | |
|
1720
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8041 // Check if we are done sweeping. Below we check "addr >= _limit" rather |
|
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8042 // than "addr == _limit" because although _limit was a block boundary when |
|
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8043 // we started the sweep, it may no longer be one because heap expansion |
|
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8044 // may have caused us to coalesce the block ending at the address _limit |
|
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8045 // with a newly expanded chunk (this happens when _limit was set to the |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8046 // previous _end of the space), so we may have stepped past _limit: |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8047 // see the following Zeno-like trail of CRs 6977970, 7008136, 7042740. |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8048 if (addr >= _limit) { // we have swept up to or past the limit: finish up |
| 0 | 8049 assert(_limit >= _sp->bottom() && _limit <= _sp->end(), |
| 8050 "sweep _limit out of bounds"); | |
|
1720
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8051 assert(addr < _sp->end(), "addr out of bounds"); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8052 // Flush any free range we might be holding as a single |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8053 // coalesced chunk to the appropriate free list. |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8054 if (inFreeRange()) { |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8055 assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8056 err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", freeFinger())); |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8057 flush_cur_free_chunk(freeFinger(), |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8058 pointer_delta(addr, freeFinger())); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8059 if (CMSTraceSweeper) { |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8060 gclog_or_tty->print("Sweep: last chunk: "); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8061 gclog_or_tty->print("put_free_blk 0x%x ("SIZE_FORMAT") " |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8062 "[coalesced:"SIZE_FORMAT"]\n", |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8063 freeFinger(), pointer_delta(addr, freeFinger()), |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8064 lastFreeRangeCoalesced()); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8065 } |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8066 } |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8067 |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8068 // help the iterator loop finish |
|
1720
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8069 return pointer_delta(_sp->end(), addr); |
|
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8070 } |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8071 |
|
1720
5ed703250bff
6977970: CMS: concurrentMarkSweepGeneration.cpp:7947 assert(addr <= _limit) failed: sweep invariant
ysr
parents:
1716
diff
changeset
|
8072 assert(addr < _limit, "sweep invariant"); |
| 0 | 8073 // check if we should yield |
| 8074 do_yield_check(addr); | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8075 if (fc->is_free()) { |
| 0 | 8076 // Chunk that is already free |
| 8077 res = fc->size(); | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8078 do_already_free_chunk(fc); |
| 0 | 8079 debug_only(_sp->verifyFreeLists()); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8080 // If we flush the chunk at hand in lookahead_and_flush() |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8081 // and it's coalesced with a preceding chunk, then the |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8082 // process of "mangling" the payload of the coalesced block |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8083 // will cause erasure of the size information from the |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8084 // (erstwhile) header of all the coalesced blocks but the |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8085 // first, so the first disjunct in the assert will not hold |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8086 // in that specific case (in which case the second disjunct |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8087 // will hold). |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8088 assert(res == fc->size() || ((HeapWord*)fc) + res >= _limit, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8089 "Otherwise the size info doesn't change at this step"); |
| 0 | 8090 NOT_PRODUCT( |
| 8091 _numObjectsAlreadyFree++; | |
| 8092 _numWordsAlreadyFree += res; | |
| 8093 ) | |
| 8094 NOT_PRODUCT(_last_fc = fc;) | |
| 8095 } else if (!_bitMap->isMarked(addr)) { | |
| 8096 // Chunk is fresh garbage | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8097 res = do_garbage_chunk(fc); |
| 0 | 8098 debug_only(_sp->verifyFreeLists()); |
| 8099 NOT_PRODUCT( | |
| 8100 _numObjectsFreed++; | |
| 8101 _numWordsFreed += res; | |
| 8102 ) | |
| 8103 } else { | |
| 8104 // Chunk that is alive. | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8105 res = do_live_chunk(fc); |
| 0 | 8106 debug_only(_sp->verifyFreeLists()); |
| 8107 NOT_PRODUCT( | |
| 8108 _numObjectsLive++; | |
| 8109 _numWordsLive += res; | |
| 8110 ) | |
| 8111 } | |
| 8112 return res; | |
| 8113 } | |
| 8114 | |
| 8115 // For the smart allocation, record following | |
| 8116 // split deaths - a free chunk is removed from its free list because | |
| 8117 // it is being split into two or more chunks. | |
| 8118 // split birth - a free chunk is being added to its free list because | |
| 8119 // a larger free chunk has been split and resulted in this free chunk. | |
| 8120 // coal death - a free chunk is being removed from its free list because | |
| 8121 // it is being coalesced into a large free chunk. | |
| 8122 // coal birth - a free chunk is being added to its free list because | |
| 8123 // it was created when two or more free chunks where coalesced into | |
| 8124 // this free chunk. | |
| 8125 // | |
| 8126 // These statistics are used to determine the desired number of free | |
| 8127 // chunks of a given size. The desired number is chosen to be relative | |
| 8128 // to the end of a CMS sweep. The desired number at the end of a sweep | |
| 8129 // is the | |
| 8130 // count-at-end-of-previous-sweep (an amount that was enough) | |
| 8131 // - count-at-beginning-of-current-sweep (the excess) | |
| 8132 // + split-births (gains in this size during interval) | |
| 8133 // - split-deaths (demands on this size during interval) | |
| 8134 // where the interval is from the end of one sweep to the end of the | |
| 8135 // next. | |
| 8136 // | |
| 8137 // When sweeping the sweeper maintains an accumulated chunk which is | |
| 8138 // the chunk that is made up of chunks that have been coalesced. That | |
| 8139 // will be termed the left-hand chunk. A new chunk of garbage that | |
| 8140 // is being considered for coalescing will be referred to as the | |
| 8141 // right-hand chunk. | |
| 8142 // | |
| 8143 // When making a decision on whether to coalesce a right-hand chunk with | |
| 8144 // the current left-hand chunk, the current count vs. the desired count | |
| 8145 // of the left-hand chunk is considered. Also if the right-hand chunk | |
| 8146 // is near the large chunk at the end of the heap (see | |
| 8147 // ConcurrentMarkSweepGeneration::isNearLargestChunk()), then the | |
| 8148 // left-hand chunk is coalesced. | |
| 8149 // | |
| 8150 // When making a decision about whether to split a chunk, the desired count | |
| 8151 // vs. the current count of the candidate to be split is also considered. | |
| 8152 // If the candidate is underpopulated (currently fewer chunks than desired) | |
| 8153 // a chunk of an overpopulated (currently more chunks than desired) size may | |
| 8154 // be chosen. The "hint" associated with a free list, if non-null, points | |
| 8155 // to a free list which may be overpopulated. | |
| 8156 // | |
| 8157 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8158 void SweepClosure::do_already_free_chunk(FreeChunk* fc) { |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8159 const size_t size = fc->size(); |
| 0 | 8160 // Chunks that cannot be coalesced are not in the |
| 8161 // free lists. | |
| 8162 if (CMSTestInFreeList && !fc->cantCoalesce()) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8163 assert(_sp->verify_chunk_in_free_list(fc), |
| 0 | 8164 "free chunk should be in free lists"); |
| 8165 } | |
| 8166 // a chunk that is already free, should not have been | |
| 8167 // marked in the bit map | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8168 HeapWord* const addr = (HeapWord*) fc; |
| 0 | 8169 assert(!_bitMap->isMarked(addr), "free chunk should be unmarked"); |
| 8170 // Verify that the bit map has no bits marked between | |
| 8171 // addr and purported end of this block. | |
| 8172 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 8173 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8174 // Some chunks cannot be coalesced under any circumstances. |
| 0 | 8175 // See the definition of cantCoalesce(). |
| 8176 if (!fc->cantCoalesce()) { | |
| 8177 // This chunk can potentially be coalesced. | |
| 8178 if (_sp->adaptive_freelists()) { | |
| 8179 // All the work is done in | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8180 do_post_free_or_garbage_chunk(fc, size); |
| 0 | 8181 } else { // Not adaptive free lists |
| 8182 // this is a free chunk that can potentially be coalesced by the sweeper; | |
| 8183 if (!inFreeRange()) { | |
| 8184 // if the next chunk is a free block that can't be coalesced | |
| 8185 // it doesn't make sense to remove this chunk from the free lists | |
| 8186 FreeChunk* nextChunk = (FreeChunk*)(addr + size); | |
|
2136
c91cc404ca46
7011940: iCMS: SIGSEGV in SweepClosure::do_already_free_chunk(FreeChunk*)+0x360
ysr
parents:
2132
diff
changeset
|
8187 assert((HeapWord*)nextChunk <= _sp->end(), "Chunk size out of bounds?"); |
|
c91cc404ca46
7011940: iCMS: SIGSEGV in SweepClosure::do_already_free_chunk(FreeChunk*)+0x360
ysr
parents:
2132
diff
changeset
|
8188 if ((HeapWord*)nextChunk < _sp->end() && // There is another free chunk to the right ... |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8189 nextChunk->is_free() && // ... which is free... |
|
2136
c91cc404ca46
7011940: iCMS: SIGSEGV in SweepClosure::do_already_free_chunk(FreeChunk*)+0x360
ysr
parents:
2132
diff
changeset
|
8190 nextChunk->cantCoalesce()) { // ... but can't be coalesced |
| 0 | 8191 // nothing to do |
| 8192 } else { | |
| 8193 // Potentially the start of a new free range: | |
| 8194 // Don't eagerly remove it from the free lists. | |
| 8195 // No need to remove it if it will just be put | |
| 8196 // back again. (Also from a pragmatic point of view | |
| 8197 // if it is a free block in a region that is beyond | |
| 8198 // any allocated blocks, an assertion will fail) | |
| 8199 // Remember the start of a free run. | |
| 8200 initialize_free_range(addr, true); | |
| 8201 // end - can coalesce with next chunk | |
| 8202 } | |
| 8203 } else { | |
| 8204 // the midst of a free range, we are coalescing | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8205 print_free_block_coalesced(fc); |
| 0 | 8206 if (CMSTraceSweeper) { |
| 8207 gclog_or_tty->print(" -- pick up free block 0x%x (%d)\n", fc, size); | |
| 8208 } | |
| 8209 // remove it from the free lists | |
| 8210 _sp->removeFreeChunkFromFreeLists(fc); | |
| 8211 set_lastFreeRangeCoalesced(true); | |
| 8212 // If the chunk is being coalesced and the current free range is | |
| 8213 // in the free lists, remove the current free range so that it | |
| 8214 // will be returned to the free lists in its entirety - all | |
| 8215 // the coalesced pieces included. | |
| 8216 if (freeRangeInFreeLists()) { | |
| 8217 FreeChunk* ffc = (FreeChunk*) freeFinger(); | |
| 8218 assert(ffc->size() == pointer_delta(addr, freeFinger()), | |
| 8219 "Size of free range is inconsistent with chunk size."); | |
| 8220 if (CMSTestInFreeList) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8221 assert(_sp->verify_chunk_in_free_list(ffc), |
| 0 | 8222 "free range is not in free lists"); |
| 8223 } | |
| 8224 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 8225 set_freeRangeInFreeLists(false); | |
| 8226 } | |
| 8227 } | |
| 8228 } | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8229 // Note that if the chunk is not coalescable (the else arm |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8230 // below), we unconditionally flush, without needing to do |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8231 // a "lookahead," as we do below. |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8232 if (inFreeRange()) lookahead_and_flush(fc, size); |
| 0 | 8233 } else { |
| 8234 // Code path common to both original and adaptive free lists. | |
| 8235 | |
| 8236 // cant coalesce with previous block; this should be treated | |
| 8237 // as the end of a free run if any | |
| 8238 if (inFreeRange()) { | |
| 8239 // we kicked some butt; time to pick up the garbage | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8240 assert(freeFinger() < addr, "freeFinger points too high"); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8241 flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger())); |
| 0 | 8242 } |
| 8243 // else, nothing to do, just continue | |
| 8244 } | |
| 8245 } | |
| 8246 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8247 size_t SweepClosure::do_garbage_chunk(FreeChunk* fc) { |
| 0 | 8248 // This is a chunk of garbage. It is not in any free list. |
| 8249 // Add it to a free list or let it possibly be coalesced into | |
| 8250 // a larger chunk. | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8251 HeapWord* const addr = (HeapWord*) fc; |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8252 const size_t size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()); |
| 0 | 8253 |
| 8254 if (_sp->adaptive_freelists()) { | |
| 8255 // Verify that the bit map has no bits marked between | |
| 8256 // addr and purported end of just dead object. | |
| 8257 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 8258 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8259 do_post_free_or_garbage_chunk(fc, size); |
| 0 | 8260 } else { |
| 8261 if (!inFreeRange()) { | |
| 8262 // start of a new free range | |
| 8263 assert(size > 0, "A free range should have a size"); | |
| 8264 initialize_free_range(addr, false); | |
| 8265 } else { | |
| 8266 // this will be swept up when we hit the end of the | |
| 8267 // free range | |
| 8268 if (CMSTraceSweeper) { | |
| 8269 gclog_or_tty->print(" -- pick up garbage 0x%x (%d) \n", fc, size); | |
| 8270 } | |
| 8271 // If the chunk is being coalesced and the current free range is | |
| 8272 // in the free lists, remove the current free range so that it | |
| 8273 // will be returned to the free lists in its entirety - all | |
| 8274 // the coalesced pieces included. | |
| 8275 if (freeRangeInFreeLists()) { | |
| 8276 FreeChunk* ffc = (FreeChunk*)freeFinger(); | |
| 8277 assert(ffc->size() == pointer_delta(addr, freeFinger()), | |
| 8278 "Size of free range is inconsistent with chunk size."); | |
| 8279 if (CMSTestInFreeList) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8280 assert(_sp->verify_chunk_in_free_list(ffc), |
| 0 | 8281 "free range is not in free lists"); |
| 8282 } | |
| 8283 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 8284 set_freeRangeInFreeLists(false); | |
| 8285 } | |
| 8286 set_lastFreeRangeCoalesced(true); | |
| 8287 } | |
| 8288 // this will be swept up when we hit the end of the free range | |
| 8289 | |
| 8290 // Verify that the bit map has no bits marked between | |
| 8291 // addr and purported end of just dead object. | |
| 8292 _bitMap->verifyNoOneBitsInRange(addr + 1, addr + size); | |
| 8293 } | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8294 assert(_limit >= addr + size, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8295 "A freshly garbage chunk can't possibly straddle over _limit"); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8296 if (inFreeRange()) lookahead_and_flush(fc, size); |
| 0 | 8297 return size; |
| 8298 } | |
| 8299 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8300 size_t SweepClosure::do_live_chunk(FreeChunk* fc) { |
| 0 | 8301 HeapWord* addr = (HeapWord*) fc; |
| 8302 // The sweeper has just found a live object. Return any accumulated | |
| 8303 // left hand chunk to the free lists. | |
| 8304 if (inFreeRange()) { | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8305 assert(freeFinger() < addr, "freeFinger points too high"); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8306 flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger())); |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8307 } |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8308 |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8309 // This object is live: we'd normally expect this to be |
| 0 | 8310 // an oop, and like to assert the following: |
| 8311 // assert(oop(addr)->is_oop(), "live block should be an oop"); | |
| 8312 // However, as we commented above, this may be an object whose | |
| 8313 // header hasn't yet been initialized. | |
| 8314 size_t size; | |
| 8315 assert(_bitMap->isMarked(addr), "Tautology for this control point"); | |
| 8316 if (_bitMap->isMarked(addr + 1)) { | |
| 8317 // Determine the size from the bit map, rather than trying to | |
| 8318 // compute it from the object header. | |
| 8319 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2); | |
| 8320 size = pointer_delta(nextOneAddr + 1, addr); | |
| 8321 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), | |
| 8322 "alignment problem"); | |
| 8323 | |
| 9152 | 8324 #ifdef ASSERT |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8325 if (oop(addr)->klass_or_null() != NULL) { |
| 0 | 8326 // Ignore mark word because we are running concurrent with mutators |
| 8327 assert(oop(addr)->is_oop(true), "live block should be an oop"); | |
| 8328 assert(size == | |
| 8329 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()), | |
| 8330 "P-mark and computed size do not agree"); | |
| 8331 } | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8332 #endif |
| 0 | 8333 |
| 8334 } else { | |
| 8335 // This should be an initialized object that's alive. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8336 assert(oop(addr)->klass_or_null() != NULL, |
| 0 | 8337 "Should be an initialized object"); |
| 8338 // Ignore mark word because we are running concurrent with mutators | |
| 8339 assert(oop(addr)->is_oop(true), "live block should be an oop"); | |
| 8340 // Verify that the bit map has no bits marked between | |
| 8341 // addr and purported end of this block. | |
| 8342 size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()); | |
| 8343 assert(size >= 3, "Necessary for Printezis marks to work"); | |
| 8344 assert(!_bitMap->isMarked(addr+1), "Tautology for this control point"); | |
| 8345 DEBUG_ONLY(_bitMap->verifyNoOneBitsInRange(addr+2, addr+size);) | |
| 8346 } | |
| 8347 return size; | |
| 8348 } | |
| 8349 | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8350 void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc, |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8351 size_t chunkSize) { |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8352 // do_post_free_or_garbage_chunk() should only be called in the case |
|
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8353 // of the adaptive free list allocator. |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8354 const bool fcInFreeLists = fc->is_free(); |
| 0 | 8355 assert(_sp->adaptive_freelists(), "Should only be used in this case."); |
| 8356 assert((HeapWord*)fc <= _limit, "sweep invariant"); | |
| 8357 if (CMSTestInFreeList && fcInFreeLists) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8358 assert(_sp->verify_chunk_in_free_list(fc), "free chunk is not in free lists"); |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8359 } |
| 0 | 8360 |
| 8361 if (CMSTraceSweeper) { | |
| 8362 gclog_or_tty->print_cr(" -- pick up another chunk at 0x%x (%d)", fc, chunkSize); | |
| 8363 } | |
| 8364 | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8365 HeapWord* const fc_addr = (HeapWord*) fc; |
| 0 | 8366 |
| 8367 bool coalesce; | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8368 const size_t left = pointer_delta(fc_addr, freeFinger()); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8369 const size_t right = chunkSize; |
| 0 | 8370 switch (FLSCoalescePolicy) { |
| 8371 // numeric value forms a coalition aggressiveness metric | |
| 8372 case 0: { // never coalesce | |
| 8373 coalesce = false; | |
| 8374 break; | |
| 8375 } | |
| 8376 case 1: { // coalesce if left & right chunks on overpopulated lists | |
| 8377 coalesce = _sp->coalOverPopulated(left) && | |
| 8378 _sp->coalOverPopulated(right); | |
| 8379 break; | |
| 8380 } | |
| 8381 case 2: { // coalesce if left chunk on overpopulated list (default) | |
| 8382 coalesce = _sp->coalOverPopulated(left); | |
| 8383 break; | |
| 8384 } | |
| 8385 case 3: { // coalesce if left OR right chunk on overpopulated list | |
| 8386 coalesce = _sp->coalOverPopulated(left) || | |
| 8387 _sp->coalOverPopulated(right); | |
| 8388 break; | |
| 8389 } | |
| 8390 case 4: { // always coalesce | |
| 8391 coalesce = true; | |
| 8392 break; | |
| 8393 } | |
| 8394 default: | |
| 8395 ShouldNotReachHere(); | |
| 8396 } | |
| 8397 | |
| 8398 // Should the current free range be coalesced? | |
| 8399 // If the chunk is in a free range and either we decided to coalesce above | |
| 8400 // or the chunk is near the large block at the end of the heap | |
| 8401 // (isNearLargestChunk() returns true), then coalesce this chunk. | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8402 const bool doCoalesce = inFreeRange() |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8403 && (coalesce || _g->isNearLargestChunk(fc_addr)); |
| 0 | 8404 if (doCoalesce) { |
| 8405 // Coalesce the current free range on the left with the new | |
| 8406 // chunk on the right. If either is on a free list, | |
| 8407 // it must be removed from the list and stashed in the closure. | |
| 8408 if (freeRangeInFreeLists()) { | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8409 FreeChunk* const ffc = (FreeChunk*)freeFinger(); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8410 assert(ffc->size() == pointer_delta(fc_addr, freeFinger()), |
| 0 | 8411 "Size of free range is inconsistent with chunk size."); |
| 8412 if (CMSTestInFreeList) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8413 assert(_sp->verify_chunk_in_free_list(ffc), |
| 0 | 8414 "Chunk is not in free lists"); |
| 8415 } | |
| 8416 _sp->coalDeath(ffc->size()); | |
| 8417 _sp->removeFreeChunkFromFreeLists(ffc); | |
| 8418 set_freeRangeInFreeLists(false); | |
| 8419 } | |
| 8420 if (fcInFreeLists) { | |
| 8421 _sp->coalDeath(chunkSize); | |
| 8422 assert(fc->size() == chunkSize, | |
| 8423 "The chunk has the wrong size or is not in the free lists"); | |
| 8424 _sp->removeFreeChunkFromFreeLists(fc); | |
| 8425 } | |
| 8426 set_lastFreeRangeCoalesced(true); | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8427 print_free_block_coalesced(fc); |
| 0 | 8428 } else { // not in a free range and/or should not coalesce |
| 8429 // Return the current free range and start a new one. | |
| 8430 if (inFreeRange()) { | |
| 8431 // In a free range but cannot coalesce with the right hand chunk. | |
| 8432 // Put the current free range into the free lists. | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8433 flush_cur_free_chunk(freeFinger(), |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8434 pointer_delta(fc_addr, freeFinger())); |
| 0 | 8435 } |
| 8436 // Set up for new free range. Pass along whether the right hand | |
| 8437 // chunk is in the free lists. | |
| 8438 initialize_free_range((HeapWord*)fc, fcInFreeLists); | |
| 8439 } | |
| 8440 } | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8441 |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8442 // Lookahead flush: |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8443 // If we are tracking a free range, and this is the last chunk that |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8444 // we'll look at because its end crosses past _limit, we'll preemptively |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8445 // flush it along with any free range we may be holding on to. Note that |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8446 // this can be the case only for an already free or freshly garbage |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8447 // chunk. If this block is an object, it can never straddle |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8448 // over _limit. The "straddling" occurs when _limit is set at |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8449 // the previous end of the space when this cycle started, and |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8450 // a subsequent heap expansion caused the previously co-terminal |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8451 // free block to be coalesced with the newly expanded portion, |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8452 // thus rendering _limit a non-block-boundary making it dangerous |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8453 // for the sweeper to step over and examine. |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8454 void SweepClosure::lookahead_and_flush(FreeChunk* fc, size_t chunk_size) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8455 assert(inFreeRange(), "Should only be called if currently in a free range."); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8456 HeapWord* const eob = ((HeapWord*)fc) + chunk_size; |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8457 assert(_sp->used_region().contains(eob - 1), |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8458 err_msg("eob = " PTR_FORMAT " out of bounds wrt _sp = [" PTR_FORMAT "," PTR_FORMAT ")" |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8459 " when examining fc = " PTR_FORMAT "(" SIZE_FORMAT ")", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8460 _limit, _sp->bottom(), _sp->end(), fc, chunk_size)); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8461 if (eob >= _limit) { |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8462 assert(eob == _limit || fc->is_free(), "Only a free chunk should allow us to cross over the limit"); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8463 if (CMSTraceSweeper) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8464 gclog_or_tty->print_cr("_limit " PTR_FORMAT " reached or crossed by block " |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8465 "[" PTR_FORMAT "," PTR_FORMAT ") in space " |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8466 "[" PTR_FORMAT "," PTR_FORMAT ")", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8467 _limit, fc, eob, _sp->bottom(), _sp->end()); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8468 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8469 // Return the storage we are tracking back into the free lists. |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8470 if (CMSTraceSweeper) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8471 gclog_or_tty->print_cr("Flushing ... "); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8472 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8473 assert(freeFinger() < eob, "Error"); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8474 flush_cur_free_chunk( freeFinger(), pointer_delta(eob, freeFinger())); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8475 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8476 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8477 |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8478 void SweepClosure::flush_cur_free_chunk(HeapWord* chunk, size_t size) { |
| 0 | 8479 assert(inFreeRange(), "Should only be called if currently in a free range."); |
| 8480 assert(size > 0, | |
| 8481 "A zero sized chunk cannot be added to the free lists."); | |
| 8482 if (!freeRangeInFreeLists()) { | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8483 if (CMSTestInFreeList) { |
| 0 | 8484 FreeChunk* fc = (FreeChunk*) chunk; |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8485 fc->set_size(size); |
|
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8486 assert(!_sp->verify_chunk_in_free_list(fc), |
| 0 | 8487 "chunk should not be in free lists yet"); |
| 8488 } | |
| 8489 if (CMSTraceSweeper) { | |
| 8490 gclog_or_tty->print_cr(" -- add free block 0x%x (%d) to free lists", | |
| 8491 chunk, size); | |
| 8492 } | |
| 8493 // A new free range is going to be starting. The current | |
| 8494 // free range has not been added to the free lists yet or | |
| 8495 // was removed so add it back. | |
| 8496 // If the current free range was coalesced, then the death | |
| 8497 // of the free range was recorded. Record a birth now. | |
| 8498 if (lastFreeRangeCoalesced()) { | |
| 8499 _sp->coalBirth(size); | |
| 8500 } | |
| 8501 _sp->addChunkAndRepairOffsetTable(chunk, size, | |
| 8502 lastFreeRangeCoalesced()); | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8503 } else if (CMSTraceSweeper) { |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8504 gclog_or_tty->print_cr("Already in free list: nothing to flush"); |
| 0 | 8505 } |
| 8506 set_inFreeRange(false); | |
| 8507 set_freeRangeInFreeLists(false); | |
| 8508 } | |
| 8509 | |
| 8510 // We take a break if we've been at this for a while, | |
| 8511 // so as to avoid monopolizing the locks involved. | |
| 8512 void SweepClosure::do_yield_work(HeapWord* addr) { | |
| 8513 // Return current free chunk being used for coalescing (if any) | |
| 8514 // to the appropriate freelist. After yielding, the next | |
| 8515 // free block encountered will start a coalescing range of | |
| 8516 // free blocks. If the next free block is adjacent to the | |
| 8517 // chunk just flushed, they will need to wait for the next | |
| 8518 // sweep to be coalesced. | |
| 8519 if (inFreeRange()) { | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1994
diff
changeset
|
8520 flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger())); |
| 0 | 8521 } |
| 8522 | |
| 8523 // First give up the locks, then yield, then re-lock. | |
| 8524 // We should probably use a constructor/destructor idiom to | |
| 8525 // do this unlock/lock or modify the MutexUnlocker class to | |
| 8526 // serve our purpose. XXX | |
| 8527 assert_lock_strong(_bitMap->lock()); | |
| 8528 assert_lock_strong(_freelistLock); | |
| 8529 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), | |
| 8530 "CMS thread should hold CMS token"); | |
| 8531 _bitMap->lock()->unlock(); | |
| 8532 _freelistLock->unlock(); | |
| 8533 ConcurrentMarkSweepThread::desynchronize(true); | |
| 8534 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 8535 _collector->stopTimer(); | |
| 8536 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr()); | |
| 8537 if (PrintCMSStatistics != 0) { | |
| 8538 _collector->incrementYields(); | |
| 8539 } | |
| 8540 _collector->icms_wait(); | |
| 8541 | |
| 8542 // See the comment in coordinator_yield() | |
| 8543 for (unsigned i = 0; i < CMSYieldSleepCount && | |
| 8544 ConcurrentMarkSweepThread::should_yield() && | |
| 8545 !CMSCollector::foregroundGCIsActive(); ++i) { | |
| 8546 os::sleep(Thread::current(), 1, false); | |
| 8547 ConcurrentMarkSweepThread::acknowledge_yield_request(); | |
| 8548 } | |
| 8549 | |
| 8550 ConcurrentMarkSweepThread::synchronize(true); | |
| 8551 _freelistLock->lock(); | |
| 8552 _bitMap->lock()->lock_without_safepoint_check(); | |
| 8553 _collector->startTimer(); | |
| 8554 } | |
| 8555 | |
| 8556 #ifndef PRODUCT | |
| 8557 // This is actually very useful in a product build if it can | |
| 8558 // be called from the debugger. Compile it into the product | |
| 8559 // as needed. | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8560 bool debug_verify_chunk_in_free_list(FreeChunk* fc) { |
|
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
8561 return debug_cms_space->verify_chunk_in_free_list(fc); |
| 0 | 8562 } |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8563 #endif |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8564 |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8565 void SweepClosure::print_free_block_coalesced(FreeChunk* fc) const { |
| 0 | 8566 if (CMSTraceSweeper) { |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8567 gclog_or_tty->print_cr("Sweep:coal_free_blk " PTR_FORMAT " (" SIZE_FORMAT ")", |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8568 fc, fc->size()); |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8569 } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
8570 } |
| 0 | 8571 |
| 8572 // CMSIsAliveClosure | |
| 8573 bool CMSIsAliveClosure::do_object_b(oop obj) { | |
| 8574 HeapWord* addr = (HeapWord*)obj; | |
| 8575 return addr != NULL && | |
| 8576 (!_span.contains(addr) || _bit_map->isMarked(addr)); | |
| 8577 } | |
| 8578 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8579 |
| 935 | 8580 CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector, |
| 8581 MemRegion span, | |
| 8582 CMSBitMap* bit_map, CMSMarkStack* mark_stack, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8583 bool cpc): |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8584 _collector(collector), |
| 935 | 8585 _span(span), |
| 8586 _bit_map(bit_map), | |
| 8587 _mark_stack(mark_stack), | |
| 8588 _concurrent_precleaning(cpc) { | |
| 8589 assert(!_span.is_empty(), "Empty span could spell trouble"); | |
| 8590 } | |
| 8591 | |
| 8592 | |
| 0 | 8593 // CMSKeepAliveClosure: the serial version |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8594 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
|
8595 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8596 if (_span.contains(addr) && |
| 8597 !_bit_map->isMarked(addr)) { | |
| 8598 _bit_map->mark(addr); | |
| 8599 bool simulate_overflow = false; | |
| 8600 NOT_PRODUCT( | |
| 8601 if (CMSMarkStackOverflowALot && | |
| 8602 _collector->simulate_overflow()) { | |
| 8603 // simulate a stack overflow | |
| 8604 simulate_overflow = true; | |
| 8605 } | |
| 8606 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8607 if (simulate_overflow || !_mark_stack->push(obj)) { |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8608 if (_concurrent_precleaning) { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8609 // 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
|
8610 // phase deal with it. |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8611 assert(_collector->overflow_list_is_empty(), "Error"); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8612 // 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
|
8613 // 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
|
8614 // 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
|
8615 // table. |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8616 if (obj->is_objArray()) { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8617 size_t sz = obj->size(); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8618 HeapWord* end_card_addr = |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8619 (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
|
8620 MemRegion redirty_range = MemRegion(addr, end_card_addr); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8621 assert(!redirty_range.is_empty(), "Arithmetical tautology"); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8622 _collector->_modUnionTable.mark_range(redirty_range); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8623 } else { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8624 _collector->_modUnionTable.mark(addr); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8625 } |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8626 _collector->_ser_kac_preclean_ovflw++; |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8627 } else { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8628 _collector->push_on_overflow_list(obj); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8629 _collector->_ser_kac_ovflw++; |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8630 } |
| 0 | 8631 } |
| 8632 } | |
| 8633 } | |
| 8634 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8635 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
|
8636 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
|
8637 |
| 0 | 8638 // CMSParKeepAliveClosure: a parallel version of the above. |
| 8639 // The work queues are private to each closure (thread), | |
| 8640 // 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
|
8641 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
|
8642 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8643 if (_span.contains(addr) && |
| 8644 !_bit_map->isMarked(addr)) { | |
| 8645 // In general, during recursive tracing, several threads | |
| 8646 // may be concurrently getting here; the first one to | |
| 8647 // "tag" it, claims it. | |
| 8648 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
|
8649 bool res = _work_queue->push(obj); |
| 0 | 8650 assert(res, "Low water mark should be much less than capacity"); |
| 8651 // Do a recursive trim in the hope that this will keep | |
| 8652 // stack usage lower, but leave some oops for potential stealers | |
| 8653 trim_queue(_low_water_mark); | |
| 8654 } // Else, another thread got there first | |
| 8655 } | |
| 8656 } | |
| 8657 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8658 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
|
8659 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
|
8660 |
| 0 | 8661 void CMSParKeepAliveClosure::trim_queue(uint max) { |
| 8662 while (_work_queue->size() > max) { | |
| 8663 oop new_oop; | |
| 8664 if (_work_queue->pop_local(new_oop)) { | |
| 8665 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop"); | |
| 8666 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 8667 "no white objects on this stack!"); | |
| 8668 assert(_span.contains((HeapWord*)new_oop), "Out of bounds oop"); | |
| 8669 // iterate over the oops in this oop, marking and pushing | |
| 8670 // the ones in CMS heap (i.e. in _span). | |
| 8671 new_oop->oop_iterate(&_mark_and_push); | |
| 8672 } | |
| 8673 } | |
| 8674 } | |
| 8675 | |
| 935 | 8676 CMSInnerParMarkAndPushClosure::CMSInnerParMarkAndPushClosure( |
| 8677 CMSCollector* collector, | |
| 8678 MemRegion span, CMSBitMap* bit_map, | |
| 8679 OopTaskQueue* work_queue): | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
8680 _collector(collector), |
| 935 | 8681 _span(span), |
| 8682 _bit_map(bit_map), | |
| 8683 _work_queue(work_queue) { } | |
| 8684 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8685 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
|
8686 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8687 if (_span.contains(addr) && |
| 8688 !_bit_map->isMarked(addr)) { | |
| 8689 if (_bit_map->par_mark(addr)) { | |
| 8690 bool simulate_overflow = false; | |
| 8691 NOT_PRODUCT( | |
| 8692 if (CMSMarkStackOverflowALot && | |
| 8693 _collector->par_simulate_overflow()) { | |
| 8694 // simulate a stack overflow | |
| 8695 simulate_overflow = true; | |
| 8696 } | |
| 8697 ) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8698 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
|
8699 _collector->par_push_on_overflow_list(obj); |
| 0 | 8700 _collector->_par_kac_ovflw++; |
| 8701 } | |
| 8702 } // Else another thread got there already | |
| 8703 } | |
| 8704 } | |
| 8705 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8706 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
|
8707 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
|
8708 |
| 0 | 8709 ////////////////////////////////////////////////////////////////// |
| 8710 // CMSExpansionCause ///////////////////////////// | |
| 8711 ////////////////////////////////////////////////////////////////// | |
| 8712 const char* CMSExpansionCause::to_string(CMSExpansionCause::Cause cause) { | |
| 8713 switch (cause) { | |
| 8714 case _no_expansion: | |
| 8715 return "No expansion"; | |
| 8716 case _satisfy_free_ratio: | |
| 8717 return "Free ratio"; | |
| 8718 case _satisfy_promotion: | |
| 8719 return "Satisfy promotion"; | |
| 8720 case _satisfy_allocation: | |
| 8721 return "allocation"; | |
| 8722 case _allocate_par_lab: | |
| 8723 return "Par LAB"; | |
| 8724 case _allocate_par_spooling_space: | |
| 8725 return "Par Spooling Space"; | |
| 8726 case _adaptive_size_policy: | |
| 8727 return "Ergonomics"; | |
| 8728 default: | |
| 8729 return "unknown"; | |
| 8730 } | |
| 8731 } | |
| 8732 | |
| 8733 void CMSDrainMarkingStackClosure::do_void() { | |
| 8734 // the max number to take from overflow list at a time | |
| 8735 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
|
8736 assert(!_concurrent_precleaning || _collector->overflow_list_is_empty(), |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
360
diff
changeset
|
8737 "Overflow list should be NULL during concurrent phases"); |
| 0 | 8738 while (!_mark_stack->isEmpty() || |
| 8739 // if stack is empty, check the overflow list | |
| 8740 _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
|
8741 oop obj = _mark_stack->pop(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
8742 HeapWord* addr = (HeapWord*)obj; |
| 0 | 8743 assert(_span.contains(addr), "Should be within span"); |
| 8744 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
|
8745 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
|
8746 obj->oop_iterate(_keep_alive); |
| 0 | 8747 } |
| 8748 } | |
| 8749 | |
| 8750 void CMSParDrainMarkingStackClosure::do_void() { | |
| 8751 // drain queue | |
| 8752 trim_queue(0); | |
| 8753 } | |
| 8754 | |
| 8755 // Trim our work_queue so its length is below max at return | |
| 8756 void CMSParDrainMarkingStackClosure::trim_queue(uint max) { | |
| 8757 while (_work_queue->size() > max) { | |
| 8758 oop new_oop; | |
| 8759 if (_work_queue->pop_local(new_oop)) { | |
| 8760 assert(new_oop->is_oop(), "Expected an oop"); | |
| 8761 assert(_bit_map->isMarked((HeapWord*)new_oop), | |
| 8762 "no white objects on this stack!"); | |
| 8763 assert(_span.contains((HeapWord*)new_oop), "Out of bounds oop"); | |
| 8764 // iterate over the oops in this oop, marking and pushing | |
| 8765 // the ones in CMS heap (i.e. in _span). | |
| 8766 new_oop->oop_iterate(&_mark_and_push); | |
| 8767 } | |
| 8768 } | |
| 8769 } | |
| 8770 | |
| 8771 //////////////////////////////////////////////////////////////////// | |
| 8772 // Support for Marking Stack Overflow list handling and related code | |
| 8773 //////////////////////////////////////////////////////////////////// | |
| 8774 // Much of the following code is similar in shape and spirit to the | |
| 8775 // code used in ParNewGC. We should try and share that code | |
| 8776 // as much as possible in the future. | |
| 8777 | |
| 8778 #ifndef PRODUCT | |
| 8779 // Debugging support for CMSStackOverflowALot | |
| 8780 | |
| 8781 // It's OK to call this multi-threaded; the worst thing | |
| 8782 // that can happen is that we'll get a bunch of closely | |
| 8783 // spaced simulated oveflows, but that's OK, in fact | |
| 8784 // probably good as it would exercise the overflow code | |
| 8785 // under contention. | |
| 8786 bool CMSCollector::simulate_overflow() { | |
| 8787 if (_overflow_counter-- <= 0) { // just being defensive | |
| 8788 _overflow_counter = CMSMarkStackOverflowInterval; | |
| 8789 return true; | |
| 8790 } else { | |
| 8791 return false; | |
| 8792 } | |
| 8793 } | |
| 8794 | |
| 8795 bool CMSCollector::par_simulate_overflow() { | |
| 8796 return simulate_overflow(); | |
| 8797 } | |
| 8798 #endif | |
| 8799 | |
| 8800 // Single-threaded | |
| 8801 bool CMSCollector::take_from_overflow_list(size_t num, CMSMarkStack* stack) { | |
| 8802 assert(stack->isEmpty(), "Expected precondition"); | |
| 8803 assert(stack->capacity() > num, "Shouldn't bite more than can chew"); | |
| 8804 size_t i = num; | |
| 8805 oop cur = _overflow_list; | |
| 8806 const markOop proto = markOopDesc::prototype(); | |
| 534 | 8807 NOT_PRODUCT(ssize_t n = 0;) |
| 0 | 8808 for (oop next; i > 0 && cur != NULL; cur = next, i--) { |
| 8809 next = oop(cur->mark()); | |
| 8810 cur->set_mark(proto); // until proven otherwise | |
| 8811 assert(cur->is_oop(), "Should be an oop"); | |
| 8812 bool res = stack->push(cur); | |
| 8813 assert(res, "Bit off more than can chew?"); | |
| 8814 NOT_PRODUCT(n++;) | |
| 8815 } | |
| 8816 _overflow_list = cur; | |
| 8817 #ifndef PRODUCT | |
| 8818 assert(_num_par_pushes >= n, "Too many pops?"); | |
| 8819 _num_par_pushes -=n; | |
| 8820 #endif | |
| 8821 return !stack->isEmpty(); | |
| 8822 } | |
| 8823 | |
| 534 | 8824 #define BUSY (oop(0x1aff1aff)) |
| 8825 // (MT-safe) Get a prefix of at most "num" from the list. | |
| 8826 // The overflow list is chained through the mark word of | |
| 8827 // each object in the list. We fetch the entire list, | |
| 8828 // break off a prefix of the right size and return the | |
| 8829 // remainder. If other threads try to take objects from | |
| 8830 // the overflow list at that time, they will wait for | |
| 8831 // some time to see if data becomes available. If (and | |
| 8832 // only if) another thread places one or more object(s) | |
| 8833 // on the global list before we have returned the suffix | |
| 8834 // to the global list, we will walk down our local list | |
| 8835 // to find its end and append the global list to | |
| 8836 // our suffix before returning it. This suffix walk can | |
| 8837 // prove to be expensive (quadratic in the amount of traffic) | |
| 8838 // when there are many objects in the overflow list and | |
| 8839 // there is much producer-consumer contention on the list. | |
| 8840 // *NOTE*: The overflow list manipulation code here and | |
| 8841 // in ParNewGeneration:: are very similar in shape, | |
| 8842 // except that in the ParNew case we use the old (from/eden) | |
| 8843 // copy of the object to thread the list via its klass word. | |
| 8844 // Because of the common code, if you make any changes in | |
| 8845 // the code below, please check the ParNew version to see if | |
| 8846 // similar changes might be needed. | |
| 8847 // CR 6797058 has been filed to consolidate the common code. | |
| 0 | 8848 bool CMSCollector::par_take_from_overflow_list(size_t num, |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
8849 OopTaskQueue* work_q, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
8850 int no_of_gc_threads) { |
| 534 | 8851 assert(work_q->size() == 0, "First empty local work queue"); |
| 0 | 8852 assert(num < work_q->max_elems(), "Can't bite more than we can chew"); |
| 8853 if (_overflow_list == NULL) { | |
| 8854 return false; | |
| 8855 } | |
| 8856 // Grab the entire list; we'll put back a suffix | |
| 534 | 8857 oop prefix = (oop)Atomic::xchg_ptr(BUSY, &_overflow_list); |
| 8858 Thread* tid = Thread::current(); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
8859 // Before "no_of_gc_threads" was introduced CMSOverflowSpinCount was |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
8860 // set to ParallelGCThreads. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1777
diff
changeset
|
8861 size_t CMSOverflowSpinCount = (size_t) no_of_gc_threads; // was ParallelGCThreads; |
| 534 | 8862 size_t sleep_time_millis = MAX2((size_t)1, num/100); |
| 8863 // If the list is busy, we spin for a short while, | |
| 8864 // sleeping between attempts to get the list. | |
| 8865 for (size_t spin = 0; prefix == BUSY && spin < CMSOverflowSpinCount; spin++) { | |
| 8866 os::sleep(tid, sleep_time_millis, false); | |
| 8867 if (_overflow_list == NULL) { | |
| 8868 // Nothing left to take | |
| 8869 return false; | |
| 8870 } else if (_overflow_list != BUSY) { | |
| 8871 // Try and grab the prefix | |
| 8872 prefix = (oop)Atomic::xchg_ptr(BUSY, &_overflow_list); | |
| 8873 } | |
| 8874 } | |
| 8875 // If the list was found to be empty, or we spun long | |
| 8876 // enough, we give up and return empty-handed. If we leave | |
| 8877 // the list in the BUSY state below, it must be the case that | |
| 8878 // some other thread holds the overflow list and will set it | |
| 8879 // to a non-BUSY state in the future. | |
| 8880 if (prefix == NULL || prefix == BUSY) { | |
| 8881 // Nothing to take or waited long enough | |
| 8882 if (prefix == NULL) { | |
| 8883 // Write back the NULL in case we overwrote it with BUSY above | |
| 8884 // and it is still the same value. | |
| 8885 (void) Atomic::cmpxchg_ptr(NULL, &_overflow_list, BUSY); | |
| 8886 } | |
| 8887 return false; | |
| 8888 } | |
| 8889 assert(prefix != NULL && prefix != BUSY, "Error"); | |
| 0 | 8890 size_t i = num; |
| 8891 oop cur = prefix; | |
| 534 | 8892 // Walk down the first "num" objects, unless we reach the end. |
| 0 | 8893 for (; i > 1 && cur->mark() != NULL; cur = oop(cur->mark()), i--); |
| 534 | 8894 if (cur->mark() == NULL) { |
| 8895 // We have "num" or fewer elements in the list, so there | |
| 8896 // is nothing to return to the global list. | |
| 8897 // Write back the NULL in lieu of the BUSY we wrote | |
| 8898 // above, if it is still the same value. | |
| 8899 if (_overflow_list == BUSY) { | |
| 8900 (void) Atomic::cmpxchg_ptr(NULL, &_overflow_list, BUSY); | |
| 8901 } | |
| 8902 } else { | |
| 8903 // Chop off the suffix and rerturn it to the global list. | |
| 8904 assert(cur->mark() != BUSY, "Error"); | |
| 0 | 8905 oop suffix_head = cur->mark(); // suffix will be put back on global list |
| 8906 cur->set_mark(NULL); // break off suffix | |
| 534 | 8907 // It's possible that the list is still in the empty(busy) state |
| 8908 // we left it in a short while ago; in that case we may be | |
| 8909 // able to place back the suffix without incurring the cost | |
| 8910 // of a walk down the list. | |
| 0 | 8911 oop observed_overflow_list = _overflow_list; |
| 534 | 8912 oop cur_overflow_list = observed_overflow_list; |
| 8913 bool attached = false; | |
| 8914 while (observed_overflow_list == BUSY || observed_overflow_list == NULL) { | |
| 0 | 8915 observed_overflow_list = |
| 534 | 8916 (oop) Atomic::cmpxchg_ptr(suffix_head, &_overflow_list, cur_overflow_list); |
| 8917 if (cur_overflow_list == observed_overflow_list) { | |
| 8918 attached = true; | |
| 8919 break; | |
| 8920 } else cur_overflow_list = observed_overflow_list; | |
| 8921 } | |
| 8922 if (!attached) { | |
| 8923 // Too bad, someone else sneaked in (at least) an element; we'll need | |
| 8924 // to do a splice. Find tail of suffix so we can prepend suffix to global | |
| 8925 // list. | |
| 8926 for (cur = suffix_head; cur->mark() != NULL; cur = (oop)(cur->mark())); | |
| 8927 oop suffix_tail = cur; | |
| 8928 assert(suffix_tail != NULL && suffix_tail->mark() == NULL, | |
| 8929 "Tautology"); | |
| 8930 observed_overflow_list = _overflow_list; | |
| 8931 do { | |
| 8932 cur_overflow_list = observed_overflow_list; | |
| 8933 if (cur_overflow_list != BUSY) { | |
| 8934 // Do the splice ... | |
| 8935 suffix_tail->set_mark(markOop(cur_overflow_list)); | |
| 8936 } else { // cur_overflow_list == BUSY | |
| 8937 suffix_tail->set_mark(NULL); | |
| 8938 } | |
| 8939 // ... and try to place spliced list back on overflow_list ... | |
| 8940 observed_overflow_list = | |
| 8941 (oop) Atomic::cmpxchg_ptr(suffix_head, &_overflow_list, cur_overflow_list); | |
| 8942 } while (cur_overflow_list != observed_overflow_list); | |
| 8943 // ... until we have succeeded in doing so. | |
| 8944 } | |
| 0 | 8945 } |
| 8946 | |
| 8947 // Push the prefix elements on work_q | |
| 8948 assert(prefix != NULL, "control point invariant"); | |
| 8949 const markOop proto = markOopDesc::prototype(); | |
| 8950 oop next; | |
| 534 | 8951 NOT_PRODUCT(ssize_t n = 0;) |
| 0 | 8952 for (cur = prefix; cur != NULL; cur = next) { |
| 8953 next = oop(cur->mark()); | |
| 8954 cur->set_mark(proto); // until proven otherwise | |
| 8955 assert(cur->is_oop(), "Should be an oop"); | |
| 8956 bool res = work_q->push(cur); | |
| 8957 assert(res, "Bit off more than we can chew?"); | |
| 8958 NOT_PRODUCT(n++;) | |
| 8959 } | |
| 8960 #ifndef PRODUCT | |
| 8961 assert(_num_par_pushes >= n, "Too many pops?"); | |
| 8962 Atomic::add_ptr(-(intptr_t)n, &_num_par_pushes); | |
| 8963 #endif | |
| 8964 return true; | |
| 8965 } | |
| 8966 | |
| 8967 // Single-threaded | |
| 8968 void CMSCollector::push_on_overflow_list(oop p) { | |
| 8969 NOT_PRODUCT(_num_par_pushes++;) | |
| 8970 assert(p->is_oop(), "Not an oop"); | |
| 8971 preserve_mark_if_necessary(p); | |
| 8972 p->set_mark((markOop)_overflow_list); | |
| 8973 _overflow_list = p; | |
| 8974 } | |
| 8975 | |
| 8976 // Multi-threaded; use CAS to prepend to overflow list | |
| 8977 void CMSCollector::par_push_on_overflow_list(oop p) { | |
| 8978 NOT_PRODUCT(Atomic::inc_ptr(&_num_par_pushes);) | |
| 8979 assert(p->is_oop(), "Not an oop"); | |
| 8980 par_preserve_mark_if_necessary(p); | |
| 8981 oop observed_overflow_list = _overflow_list; | |
| 8982 oop cur_overflow_list; | |
| 8983 do { | |
| 8984 cur_overflow_list = observed_overflow_list; | |
| 534 | 8985 if (cur_overflow_list != BUSY) { |
| 8986 p->set_mark(markOop(cur_overflow_list)); | |
| 8987 } else { | |
| 8988 p->set_mark(NULL); | |
| 8989 } | |
| 0 | 8990 observed_overflow_list = |
| 8991 (oop) Atomic::cmpxchg_ptr(p, &_overflow_list, cur_overflow_list); | |
| 8992 } while (cur_overflow_list != observed_overflow_list); | |
| 8993 } | |
| 534 | 8994 #undef BUSY |
| 0 | 8995 |
| 8996 // Single threaded | |
| 8997 // General Note on GrowableArray: pushes may silently fail | |
| 8998 // because we are (temporarily) out of C-heap for expanding | |
| 8999 // the stack. The problem is quite ubiquitous and affects | |
| 9000 // a lot of code in the JVM. The prudent thing for GrowableArray | |
| 9001 // to do (for now) is to exit with an error. However, that may | |
| 9002 // be too draconian in some cases because the caller may be | |
| 534 | 9003 // able to recover without much harm. For such cases, we |
| 0 | 9004 // should probably introduce a "soft_push" method which returns |
| 9005 // an indication of success or failure with the assumption that | |
| 9006 // the caller may be able to recover from a failure; code in | |
| 9007 // the VM can then be changed, incrementally, to deal with such | |
| 9008 // failures where possible, thus, incrementally hardening the VM | |
| 9009 // in such low resource situations. | |
| 9010 void CMSCollector::preserve_mark_work(oop p, markOop m) { | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9011 _preserved_oop_stack.push(p); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9012 _preserved_mark_stack.push(m); |
| 0 | 9013 assert(m == p->mark(), "Mark word changed"); |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9014 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), |
| 0 | 9015 "bijection"); |
| 9016 } | |
| 9017 | |
| 9018 // Single threaded | |
| 9019 void CMSCollector::preserve_mark_if_necessary(oop p) { | |
| 9020 markOop m = p->mark(); | |
| 9021 if (m->must_be_preserved(p)) { | |
| 9022 preserve_mark_work(p, m); | |
| 9023 } | |
| 9024 } | |
| 9025 | |
| 9026 void CMSCollector::par_preserve_mark_if_necessary(oop p) { | |
| 9027 markOop m = p->mark(); | |
| 9028 if (m->must_be_preserved(p)) { | |
| 9029 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); | |
| 9030 // Even though we read the mark word without holding | |
| 9031 // the lock, we are assured that it will not change | |
| 9032 // because we "own" this oop, so no other thread can | |
| 9033 // be trying to push it on the overflow list; see | |
| 9034 // the assertion in preserve_mark_work() that checks | |
| 9035 // that m == p->mark(). | |
| 9036 preserve_mark_work(p, m); | |
| 9037 } | |
| 9038 } | |
| 9039 | |
| 9040 // We should be able to do this multi-threaded, | |
| 9041 // a chunk of stack being a task (this is | |
| 9042 // correct because each oop only ever appears | |
| 9043 // once in the overflow list. However, it's | |
| 9044 // not very easy to completely overlap this with | |
| 9045 // other operations, so will generally not be done | |
| 9046 // until all work's been completed. Because we | |
| 9047 // expect the preserved oop stack (set) to be small, | |
| 9048 // it's probably fine to do this single-threaded. | |
| 9049 // We can explore cleverer concurrent/overlapped/parallel | |
| 9050 // processing of preserved marks if we feel the | |
| 9051 // need for this in the future. Stack overflow should | |
| 9052 // be so rare in practice and, when it happens, its | |
| 9053 // effect on performance so great that this will | |
| 9054 // likely just be in the noise anyway. | |
| 9055 void CMSCollector::restore_preserved_marks_if_any() { | |
| 9056 assert(SafepointSynchronize::is_at_safepoint(), | |
| 9057 "world should be stopped"); | |
| 9058 assert(Thread::current()->is_ConcurrentGC_thread() || | |
| 9059 Thread::current()->is_VM_thread(), | |
| 9060 "should be single-threaded"); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9061 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9062 "bijection"); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9063 |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9064 while (!_preserved_oop_stack.is_empty()) { |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9065 oop p = _preserved_oop_stack.pop(); |
| 0 | 9066 assert(p->is_oop(), "Should be an oop"); |
| 9067 assert(_span.contains(p), "oop should be in _span"); | |
| 9068 assert(p->mark() == markOopDesc::prototype(), | |
| 9069 "Set when taken from overflow list"); | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9070 markOop m = _preserved_mark_stack.pop(); |
| 0 | 9071 p->set_mark(m); |
| 9072 } | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9073 assert(_preserved_mark_stack.is_empty() && _preserved_oop_stack.is_empty(), |
| 0 | 9074 "stacks were cleared above"); |
| 9075 } | |
| 9076 | |
| 9077 #ifndef PRODUCT | |
| 9078 bool CMSCollector::no_preserved_marks() const { | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
9079 return _preserved_mark_stack.is_empty() && _preserved_oop_stack.is_empty(); |
| 0 | 9080 } |
| 9081 #endif | |
| 9082 | |
| 9083 CMSAdaptiveSizePolicy* ASConcurrentMarkSweepGeneration::cms_size_policy() const | |
| 9084 { | |
| 9085 GenCollectedHeap* gch = (GenCollectedHeap*) GenCollectedHeap::heap(); | |
| 9086 CMSAdaptiveSizePolicy* size_policy = | |
| 9087 (CMSAdaptiveSizePolicy*) gch->gen_policy()->size_policy(); | |
| 9088 assert(size_policy->is_gc_cms_adaptive_size_policy(), | |
| 9089 "Wrong type for size policy"); | |
| 9090 return size_policy; | |
| 9091 } | |
| 9092 | |
| 9093 void ASConcurrentMarkSweepGeneration::resize(size_t cur_promo_size, | |
| 9094 size_t desired_promo_size) { | |
| 9095 if (cur_promo_size < desired_promo_size) { | |
| 9096 size_t expand_bytes = desired_promo_size - cur_promo_size; | |
| 9097 if (PrintAdaptiveSizePolicy && Verbose) { | |
| 9098 gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize " | |
| 9099 "Expanding tenured generation by " SIZE_FORMAT " (bytes)", | |
| 9100 expand_bytes); | |
| 9101 } | |
| 9102 expand(expand_bytes, | |
| 9103 MinHeapDeltaBytes, | |
| 9104 CMSExpansionCause::_adaptive_size_policy); | |
| 9105 } else if (desired_promo_size < cur_promo_size) { | |
| 9106 size_t shrink_bytes = cur_promo_size - desired_promo_size; | |
| 9107 if (PrintAdaptiveSizePolicy && Verbose) { | |
| 9108 gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize " | |
| 9109 "Shrinking tenured generation by " SIZE_FORMAT " (bytes)", | |
| 9110 shrink_bytes); | |
| 9111 } | |
| 9112 shrink(shrink_bytes); | |
| 9113 } | |
| 9114 } | |
| 9115 | |
| 9116 CMSGCAdaptivePolicyCounters* ASConcurrentMarkSweepGeneration::gc_adaptive_policy_counters() { | |
| 9117 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 9118 CMSGCAdaptivePolicyCounters* counters = | |
| 9119 (CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters(); | |
| 9120 assert(counters->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind, | |
| 9121 "Wrong kind of counters"); | |
| 9122 return counters; | |
| 9123 } | |
| 9124 | |
| 9125 | |
| 9126 void ASConcurrentMarkSweepGeneration::update_counters() { | |
| 9127 if (UsePerfData) { | |
| 9128 _space_counters->update_all(); | |
| 9129 _gen_counters->update_all(); | |
| 9130 CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters(); | |
| 9131 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 9132 CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats(); | |
| 9133 assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind, | |
| 9134 "Wrong gc statistics type"); | |
| 9135 counters->update_counters(gc_stats_l); | |
| 9136 } | |
| 9137 } | |
| 9138 | |
| 9139 void ASConcurrentMarkSweepGeneration::update_counters(size_t used) { | |
| 9140 if (UsePerfData) { | |
| 9141 _space_counters->update_used(used); | |
| 9142 _space_counters->update_capacity(); | |
| 9143 _gen_counters->update_all(); | |
| 9144 | |
| 9145 CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters(); | |
| 9146 GenCollectedHeap* gch = GenCollectedHeap::heap(); | |
| 9147 CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats(); | |
| 9148 assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind, | |
| 9149 "Wrong gc statistics type"); | |
| 9150 counters->update_counters(gc_stats_l); | |
| 9151 } | |
| 9152 } | |
| 9153 | |
| 9154 void ASConcurrentMarkSweepGeneration::shrink_by(size_t desired_bytes) { | |
| 9155 assert_locked_or_safepoint(Heap_lock); | |
| 9156 assert_lock_strong(freelistLock()); | |
| 9157 HeapWord* old_end = _cmsSpace->end(); | |
| 9158 HeapWord* unallocated_start = _cmsSpace->unallocated_block(); | |
| 9159 assert(old_end >= unallocated_start, "Miscalculation of unallocated_start"); | |
| 9160 FreeChunk* chunk_at_end = find_chunk_at_end(); | |
| 9161 if (chunk_at_end == NULL) { | |
| 9162 // No room to shrink | |
| 9163 if (PrintGCDetails && Verbose) { | |
| 9164 gclog_or_tty->print_cr("No room to shrink: old_end " | |
| 9165 PTR_FORMAT " unallocated_start " PTR_FORMAT | |
| 9166 " chunk_at_end " PTR_FORMAT, | |
| 9167 old_end, unallocated_start, chunk_at_end); | |
| 9168 } | |
| 9169 return; | |
| 9170 } else { | |
| 9171 | |
| 9172 // Find the chunk at the end of the space and determine | |
| 9173 // how much it can be shrunk. | |
| 9174 size_t shrinkable_size_in_bytes = chunk_at_end->size(); | |
| 9175 size_t aligned_shrinkable_size_in_bytes = | |
| 9176 align_size_down(shrinkable_size_in_bytes, os::vm_page_size()); | |
| 6885 | 9177 assert(unallocated_start <= (HeapWord*) chunk_at_end->end(), |
| 0 | 9178 "Inconsistent chunk at end of space"); |
| 9179 size_t bytes = MIN2(desired_bytes, aligned_shrinkable_size_in_bytes); | |
| 9180 size_t word_size_before = heap_word_size(_virtual_space.committed_size()); | |
| 9181 | |
| 9182 // Shrink the underlying space | |
| 9183 _virtual_space.shrink_by(bytes); | |
| 9184 if (PrintGCDetails && Verbose) { | |
| 9185 gclog_or_tty->print_cr("ConcurrentMarkSweepGeneration::shrink_by:" | |
| 9186 " desired_bytes " SIZE_FORMAT | |
| 9187 " shrinkable_size_in_bytes " SIZE_FORMAT | |
| 9188 " aligned_shrinkable_size_in_bytes " SIZE_FORMAT | |
| 9189 " bytes " SIZE_FORMAT, | |
| 9190 desired_bytes, shrinkable_size_in_bytes, | |
| 9191 aligned_shrinkable_size_in_bytes, bytes); | |
| 9192 gclog_or_tty->print_cr(" old_end " SIZE_FORMAT | |
| 9193 " unallocated_start " SIZE_FORMAT, | |
| 9194 old_end, unallocated_start); | |
| 9195 } | |
| 9196 | |
| 9197 // If the space did shrink (shrinking is not guaranteed), | |
| 9198 // shrink the chunk at the end by the appropriate amount. | |
| 9199 if (((HeapWord*)_virtual_space.high()) < old_end) { | |
| 9200 size_t new_word_size = | |
| 9201 heap_word_size(_virtual_space.committed_size()); | |
| 9202 | |
| 9203 // Have to remove the chunk from the dictionary because it is changing | |
| 9204 // size and might be someplace elsewhere in the dictionary. | |
| 9205 | |
| 9206 // Get the chunk at end, shrink it, and put it | |
| 9207 // back. | |
| 9208 _cmsSpace->removeChunkFromDictionary(chunk_at_end); | |
| 9209 size_t word_size_change = word_size_before - new_word_size; | |
| 9210 size_t chunk_at_end_old_size = chunk_at_end->size(); | |
| 9211 assert(chunk_at_end_old_size >= word_size_change, | |
| 9212 "Shrink is too large"); | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
9213 chunk_at_end->set_size(chunk_at_end_old_size - |
| 0 | 9214 word_size_change); |
| 9215 _cmsSpace->freed((HeapWord*) chunk_at_end->end(), | |
| 9216 word_size_change); | |
| 9217 | |
| 9218 _cmsSpace->returnChunkToDictionary(chunk_at_end); | |
| 9219 | |
| 9220 MemRegion mr(_cmsSpace->bottom(), new_word_size); | |
| 9221 _bts->resize(new_word_size); // resize the block offset shared array | |
| 9222 Universe::heap()->barrier_set()->resize_covered_region(mr); | |
| 9223 _cmsSpace->assert_locked(); | |
| 9224 _cmsSpace->set_end((HeapWord*)_virtual_space.high()); | |
| 9225 | |
| 9226 NOT_PRODUCT(_cmsSpace->dictionary()->verify()); | |
| 9227 | |
| 9228 // update the space and generation capacity counters | |
| 9229 if (UsePerfData) { | |
| 9230 _space_counters->update_capacity(); | |
| 9231 _gen_counters->update_all(); | |
| 9232 } | |
| 9233 | |
| 9234 if (Verbose && PrintGCDetails) { | |
| 9235 size_t new_mem_size = _virtual_space.committed_size(); | |
| 9236 size_t old_mem_size = new_mem_size + bytes; | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6885
diff
changeset
|
9237 gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K", |
| 0 | 9238 name(), old_mem_size/K, bytes/K, new_mem_size/K); |
| 9239 } | |
| 9240 } | |
| 9241 | |
| 9242 assert(_cmsSpace->unallocated_block() <= _cmsSpace->end(), | |
| 9243 "Inconsistency at end of space"); | |
| 6885 | 9244 assert(chunk_at_end->end() == (uintptr_t*) _cmsSpace->end(), |
| 0 | 9245 "Shrinking is inconsistent"); |
| 9246 return; | |
| 9247 } | |
| 9248 } | |
| 9249 | |
| 9250 // Transfer some number of overflown objects to usual marking | |
| 9251 // stack. Return true if some objects were transferred. | |
| 9252 bool MarkRefsIntoAndScanClosure::take_from_overflow_list() { | |
|
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
628
diff
changeset
|
9253 size_t num = MIN2((size_t)(_mark_stack->capacity() - _mark_stack->length())/4, |
| 0 | 9254 (size_t)ParGCDesiredObjsFromOverflowList); |
| 9255 | |
| 9256 bool res = _collector->take_from_overflow_list(num, _mark_stack); | |
| 9257 assert(_collector->overflow_list_is_empty() || res, | |
| 9258 "If list is not empty, we should have taken something"); | |
| 9259 assert(!res || !_mark_stack->isEmpty(), | |
| 9260 "If we took something, it should now be on our stack"); | |
| 9261 return res; | |
| 9262 } | |
| 9263 | |
| 9264 size_t MarkDeadObjectsClosure::do_blk(HeapWord* addr) { | |
| 9265 size_t res = _sp->block_size_no_stall(addr, _collector); | |
| 9266 if (_sp->block_is_obj(addr)) { | |
| 9267 if (_live_bit_map->isMarked(addr)) { | |
| 9268 // It can't have been dead in a previous cycle | |
| 9269 guarantee(!_dead_bit_map->isMarked(addr), "No resurrection!"); | |
| 9270 } else { | |
| 9271 _dead_bit_map->mark(addr); // mark the dead object | |
| 9272 } | |
| 9273 } | |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
9274 // Could be 0, if the block size could not be computed without stalling. |
| 0 | 9275 return res; |
| 9276 } | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9277 |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
9278 TraceCMSMemoryManagerStats::TraceCMSMemoryManagerStats(CMSCollector::CollectorState phase, GCCause::Cause cause): TraceMemoryManagerStats() { |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9279 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9280 switch (phase) { |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9281 case CMSCollector::InitialMarking: |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9282 initialize(true /* fullGC */ , |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
9283 cause /* cause of the GC */, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9284 true /* recordGCBeginTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9285 true /* recordPreGCUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9286 false /* recordPeakUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9287 false /* recordPostGCusage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9288 true /* recordAccumulatedGCTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9289 false /* recordGCEndTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9290 false /* countCollection */ ); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9291 break; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9292 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9293 case CMSCollector::FinalMarking: |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9294 initialize(true /* fullGC */ , |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
9295 cause /* cause of the GC */, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9296 false /* recordGCBeginTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9297 false /* recordPreGCUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9298 false /* recordPeakUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9299 false /* recordPostGCusage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9300 true /* recordAccumulatedGCTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9301 false /* recordGCEndTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9302 false /* countCollection */ ); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9303 break; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9304 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9305 case CMSCollector::Sweeping: |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9306 initialize(true /* fullGC */ , |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3293
diff
changeset
|
9307 cause /* cause of the GC */, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9308 false /* recordGCBeginTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9309 false /* recordPreGCUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9310 true /* recordPeakUsage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9311 true /* recordPostGCusage */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9312 false /* recordAccumulatedGCTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9313 true /* recordGCEndTime */, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9314 true /* countCollection */ ); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9315 break; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9316 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9317 default: |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9318 ShouldNotReachHere(); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9319 } |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9320 } |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1579
diff
changeset
|
9321 |