Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @ 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 | 7b835924c31c |
| children | b06ac540229e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 8035 | 2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP | |
| 27 | |
| 28 #include "gc_implementation/shared/gSpaceCounters.hpp" | |
| 29 #include "gc_implementation/shared/gcStats.hpp" | |
| 30 #include "gc_implementation/shared/generationCounters.hpp" | |
| 6026 | 31 #include "memory/freeBlockDictionary.hpp" |
| 1972 | 32 #include "memory/generation.hpp" |
| 33 #include "runtime/mutexLocker.hpp" | |
| 34 #include "runtime/virtualspace.hpp" | |
| 35 #include "services/memoryService.hpp" | |
| 36 #include "utilities/bitMap.inline.hpp" | |
| 37 #include "utilities/stack.inline.hpp" | |
| 38 #include "utilities/taskqueue.hpp" | |
| 39 #include "utilities/yieldingWorkgroup.hpp" | |
| 40 | |
| 0 | 41 // ConcurrentMarkSweepGeneration is in support of a concurrent |
| 42 // mark-sweep old generation in the Detlefs-Printezis--Boehm-Demers-Schenker | |
| 43 // style. We assume, for now, that this generation is always the | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
44 // seniormost generation and for simplicity |
| 0 | 45 // in the first implementation, that this generation is a single compactible |
| 46 // space. Neither of these restrictions appears essential, and will be | |
| 47 // relaxed in the future when more time is available to implement the | |
| 48 // greater generality (and there's a need for it). | |
| 49 // | |
| 50 // Concurrent mode failures are currently handled by | |
| 51 // means of a sliding mark-compact. | |
| 52 | |
| 53 class CMSAdaptiveSizePolicy; | |
| 54 class CMSConcMarkingTask; | |
| 55 class CMSGCAdaptivePolicyCounters; | |
| 56 class ConcurrentMarkSweepGeneration; | |
| 57 class ConcurrentMarkSweepPolicy; | |
| 58 class ConcurrentMarkSweepThread; | |
| 59 class CompactibleFreeListSpace; | |
| 60 class FreeChunk; | |
| 61 class PromotionInfo; | |
| 62 class ScanMarkedObjectsAgainCarefullyClosure; | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
63 class TenuredGeneration; |
| 0 | 64 |
| 65 // A generic CMS bit map. It's the basis for both the CMS marking bit map | |
| 66 // as well as for the mod union table (in each case only a subset of the | |
| 67 // methods are used). This is essentially a wrapper around the BitMap class, | |
| 68 // with one bit per (1<<_shifter) HeapWords. (i.e. for the marking bit map, | |
| 69 // we have _shifter == 0. and for the mod union table we have | |
| 70 // shifter == CardTableModRefBS::card_shift - LogHeapWordSize.) | |
| 71 // XXX 64-bit issues in BitMap? | |
| 72 class CMSBitMap VALUE_OBJ_CLASS_SPEC { | |
| 73 friend class VMStructs; | |
| 74 | |
| 75 HeapWord* _bmStartWord; // base address of range covered by map | |
| 76 size_t _bmWordSize; // map size (in #HeapWords covered) | |
| 77 const int _shifter; // shifts to convert HeapWord to bit position | |
| 78 VirtualSpace _virtual_space; // underlying the bit map | |
| 79 BitMap _bm; // the bit map itself | |
| 80 public: | |
| 81 Mutex* const _lock; // mutex protecting _bm; | |
| 82 | |
| 83 public: | |
| 84 // constructor | |
| 85 CMSBitMap(int shifter, int mutex_rank, const char* mutex_name); | |
| 86 | |
| 87 // allocates the actual storage for the map | |
| 88 bool allocate(MemRegion mr); | |
| 89 // field getter | |
| 90 Mutex* lock() const { return _lock; } | |
| 91 // locking verifier convenience function | |
| 92 void assert_locked() const PRODUCT_RETURN; | |
| 93 | |
| 94 // inquiries | |
| 95 HeapWord* startWord() const { return _bmStartWord; } | |
| 96 size_t sizeInWords() const { return _bmWordSize; } | |
| 97 size_t sizeInBits() const { return _bm.size(); } | |
| 98 // the following is one past the last word in space | |
| 99 HeapWord* endWord() const { return _bmStartWord + _bmWordSize; } | |
| 100 | |
| 101 // reading marks | |
| 102 bool isMarked(HeapWord* addr) const; | |
| 103 bool par_isMarked(HeapWord* addr) const; // do not lock checks | |
| 104 bool isUnmarked(HeapWord* addr) const; | |
| 105 bool isAllClear() const; | |
| 106 | |
| 107 // writing marks | |
| 108 void mark(HeapWord* addr); | |
| 109 // For marking by parallel GC threads; | |
| 110 // returns true if we did, false if another thread did | |
| 111 bool par_mark(HeapWord* addr); | |
| 112 | |
| 113 void mark_range(MemRegion mr); | |
| 114 void par_mark_range(MemRegion mr); | |
| 115 void mark_large_range(MemRegion mr); | |
| 116 void par_mark_large_range(MemRegion mr); | |
| 117 void par_clear(HeapWord* addr); // For unmarking by parallel GC threads. | |
| 118 void clear_range(MemRegion mr); | |
| 119 void par_clear_range(MemRegion mr); | |
| 120 void clear_large_range(MemRegion mr); | |
| 121 void par_clear_large_range(MemRegion mr); | |
| 122 void clear_all(); | |
| 123 void clear_all_incrementally(); // Not yet implemented!! | |
| 124 | |
| 125 NOT_PRODUCT( | |
| 126 // checks the memory region for validity | |
| 127 void region_invariant(MemRegion mr); | |
| 128 ) | |
| 129 | |
| 130 // iteration | |
| 131 void iterate(BitMapClosure* cl) { | |
| 132 _bm.iterate(cl); | |
| 133 } | |
| 134 void iterate(BitMapClosure* cl, HeapWord* left, HeapWord* right); | |
| 135 void dirty_range_iterate_clear(MemRegionClosure* cl); | |
| 136 void dirty_range_iterate_clear(MemRegion mr, MemRegionClosure* cl); | |
| 137 | |
| 138 // auxiliary support for iteration | |
| 139 HeapWord* getNextMarkedWordAddress(HeapWord* addr) const; | |
| 140 HeapWord* getNextMarkedWordAddress(HeapWord* start_addr, | |
| 141 HeapWord* end_addr) const; | |
| 142 HeapWord* getNextUnmarkedWordAddress(HeapWord* addr) const; | |
| 143 HeapWord* getNextUnmarkedWordAddress(HeapWord* start_addr, | |
| 144 HeapWord* end_addr) const; | |
| 145 MemRegion getAndClearMarkedRegion(HeapWord* addr); | |
| 146 MemRegion getAndClearMarkedRegion(HeapWord* start_addr, | |
| 147 HeapWord* end_addr); | |
| 148 | |
| 149 // conversion utilities | |
| 150 HeapWord* offsetToHeapWord(size_t offset) const; | |
| 151 size_t heapWordToOffset(HeapWord* addr) const; | |
| 152 size_t heapWordDiffToOffsetDiff(size_t diff) const; | |
| 153 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
154 void 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
|
155 |
| 0 | 156 // debugging |
| 157 // is this address range covered by the bit-map? | |
| 158 NOT_PRODUCT( | |
| 159 bool covers(MemRegion mr) const; | |
| 160 bool covers(HeapWord* start, size_t size = 0) const; | |
| 161 ) | |
| 162 void verifyNoOneBitsInRange(HeapWord* left, HeapWord* right) PRODUCT_RETURN; | |
| 163 }; | |
| 164 | |
| 165 // Represents a marking stack used by the CMS collector. | |
| 166 // Ideally this should be GrowableArray<> just like MSC's marking stack(s). | |
| 6197 | 167 class CMSMarkStack: public CHeapObj<mtGC> { |
| 0 | 168 // |
| 169 friend class CMSCollector; // to get at expasion stats further below | |
| 170 // | |
| 171 | |
| 172 VirtualSpace _virtual_space; // space for the stack | |
| 173 oop* _base; // bottom of stack | |
| 174 size_t _index; // one more than last occupied index | |
| 175 size_t _capacity; // max #elements | |
| 176 Mutex _par_lock; // an advisory lock used in case of parallel access | |
| 177 NOT_PRODUCT(size_t _max_depth;) // max depth plumbed during run | |
| 178 | |
| 179 protected: | |
| 180 size_t _hit_limit; // we hit max stack size limit | |
| 181 size_t _failed_double; // we failed expansion before hitting limit | |
| 182 | |
| 183 public: | |
| 184 CMSMarkStack(): | |
| 185 _par_lock(Mutex::event, "CMSMarkStack._par_lock", true), | |
| 186 _hit_limit(0), | |
| 187 _failed_double(0) {} | |
| 188 | |
| 189 bool allocate(size_t size); | |
| 190 | |
| 191 size_t capacity() const { return _capacity; } | |
| 192 | |
| 193 oop pop() { | |
| 194 if (!isEmpty()) { | |
| 195 return _base[--_index] ; | |
| 196 } | |
| 197 return NULL; | |
| 198 } | |
| 199 | |
| 200 bool push(oop ptr) { | |
| 201 if (isFull()) { | |
| 202 return false; | |
| 203 } else { | |
| 204 _base[_index++] = ptr; | |
| 205 NOT_PRODUCT(_max_depth = MAX2(_max_depth, _index)); | |
| 206 return true; | |
| 207 } | |
| 208 } | |
| 209 | |
| 210 bool isEmpty() const { return _index == 0; } | |
| 211 bool isFull() const { | |
| 212 assert(_index <= _capacity, "buffer overflow"); | |
| 213 return _index == _capacity; | |
| 214 } | |
| 215 | |
| 216 size_t length() { return _index; } | |
| 217 | |
| 218 // "Parallel versions" of some of the above | |
| 219 oop par_pop() { | |
| 220 // lock and pop | |
| 221 MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag); | |
| 222 return pop(); | |
| 223 } | |
| 224 | |
| 225 bool par_push(oop ptr) { | |
| 226 // lock and push | |
| 227 MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag); | |
| 228 return push(ptr); | |
| 229 } | |
| 230 | |
| 231 // Forcibly reset the stack, losing all of its contents. | |
| 232 void reset() { | |
| 233 _index = 0; | |
| 234 } | |
| 235 | |
| 236 // Expand the stack, typically in response to an overflow condition | |
| 237 void expand(); | |
| 238 | |
| 239 // Compute the least valued stack element. | |
| 240 oop least_value(HeapWord* low) { | |
| 241 oop least = (oop)low; | |
| 242 for (size_t i = 0; i < _index; i++) { | |
| 243 least = MIN2(least, _base[i]); | |
| 244 } | |
| 245 return least; | |
| 246 } | |
| 247 | |
| 248 // Exposed here to allow stack expansion in || case | |
| 249 Mutex* par_lock() { return &_par_lock; } | |
| 250 }; | |
| 251 | |
| 252 class CardTableRS; | |
| 253 class CMSParGCThreadState; | |
| 254 | |
| 255 class ModUnionClosure: public MemRegionClosure { | |
| 256 protected: | |
| 257 CMSBitMap* _t; | |
| 258 public: | |
| 259 ModUnionClosure(CMSBitMap* t): _t(t) { } | |
| 260 void do_MemRegion(MemRegion mr); | |
| 261 }; | |
| 262 | |
| 263 class ModUnionClosurePar: public ModUnionClosure { | |
| 264 public: | |
| 265 ModUnionClosurePar(CMSBitMap* t): ModUnionClosure(t) { } | |
| 266 void do_MemRegion(MemRegion mr); | |
| 267 }; | |
| 268 | |
| 269 // Survivor Chunk Array in support of parallelization of | |
| 270 // Survivor Space rescan. | |
| 6197 | 271 class ChunkArray: public CHeapObj<mtGC> { |
| 0 | 272 size_t _index; |
| 273 size_t _capacity; | |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
274 size_t _overflows; |
| 0 | 275 HeapWord** _array; // storage for array |
| 276 | |
| 277 public: | |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
278 ChunkArray() : _index(0), _capacity(0), _overflows(0), _array(NULL) {} |
| 0 | 279 ChunkArray(HeapWord** a, size_t c): |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
280 _index(0), _capacity(c), _overflows(0), _array(a) {} |
| 0 | 281 |
| 282 HeapWord** array() { return _array; } | |
| 283 void set_array(HeapWord** a) { _array = a; } | |
| 284 | |
| 285 size_t capacity() { return _capacity; } | |
| 286 void set_capacity(size_t c) { _capacity = c; } | |
| 287 | |
| 288 size_t end() { | |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
289 assert(_index <= capacity(), |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
290 err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT "): out of bounds", |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
291 _index, _capacity)); |
| 0 | 292 return _index; |
| 293 } // exclusive | |
| 294 | |
| 295 HeapWord* nth(size_t n) { | |
| 296 assert(n < end(), "Out of bounds access"); | |
| 297 return _array[n]; | |
| 298 } | |
| 299 | |
| 300 void reset() { | |
| 301 _index = 0; | |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
302 if (_overflows > 0 && PrintCMSStatistics > 1) { |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
303 warning("CMS: ChunkArray[" SIZE_FORMAT "] overflowed " SIZE_FORMAT " times", |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
304 _capacity, _overflows); |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
305 } |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
306 _overflows = 0; |
| 0 | 307 } |
| 308 | |
| 309 void record_sample(HeapWord* p, size_t sz) { | |
| 310 // For now we do not do anything with the size | |
| 311 if (_index < _capacity) { | |
| 312 _array[_index++] = p; | |
|
1753
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
313 } else { |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
314 ++_overflows; |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
315 assert(_index == _capacity, |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
316 err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
317 "): out of bounds at overflow#" SIZE_FORMAT, |
|
bba76f745fe6
6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents:
1716
diff
changeset
|
318 _index, _capacity, _overflows)); |
| 0 | 319 } |
| 320 } | |
| 321 }; | |
| 322 | |
| 323 // | |
| 324 // Timing, allocation and promotion statistics for gc scheduling and incremental | |
| 325 // mode pacing. Most statistics are exponential averages. | |
| 326 // | |
| 327 class CMSStats VALUE_OBJ_CLASS_SPEC { | |
| 328 private: | |
| 329 ConcurrentMarkSweepGeneration* const _cms_gen; // The cms (old) gen. | |
| 330 | |
| 331 // The following are exponential averages with factor alpha: | |
| 332 // avg = (100 - alpha) * avg + alpha * cur_sample | |
| 333 // | |
| 334 // The durations measure: end_time[n] - start_time[n] | |
| 335 // The periods measure: start_time[n] - start_time[n-1] | |
| 336 // | |
| 337 // The cms period and duration include only concurrent collections; time spent | |
| 338 // in foreground cms collections due to System.gc() or because of a failure to | |
| 339 // keep up are not included. | |
| 340 // | |
| 341 // There are 3 alphas to "bootstrap" the statistics. The _saved_alpha is the | |
| 342 // real value, but is used only after the first period. A value of 100 is | |
| 343 // used for the first sample so it gets the entire weight. | |
| 344 unsigned int _saved_alpha; // 0-100 | |
| 345 unsigned int _gc0_alpha; | |
| 346 unsigned int _cms_alpha; | |
| 347 | |
| 348 double _gc0_duration; | |
| 349 double _gc0_period; | |
| 350 size_t _gc0_promoted; // bytes promoted per gc0 | |
| 351 double _cms_duration; | |
| 352 double _cms_duration_pre_sweep; // time from initiation to start of sweep | |
| 353 double _cms_duration_per_mb; | |
| 354 double _cms_period; | |
| 355 size_t _cms_allocated; // bytes of direct allocation per gc0 period | |
| 356 | |
| 357 // Timers. | |
| 358 elapsedTimer _cms_timer; | |
| 359 TimeStamp _gc0_begin_time; | |
| 360 TimeStamp _cms_begin_time; | |
| 361 TimeStamp _cms_end_time; | |
| 362 | |
| 363 // Snapshots of the amount used in the CMS generation. | |
| 364 size_t _cms_used_at_gc0_begin; | |
| 365 size_t _cms_used_at_gc0_end; | |
| 366 size_t _cms_used_at_cms_begin; | |
| 367 | |
| 368 // Used to prevent the duty cycle from being reduced in the middle of a cms | |
| 369 // cycle. | |
| 370 bool _allow_duty_cycle_reduction; | |
| 371 | |
| 372 enum { | |
| 373 _GC0_VALID = 0x1, | |
| 374 _CMS_VALID = 0x2, | |
| 375 _ALL_VALID = _GC0_VALID | _CMS_VALID | |
| 376 }; | |
| 377 | |
| 378 unsigned int _valid_bits; | |
| 379 | |
| 380 unsigned int _icms_duty_cycle; // icms duty cycle (0-100). | |
| 381 | |
| 382 protected: | |
| 383 | |
| 384 // Return a duty cycle that avoids wild oscillations, by limiting the amount | |
| 385 // of change between old_duty_cycle and new_duty_cycle (the latter is treated | |
| 386 // as a recommended value). | |
| 387 static unsigned int icms_damped_duty_cycle(unsigned int old_duty_cycle, | |
| 388 unsigned int new_duty_cycle); | |
| 389 unsigned int icms_update_duty_cycle_impl(); | |
| 390 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
391 // In support of adjusting of cms trigger ratios based on history |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
392 // of concurrent mode failure. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
393 double cms_free_adjustment_factor(size_t free) const; |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
394 void adjust_cms_free_adjustment_factor(bool fail, size_t free); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
395 |
| 0 | 396 public: |
| 397 CMSStats(ConcurrentMarkSweepGeneration* cms_gen, | |
| 398 unsigned int alpha = CMSExpAvgFactor); | |
| 399 | |
| 400 // Whether or not the statistics contain valid data; higher level statistics | |
| 401 // cannot be called until this returns true (they require at least one young | |
| 402 // gen and one cms cycle to have completed). | |
| 403 bool valid() const; | |
| 404 | |
| 405 // Record statistics. | |
| 406 void record_gc0_begin(); | |
| 407 void record_gc0_end(size_t cms_gen_bytes_used); | |
| 408 void record_cms_begin(); | |
| 409 void record_cms_end(); | |
| 410 | |
| 411 // Allow management of the cms timer, which must be stopped/started around | |
| 412 // yield points. | |
| 413 elapsedTimer& cms_timer() { return _cms_timer; } | |
| 414 void start_cms_timer() { _cms_timer.start(); } | |
| 415 void stop_cms_timer() { _cms_timer.stop(); } | |
| 416 | |
| 417 // Basic statistics; units are seconds or bytes. | |
| 418 double gc0_period() const { return _gc0_period; } | |
| 419 double gc0_duration() const { return _gc0_duration; } | |
| 420 size_t gc0_promoted() const { return _gc0_promoted; } | |
| 421 double cms_period() const { return _cms_period; } | |
| 422 double cms_duration() const { return _cms_duration; } | |
| 423 double cms_duration_per_mb() const { return _cms_duration_per_mb; } | |
| 424 size_t cms_allocated() const { return _cms_allocated; } | |
| 425 | |
| 426 size_t cms_used_at_gc0_end() const { return _cms_used_at_gc0_end;} | |
| 427 | |
| 428 // Seconds since the last background cms cycle began or ended. | |
| 429 double cms_time_since_begin() const; | |
| 430 double cms_time_since_end() const; | |
| 431 | |
| 432 // Higher level statistics--caller must check that valid() returns true before | |
| 433 // calling. | |
| 434 | |
| 435 // Returns bytes promoted per second of wall clock time. | |
| 436 double promotion_rate() const; | |
| 437 | |
| 438 // Returns bytes directly allocated per second of wall clock time. | |
| 439 double cms_allocation_rate() const; | |
| 440 | |
| 441 // Rate at which space in the cms generation is being consumed (sum of the | |
| 442 // above two). | |
| 443 double cms_consumption_rate() const; | |
| 444 | |
| 445 // Returns an estimate of the number of seconds until the cms generation will | |
| 446 // fill up, assuming no collection work is done. | |
| 447 double time_until_cms_gen_full() const; | |
| 448 | |
| 449 // Returns an estimate of the number of seconds remaining until | |
| 450 // the cms generation collection should start. | |
| 451 double time_until_cms_start() const; | |
| 452 | |
| 453 // End of higher level statistics. | |
| 454 | |
| 455 // Returns the cms incremental mode duty cycle, as a percentage (0-100). | |
| 456 unsigned int icms_duty_cycle() const { return _icms_duty_cycle; } | |
| 457 | |
| 458 // Update the duty cycle and return the new value. | |
| 459 unsigned int icms_update_duty_cycle(); | |
| 460 | |
| 461 // Debugging. | |
| 462 void print_on(outputStream* st) const PRODUCT_RETURN; | |
| 463 void print() const { print_on(gclog_or_tty); } | |
| 464 }; | |
| 465 | |
| 466 // A closure related to weak references processing which | |
| 467 // we embed in the CMSCollector, since we need to pass | |
| 468 // it to the reference processor for secondary filtering | |
| 469 // of references based on reachability of referent; | |
| 470 // see role of _is_alive_non_header closure in the | |
| 471 // ReferenceProcessor class. | |
| 472 // For objects in the CMS generation, this closure checks | |
| 473 // if the object is "live" (reachable). Used in weak | |
| 474 // reference processing. | |
| 475 class CMSIsAliveClosure: public BoolObjectClosure { | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
476 const MemRegion _span; |
| 0 | 477 const CMSBitMap* _bit_map; |
| 478 | |
| 479 friend class CMSCollector; | |
| 480 public: | |
| 481 CMSIsAliveClosure(MemRegion span, | |
| 482 CMSBitMap* bit_map): | |
| 483 _span(span), | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
484 _bit_map(bit_map) { |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
485 assert(!span.is_empty(), "Empty span could spell trouble"); |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
486 } |
|
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
487 |
| 0 | 488 void do_object(oop obj) { |
| 489 assert(false, "not to be invoked"); | |
| 490 } | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
491 |
| 0 | 492 bool do_object_b(oop obj); |
| 493 }; | |
| 494 | |
| 495 | |
| 496 // Implements AbstractRefProcTaskExecutor for CMS. | |
| 497 class CMSRefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
| 498 public: | |
| 499 | |
| 500 CMSRefProcTaskExecutor(CMSCollector& collector) | |
| 501 : _collector(collector) | |
| 502 { } | |
| 503 | |
| 504 // Executes a task using worker threads. | |
| 505 virtual void execute(ProcessTask& task); | |
| 506 virtual void execute(EnqueueTask& task); | |
| 507 private: | |
| 508 CMSCollector& _collector; | |
| 509 }; | |
| 510 | |
| 511 | |
| 6197 | 512 class CMSCollector: public CHeapObj<mtGC> { |
| 0 | 513 friend class VMStructs; |
| 514 friend class ConcurrentMarkSweepThread; | |
| 515 friend class ConcurrentMarkSweepGeneration; | |
| 516 friend class CompactibleFreeListSpace; | |
| 517 friend class CMSParRemarkTask; | |
| 518 friend class CMSConcMarkingTask; | |
| 519 friend class CMSRefProcTaskProxy; | |
| 520 friend class CMSRefProcTaskExecutor; | |
| 521 friend class ScanMarkedObjectsAgainCarefullyClosure; // for sampling eden | |
| 522 friend class SurvivorSpacePrecleanClosure; // --- ditto ------- | |
| 523 friend class PushOrMarkClosure; // to access _restart_addr | |
| 524 friend class Par_PushOrMarkClosure; // to access _restart_addr | |
| 525 friend class MarkFromRootsClosure; // -- ditto -- | |
| 526 // ... and for clearing cards | |
| 527 friend class Par_MarkFromRootsClosure; // to access _restart_addr | |
| 528 // ... and for clearing cards | |
| 529 friend class Par_ConcMarkingClosure; // to access _restart_addr etc. | |
| 530 friend class MarkFromRootsVerifyClosure; // to access _restart_addr | |
| 531 friend class PushAndMarkVerifyClosure; // -- ditto -- | |
| 532 friend class MarkRefsIntoAndScanClosure; // to access _overflow_list | |
| 533 friend class PushAndMarkClosure; // -- ditto -- | |
| 534 friend class Par_PushAndMarkClosure; // -- ditto -- | |
| 535 friend class CMSKeepAliveClosure; // -- ditto -- | |
| 536 friend class CMSDrainMarkingStackClosure; // -- ditto -- | |
| 537 friend class CMSInnerParMarkAndPushClosure; // -- ditto -- | |
| 538 NOT_PRODUCT(friend class ScanMarkedObjectsAgainClosure;) // assertion on _overflow_list | |
| 539 friend class ReleaseForegroundGC; // to access _foregroundGCShouldWait | |
| 540 friend class VM_CMS_Operation; | |
| 541 friend class VM_CMS_Initial_Mark; | |
| 542 friend class VM_CMS_Final_Remark; | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
543 friend class TraceCMSMemoryManagerStats; |
| 0 | 544 |
| 545 private: | |
| 546 jlong _time_of_last_gc; | |
| 547 void update_time_of_last_gc(jlong now) { | |
| 548 _time_of_last_gc = now; | |
| 549 } | |
| 550 | |
| 551 OopTaskQueueSet* _task_queues; | |
| 552 | |
| 553 // Overflow list of grey objects, threaded through mark-word | |
| 554 // Manipulated with CAS in the parallel/multi-threaded case. | |
| 555 oop _overflow_list; | |
| 556 // The following array-pair keeps track of mark words | |
| 557 // displaced for accomodating overflow list above. | |
| 558 // This code will likely be revisited under RFE#4922830. | |
| 6197 | 559 Stack<oop, mtGC> _preserved_oop_stack; |
| 560 Stack<markOop, mtGC> _preserved_mark_stack; | |
| 0 | 561 |
| 562 int* _hash_seed; | |
| 563 | |
| 564 // In support of multi-threaded concurrent phases | |
| 565 YieldingFlexibleWorkGang* _conc_workers; | |
| 566 | |
| 567 // Performance Counters | |
| 568 CollectorCounters* _gc_counters; | |
| 569 | |
| 570 // Initialization Errors | |
| 571 bool _completed_initialization; | |
| 572 | |
| 573 // In support of ExplicitGCInvokesConcurrent | |
| 574 static bool _full_gc_requested; | |
| 575 unsigned int _collection_count_start; | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
576 |
| 0 | 577 // Should we unload classes this concurrent cycle? |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
578 bool _should_unload_classes; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
579 unsigned int _concurrent_cycles_since_last_unload; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
580 unsigned int concurrent_cycles_since_last_unload() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
581 return _concurrent_cycles_since_last_unload; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
582 } |
| 0 | 583 // Did we (allow) unload classes in the previous concurrent cycle? |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
584 bool unloaded_classes_last_cycle() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
585 return concurrent_cycles_since_last_unload() == 0; |
| 0 | 586 } |
|
798
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
579
diff
changeset
|
587 // Root scanning options for perm gen |
|
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
579
diff
changeset
|
588 int _roots_scanning_options; |
|
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
579
diff
changeset
|
589 int roots_scanning_options() const { return _roots_scanning_options; } |
|
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
579
diff
changeset
|
590 void add_root_scanning_option(int o) { _roots_scanning_options |= o; } |
|
fe1574da39fc
6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents:
579
diff
changeset
|
591 void remove_root_scanning_option(int o) { _roots_scanning_options &= ~o; } |
| 0 | 592 |
| 593 // Verification support | |
| 594 CMSBitMap _verification_mark_bm; | |
| 595 void verify_after_remark_work_1(); | |
| 596 void verify_after_remark_work_2(); | |
| 597 | |
| 598 // true if any verification flag is on. | |
| 599 bool _verifying; | |
| 600 bool verifying() const { return _verifying; } | |
| 601 void set_verifying(bool v) { _verifying = v; } | |
| 602 | |
| 603 // Collector policy | |
| 604 ConcurrentMarkSweepPolicy* _collector_policy; | |
| 605 ConcurrentMarkSweepPolicy* collector_policy() { return _collector_policy; } | |
| 606 | |
| 607 // XXX Move these to CMSStats ??? FIX ME !!! | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
608 elapsedTimer _inter_sweep_timer; // time between sweeps |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
609 elapsedTimer _intra_sweep_timer; // time _in_ sweeps |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
610 // padded decaying average estimates of the above |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
611 AdaptivePaddedAverage _inter_sweep_estimate; |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
612 AdaptivePaddedAverage _intra_sweep_estimate; |
| 0 | 613 |
| 614 protected: | |
| 615 ConcurrentMarkSweepGeneration* _cmsGen; // old gen (CMS) | |
| 616 MemRegion _span; // span covering above two | |
| 617 CardTableRS* _ct; // card table | |
| 618 | |
| 619 // CMS marking support structures | |
| 620 CMSBitMap _markBitMap; | |
| 621 CMSBitMap _modUnionTable; | |
| 622 CMSMarkStack _markStack; | |
| 623 | |
| 624 HeapWord* _restart_addr; // in support of marking stack overflow | |
| 625 void lower_restart_addr(HeapWord* low); | |
| 626 | |
| 627 // Counters in support of marking stack / work queue overflow handling: | |
| 628 // a non-zero value indicates certain types of overflow events during | |
| 629 // the current CMS cycle and could lead to stack resizing efforts at | |
| 630 // an opportune future time. | |
| 631 size_t _ser_pmc_preclean_ovflw; | |
| 632 size_t _ser_pmc_remark_ovflw; | |
| 633 size_t _par_pmc_remark_ovflw; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
634 size_t _ser_kac_preclean_ovflw; |
| 0 | 635 size_t _ser_kac_ovflw; |
| 636 size_t _par_kac_ovflw; | |
| 534 | 637 NOT_PRODUCT(ssize_t _num_par_pushes;) |
| 0 | 638 |
| 639 // ("Weak") Reference processing support | |
| 640 ReferenceProcessor* _ref_processor; | |
| 641 CMSIsAliveClosure _is_alive_closure; | |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
642 // keep this textually after _markBitMap and _span; c'tor dependency |
| 0 | 643 |
| 644 ConcurrentMarkSweepThread* _cmsThread; // the thread doing the work | |
| 645 ModUnionClosure _modUnionClosure; | |
| 646 ModUnionClosurePar _modUnionClosurePar; | |
| 647 | |
| 648 // CMS abstract state machine | |
| 649 // initial_state: Idling | |
| 650 // next_state(Idling) = {Marking} | |
| 651 // next_state(Marking) = {Precleaning, Sweeping} | |
| 652 // next_state(Precleaning) = {AbortablePreclean, FinalMarking} | |
| 653 // next_state(AbortablePreclean) = {FinalMarking} | |
| 654 // next_state(FinalMarking) = {Sweeping} | |
| 655 // next_state(Sweeping) = {Resizing} | |
| 656 // next_state(Resizing) = {Resetting} | |
| 657 // next_state(Resetting) = {Idling} | |
| 658 // The numeric values below are chosen so that: | |
| 659 // . _collectorState <= Idling == post-sweep && pre-mark | |
| 660 // . _collectorState in (Idling, Sweeping) == {initial,final}marking || | |
| 661 // precleaning || abortablePrecleanb | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
662 public: |
| 0 | 663 enum CollectorState { |
| 664 Resizing = 0, | |
| 665 Resetting = 1, | |
| 666 Idling = 2, | |
| 667 InitialMarking = 3, | |
| 668 Marking = 4, | |
| 669 Precleaning = 5, | |
| 670 AbortablePreclean = 6, | |
| 671 FinalMarking = 7, | |
| 672 Sweeping = 8 | |
| 673 }; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
674 protected: |
| 0 | 675 static CollectorState _collectorState; |
| 676 | |
| 677 // State related to prologue/epilogue invocation for my generations | |
| 678 bool _between_prologue_and_epilogue; | |
| 679 | |
| 680 // Signalling/State related to coordination between fore- and backgroud GC | |
| 681 // Note: When the baton has been passed from background GC to foreground GC, | |
| 682 // _foregroundGCIsActive is true and _foregroundGCShouldWait is false. | |
| 683 static bool _foregroundGCIsActive; // true iff foreground collector is active or | |
| 684 // wants to go active | |
| 685 static bool _foregroundGCShouldWait; // true iff background GC is active and has not | |
| 686 // yet passed the baton to the foreground GC | |
| 687 | |
| 688 // Support for CMSScheduleRemark (abortable preclean) | |
| 689 bool _abort_preclean; | |
| 690 bool _start_sampling; | |
| 691 | |
| 692 int _numYields; | |
| 693 size_t _numDirtyCards; | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
694 size_t _sweep_count; |
| 0 | 695 // number of full gc's since the last concurrent gc. |
| 696 uint _full_gcs_since_conc_gc; | |
| 697 | |
| 698 // occupancy used for bootstrapping stats | |
| 699 double _bootstrap_occupancy; | |
| 700 | |
| 701 // timer | |
| 702 elapsedTimer _timer; | |
| 703 | |
| 704 // Timing, allocation and promotion statistics, used for scheduling. | |
| 705 CMSStats _stats; | |
| 706 | |
| 707 // Allocation limits installed in the young gen, used only in | |
| 708 // CMSIncrementalMode. When an allocation in the young gen would cross one of | |
| 709 // these limits, the cms generation is notified and the cms thread is started | |
| 710 // or stopped, respectively. | |
| 711 HeapWord* _icms_start_limit; | |
| 712 HeapWord* _icms_stop_limit; | |
| 713 | |
| 714 enum CMS_op_type { | |
| 715 CMS_op_checkpointRootsInitial, | |
| 716 CMS_op_checkpointRootsFinal | |
| 717 }; | |
| 718 | |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6026
diff
changeset
|
719 void do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause); |
| 0 | 720 bool stop_world_and_do(CMS_op_type op); |
| 721 | |
| 722 OopTaskQueueSet* task_queues() { return _task_queues; } | |
| 723 int* hash_seed(int i) { return &_hash_seed[i]; } | |
| 724 YieldingFlexibleWorkGang* conc_workers() { return _conc_workers; } | |
| 725 | |
| 726 // Support for parallelizing Eden rescan in CMS remark phase | |
| 727 void sample_eden(); // ... sample Eden space top | |
| 728 | |
| 729 private: | |
| 730 // Support for parallelizing young gen rescan in CMS remark phase | |
| 731 Generation* _young_gen; // the younger gen | |
| 732 HeapWord** _top_addr; // ... Top of Eden | |
| 733 HeapWord** _end_addr; // ... End of Eden | |
| 734 HeapWord** _eden_chunk_array; // ... Eden partitioning array | |
| 735 size_t _eden_chunk_index; // ... top (exclusive) of array | |
| 736 size_t _eden_chunk_capacity; // ... max entries in array | |
| 737 | |
| 738 // Support for parallelizing survivor space rescan | |
| 739 HeapWord** _survivor_chunk_array; | |
| 740 size_t _survivor_chunk_index; | |
| 741 size_t _survivor_chunk_capacity; | |
| 742 size_t* _cursor; | |
| 743 ChunkArray* _survivor_plab_array; | |
| 744 | |
| 745 // Support for marking stack overflow handling | |
| 746 bool take_from_overflow_list(size_t num, CMSMarkStack* to_stack); | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1753
diff
changeset
|
747 bool par_take_from_overflow_list(size_t num, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1753
diff
changeset
|
748 OopTaskQueue* to_work_q, |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1753
diff
changeset
|
749 int no_of_gc_threads); |
| 0 | 750 void push_on_overflow_list(oop p); |
| 751 void par_push_on_overflow_list(oop p); | |
| 752 // the following is, obviously, not, in general, "MT-stable" | |
| 753 bool overflow_list_is_empty() const; | |
| 754 | |
| 755 void preserve_mark_if_necessary(oop p); | |
| 756 void par_preserve_mark_if_necessary(oop p); | |
| 757 void preserve_mark_work(oop p, markOop m); | |
| 758 void restore_preserved_marks_if_any(); | |
| 759 NOT_PRODUCT(bool no_preserved_marks() const;) | |
| 760 // in support of testing overflow code | |
| 761 NOT_PRODUCT(int _overflow_counter;) | |
| 762 NOT_PRODUCT(bool simulate_overflow();) // sequential | |
| 763 NOT_PRODUCT(bool par_simulate_overflow();) // MT version | |
| 764 | |
| 765 // CMS work methods | |
| 766 void checkpointRootsInitialWork(bool asynch); // initial checkpoint work | |
| 767 | |
| 768 // a return value of false indicates failure due to stack overflow | |
| 769 bool markFromRootsWork(bool asynch); // concurrent marking work | |
| 770 | |
| 771 public: // FIX ME!!! only for testing | |
| 772 bool do_marking_st(bool asynch); // single-threaded marking | |
| 773 bool do_marking_mt(bool asynch); // multi-threaded marking | |
| 774 | |
| 775 private: | |
| 776 | |
| 777 // concurrent precleaning work | |
| 778 size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen, | |
| 779 ScanMarkedObjectsAgainCarefullyClosure* cl); | |
| 780 size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen, | |
| 781 ScanMarkedObjectsAgainCarefullyClosure* cl); | |
| 782 // Does precleaning work, returning a quantity indicative of | |
| 783 // the amount of "useful work" done. | |
| 784 size_t preclean_work(bool clean_refs, bool clean_survivors); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
785 void preclean_klasses(MarkRefsIntoAndScanClosure* cl, Mutex* freelistLock); |
| 0 | 786 void abortable_preclean(); // Preclean while looking for possible abort |
| 787 void initialize_sequential_subtasks_for_young_gen_rescan(int i); | |
| 788 // Helper function for above; merge-sorts the per-thread plab samples | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1753
diff
changeset
|
789 void merge_survivor_plab_arrays(ContiguousSpace* surv, int no_of_gc_threads); |
| 0 | 790 // Resets (i.e. clears) the per-thread plab sample vectors |
| 791 void reset_survivor_plab_arrays(); | |
| 792 | |
| 793 // final (second) checkpoint work | |
| 794 void checkpointRootsFinalWork(bool asynch, bool clear_all_soft_refs, | |
| 795 bool init_mark_was_synchronous); | |
| 796 // work routine for parallel version of remark | |
| 797 void do_remark_parallel(); | |
| 798 // work routine for non-parallel version of remark | |
| 799 void do_remark_non_parallel(); | |
| 800 // reference processing work routine (during second checkpoint) | |
| 801 void refProcessingWork(bool asynch, bool clear_all_soft_refs); | |
| 802 | |
| 803 // concurrent sweeping work | |
| 804 void sweepWork(ConcurrentMarkSweepGeneration* gen, bool asynch); | |
| 805 | |
| 806 // (concurrent) resetting of support data structures | |
| 807 void reset(bool asynch); | |
| 808 | |
| 809 // Clear _expansion_cause fields of constituent generations | |
| 810 void clear_expansion_cause(); | |
| 811 | |
| 812 // An auxilliary method used to record the ends of | |
| 813 // used regions of each generation to limit the extent of sweep | |
| 814 void save_sweep_limits(); | |
| 815 | |
| 816 // A work method used by foreground collection to determine | |
| 817 // what type of collection (compacting or not, continuing or fresh) | |
| 818 // it should do. | |
| 819 void decide_foreground_collection_type(bool clear_all_soft_refs, | |
| 820 bool* should_compact, bool* should_start_over); | |
| 821 | |
| 822 // A work method used by the foreground collector to do | |
| 823 // a mark-sweep-compact. | |
| 824 void do_compaction_work(bool clear_all_soft_refs); | |
| 825 | |
| 826 // A work method used by the foreground collector to do | |
| 827 // a mark-sweep, after taking over from a possibly on-going | |
| 828 // concurrent mark-sweep collection. | |
| 829 void do_mark_sweep_work(bool clear_all_soft_refs, | |
| 830 CollectorState first_state, bool should_start_over); | |
| 831 | |
| 832 // If the backgrould GC is active, acquire control from the background | |
| 833 // GC and do the collection. | |
| 834 void acquire_control_and_collect(bool full, bool clear_all_soft_refs); | |
| 835 | |
| 836 // For synchronizing passing of control from background to foreground | |
| 837 // GC. waitForForegroundGC() is called by the background | |
| 838 // collector. It if had to wait for a foreground collection, | |
| 839 // it returns true and the background collection should assume | |
| 840 // that the collection was finished by the foreground | |
| 841 // collector. | |
| 842 bool waitForForegroundGC(); | |
| 843 | |
| 844 // Incremental mode triggering: recompute the icms duty cycle and set the | |
| 845 // allocation limits in the young gen. | |
| 846 void icms_update_allocation_limits(); | |
| 847 | |
| 848 size_t block_size_using_printezis_bits(HeapWord* addr) const; | |
| 849 size_t block_size_if_printezis_bits(HeapWord* addr) const; | |
| 850 HeapWord* next_card_start_after_block(HeapWord* addr) const; | |
| 851 | |
| 852 void setup_cms_unloading_and_verification_state(); | |
| 853 public: | |
| 854 CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, | |
| 855 CardTableRS* ct, | |
| 856 ConcurrentMarkSweepPolicy* cp); | |
| 857 ConcurrentMarkSweepThread* cmsThread() { return _cmsThread; } | |
| 858 | |
| 859 ReferenceProcessor* ref_processor() { return _ref_processor; } | |
| 860 void ref_processor_init(); | |
| 861 | |
| 862 Mutex* bitMapLock() const { return _markBitMap.lock(); } | |
| 863 static CollectorState abstract_state() { return _collectorState; } | |
| 864 | |
| 865 bool should_abort_preclean() const; // Whether preclean should be aborted. | |
| 866 size_t get_eden_used() const; | |
| 867 size_t get_eden_capacity() const; | |
| 868 | |
| 869 ConcurrentMarkSweepGeneration* cmsGen() { return _cmsGen; } | |
| 870 | |
| 871 // locking checks | |
| 872 NOT_PRODUCT(static bool have_cms_token();) | |
| 873 | |
| 874 // XXXPERM bool should_collect(bool full, size_t size, bool tlab); | |
| 875 bool shouldConcurrentCollect(); | |
| 876 | |
| 877 void collect(bool full, | |
| 878 bool clear_all_soft_refs, | |
| 879 size_t size, | |
| 880 bool tlab); | |
| 881 void collect_in_background(bool clear_all_soft_refs); | |
| 882 void collect_in_foreground(bool clear_all_soft_refs); | |
| 883 | |
| 884 // In support of ExplicitGCInvokesConcurrent | |
| 885 static void request_full_gc(unsigned int full_gc_count); | |
| 886 // Should we unload classes in a particular concurrent cycle? | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
887 bool should_unload_classes() const { |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
888 return _should_unload_classes; |
| 0 | 889 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
890 void update_should_unload_classes(); |
| 0 | 891 |
| 892 void direct_allocated(HeapWord* start, size_t size); | |
| 893 | |
| 894 // Object is dead if not marked and current phase is sweeping. | |
| 895 bool is_dead_obj(oop obj) const; | |
| 896 | |
| 897 // After a promotion (of "start"), do any necessary marking. | |
| 898 // If "par", then it's being done by a parallel GC thread. | |
| 899 // The last two args indicate if we need precise marking | |
| 900 // and if so the size of the object so it can be dirtied | |
| 901 // in its entirety. | |
| 902 void promoted(bool par, HeapWord* start, | |
| 903 bool is_obj_array, size_t obj_size); | |
| 904 | |
| 905 HeapWord* allocation_limit_reached(Space* space, HeapWord* top, | |
| 906 size_t word_size); | |
| 907 | |
| 908 void getFreelistLocks() const; | |
| 909 void releaseFreelistLocks() const; | |
| 910 bool haveFreelistLocks() const; | |
| 911 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
912 // Adjust size of underlying generation |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
913 void compute_new_size(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
914 |
| 0 | 915 // GC prologue and epilogue |
| 916 void gc_prologue(bool full); | |
| 917 void gc_epilogue(bool full); | |
| 918 | |
| 919 jlong time_of_last_gc(jlong now) { | |
| 920 if (_collectorState <= Idling) { | |
| 921 // gc not in progress | |
| 922 return _time_of_last_gc; | |
| 923 } else { | |
| 924 // collection in progress | |
| 925 return now; | |
| 926 } | |
| 927 } | |
| 928 | |
| 929 // Support for parallel remark of survivor space | |
| 930 void* get_data_recorder(int thr_num); | |
| 931 | |
| 932 CMSBitMap* markBitMap() { return &_markBitMap; } | |
| 933 void directAllocated(HeapWord* start, size_t size); | |
| 934 | |
| 935 // main CMS steps and related support | |
| 936 void checkpointRootsInitial(bool asynch); | |
| 937 bool markFromRoots(bool asynch); // a return value of false indicates failure | |
| 938 // due to stack overflow | |
| 939 void preclean(); | |
| 940 void checkpointRootsFinal(bool asynch, bool clear_all_soft_refs, | |
| 941 bool init_mark_was_synchronous); | |
| 942 void sweep(bool asynch); | |
| 943 | |
| 944 // Check that the currently executing thread is the expected | |
| 945 // one (foreground collector or background collector). | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
946 static void check_correct_thread_executing() PRODUCT_RETURN; |
| 0 | 947 // XXXPERM void print_statistics() PRODUCT_RETURN; |
| 948 | |
| 949 bool is_cms_reachable(HeapWord* addr); | |
| 950 | |
| 951 // Performance Counter Support | |
| 952 CollectorCounters* counters() { return _gc_counters; } | |
| 953 | |
| 954 // timer stuff | |
| 955 void startTimer() { assert(!_timer.is_active(), "Error"); _timer.start(); } | |
| 956 void stopTimer() { assert( _timer.is_active(), "Error"); _timer.stop(); } | |
| 957 void resetTimer() { assert(!_timer.is_active(), "Error"); _timer.reset(); } | |
| 958 double timerValue() { assert(!_timer.is_active(), "Error"); return _timer.seconds(); } | |
| 959 | |
| 960 int yields() { return _numYields; } | |
| 961 void resetYields() { _numYields = 0; } | |
| 962 void incrementYields() { _numYields++; } | |
| 963 void resetNumDirtyCards() { _numDirtyCards = 0; } | |
| 964 void incrementNumDirtyCards(size_t num) { _numDirtyCards += num; } | |
| 965 size_t numDirtyCards() { return _numDirtyCards; } | |
| 966 | |
| 967 static bool foregroundGCShouldWait() { return _foregroundGCShouldWait; } | |
| 968 static void set_foregroundGCShouldWait(bool v) { _foregroundGCShouldWait = v; } | |
| 969 static bool foregroundGCIsActive() { return _foregroundGCIsActive; } | |
| 970 static void set_foregroundGCIsActive(bool v) { _foregroundGCIsActive = v; } | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
971 size_t sweep_count() const { return _sweep_count; } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
972 void increment_sweep_count() { _sweep_count++; } |
| 0 | 973 |
| 974 // Timers/stats for gc scheduling and incremental mode pacing. | |
| 975 CMSStats& stats() { return _stats; } | |
| 976 | |
| 977 // Convenience methods that check whether CMSIncrementalMode is enabled and | |
| 978 // forward to the corresponding methods in ConcurrentMarkSweepThread. | |
| 979 static void start_icms(); | |
| 980 static void stop_icms(); // Called at the end of the cms cycle. | |
| 981 static void disable_icms(); // Called before a foreground collection. | |
| 982 static void enable_icms(); // Called after a foreground collection. | |
| 983 void icms_wait(); // Called at yield points. | |
| 984 | |
| 985 // Adaptive size policy | |
| 986 CMSAdaptiveSizePolicy* size_policy(); | |
| 987 CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters(); | |
| 988 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
989 static void print_on_error(outputStream* st); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
9072
diff
changeset
|
990 |
| 0 | 991 // debugging |
| 6008 | 992 void verify(); |
| 0 | 993 bool verify_after_remark(); |
| 994 void verify_ok_to_terminate() const PRODUCT_RETURN; | |
| 995 void verify_work_stacks_empty() const PRODUCT_RETURN; | |
| 996 void verify_overflow_empty() const PRODUCT_RETURN; | |
| 997 | |
| 998 // convenience methods in support of debugging | |
| 999 static const size_t skip_header_HeapWords() PRODUCT_RETURN0; | |
| 1000 HeapWord* block_start(const void* p) const PRODUCT_RETURN0; | |
| 1001 | |
| 1002 // accessors | |
| 1003 CMSMarkStack* verification_mark_stack() { return &_markStack; } | |
| 1004 CMSBitMap* verification_mark_bm() { return &_verification_mark_bm; } | |
| 1005 | |
| 1006 // Initialization errors | |
| 1007 bool completed_initialization() { return _completed_initialization; } | |
| 1008 }; | |
| 1009 | |
| 1010 class CMSExpansionCause : public AllStatic { | |
| 1011 public: | |
| 1012 enum Cause { | |
| 1013 _no_expansion, | |
| 1014 _satisfy_free_ratio, | |
| 1015 _satisfy_promotion, | |
| 1016 _satisfy_allocation, | |
| 1017 _allocate_par_lab, | |
| 1018 _allocate_par_spooling_space, | |
| 1019 _adaptive_size_policy | |
| 1020 }; | |
| 1021 // Return a string describing the cause of the expansion. | |
| 1022 static const char* to_string(CMSExpansionCause::Cause cause); | |
| 1023 }; | |
| 1024 | |
| 1025 class ConcurrentMarkSweepGeneration: public CardGeneration { | |
| 1026 friend class VMStructs; | |
| 1027 friend class ConcurrentMarkSweepThread; | |
| 1028 friend class ConcurrentMarkSweep; | |
| 1029 friend class CMSCollector; | |
| 1030 protected: | |
| 1031 static CMSCollector* _collector; // the collector that collects us | |
| 1032 CompactibleFreeListSpace* _cmsSpace; // underlying space (only one for now) | |
| 1033 | |
| 1034 // Performance Counters | |
| 1035 GenerationCounters* _gen_counters; | |
| 1036 GSpaceCounters* _space_counters; | |
| 1037 | |
| 1038 // Words directly allocated, used by CMSStats. | |
| 1039 size_t _direct_allocated_words; | |
| 1040 | |
| 1041 // Non-product stat counters | |
| 1042 NOT_PRODUCT( | |
|
1716
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1703
diff
changeset
|
1043 size_t _numObjectsPromoted; |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1703
diff
changeset
|
1044 size_t _numWordsPromoted; |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1703
diff
changeset
|
1045 size_t _numObjectsAllocated; |
|
be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents:
1703
diff
changeset
|
1046 size_t _numWordsAllocated; |
| 0 | 1047 ) |
| 1048 | |
| 1049 // Used for sizing decisions | |
| 1050 bool _incremental_collection_failed; | |
| 1051 bool incremental_collection_failed() { | |
| 1052 return _incremental_collection_failed; | |
| 1053 } | |
| 1054 void set_incremental_collection_failed() { | |
| 1055 _incremental_collection_failed = true; | |
| 1056 } | |
| 1057 void clear_incremental_collection_failed() { | |
| 1058 _incremental_collection_failed = false; | |
| 1059 } | |
| 1060 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1061 // accessors |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1062 void set_expansion_cause(CMSExpansionCause::Cause v) { _expansion_cause = v;} |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1063 CMSExpansionCause::Cause expansion_cause() const { return _expansion_cause; } |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1064 |
| 0 | 1065 private: |
| 1066 // For parallel young-gen GC support. | |
| 1067 CMSParGCThreadState** _par_gc_thread_states; | |
| 1068 | |
| 1069 // Reason generation was expanded | |
| 1070 CMSExpansionCause::Cause _expansion_cause; | |
| 1071 | |
| 1072 // In support of MinChunkSize being larger than min object size | |
| 1073 const double _dilatation_factor; | |
| 1074 | |
| 1075 enum CollectionTypes { | |
| 1076 Concurrent_collection_type = 0, | |
| 1077 MS_foreground_collection_type = 1, | |
| 1078 MSC_foreground_collection_type = 2, | |
| 1079 Unknown_collection_type = 3 | |
| 1080 }; | |
| 1081 | |
| 1082 CollectionTypes _debug_collection_type; | |
| 1083 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1084 // Fraction of current occupancy at which to start a CMS collection which |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1085 // will collect this generation (at least). |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1086 double _initiating_occupancy; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1087 |
| 0 | 1088 protected: |
| 1089 // Shrink generation by specified size (returns false if unable to shrink) | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1090 void shrink_free_list_by(size_t bytes); |
| 0 | 1091 |
| 1092 // Update statistics for GC | |
| 1093 virtual void update_gc_stats(int level, bool full); | |
| 1094 | |
| 1095 // Maximum available space in the generation (including uncommitted) | |
| 1096 // space. | |
| 1097 size_t max_available() const; | |
| 1098 | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1099 // getter and initializer for _initiating_occupancy field. |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1100 double initiating_occupancy() const { return _initiating_occupancy; } |
| 8035 | 1101 void init_initiating_occupancy(intx io, uintx tr); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1102 |
| 0 | 1103 public: |
| 1104 ConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size, | |
| 1105 int level, CardTableRS* ct, | |
| 1106 bool use_adaptive_freelists, | |
| 6026 | 1107 FreeBlockDictionary<FreeChunk>::DictionaryChoice); |
| 0 | 1108 |
| 1109 // Accessors | |
| 1110 CMSCollector* collector() const { return _collector; } | |
| 1111 static void set_collector(CMSCollector* collector) { | |
| 1112 assert(_collector == NULL, "already set"); | |
| 1113 _collector = collector; | |
| 1114 } | |
| 1115 CompactibleFreeListSpace* cmsSpace() const { return _cmsSpace; } | |
| 1116 | |
| 1117 Mutex* freelistLock() const; | |
| 1118 | |
| 1119 virtual Generation::Name kind() { return Generation::ConcurrentMarkSweep; } | |
| 1120 | |
| 1121 // Adaptive size policy | |
| 1122 CMSAdaptiveSizePolicy* size_policy(); | |
| 1123 | |
| 1124 bool refs_discovery_is_atomic() const { return false; } | |
| 1125 bool refs_discovery_is_mt() const { | |
| 1126 // Note: CMS does MT-discovery during the parallel-remark | |
| 1127 // phases. Use ReferenceProcessorMTMutator to make refs | |
| 1128 // discovery MT-safe during such phases or other parallel | |
| 1129 // discovery phases in the future. This may all go away | |
| 1130 // if/when we decide that refs discovery is sufficiently | |
| 1131 // rare that the cost of the CAS's involved is in the | |
| 1132 // noise. That's a measurement that should be done, and | |
| 1133 // the code simplified if that turns out to be the case. | |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2132
diff
changeset
|
1134 return ConcGCThreads > 1; |
| 0 | 1135 } |
| 1136 | |
| 1137 // Override | |
| 1138 virtual void ref_processor_init(); | |
| 1139 | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1140 // Grow generation by specified size (returns false if unable to grow) |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1141 bool grow_by(size_t bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1142 // Grow generation to reserved size. |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1143 bool grow_to_reserved(); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1144 |
| 0 | 1145 void clear_expansion_cause() { _expansion_cause = CMSExpansionCause::_no_expansion; } |
| 1146 | |
| 1147 // Space enquiries | |
| 1148 size_t capacity() const; | |
| 1149 size_t used() const; | |
| 1150 size_t free() const; | |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1151 double occupancy() const { return ((double)used())/((double)capacity()); } |
| 0 | 1152 size_t contiguous_available() const; |
| 1153 size_t unsafe_max_alloc_nogc() const; | |
| 1154 | |
| 1155 // over-rides | |
| 1156 MemRegion used_region() const; | |
| 1157 MemRegion used_region_at_save_marks() const; | |
| 1158 | |
| 1159 // Does a "full" (forced) collection invoked on this generation collect | |
| 1160 // all younger generations as well? Note that the second conjunct is a | |
| 1161 // hack to allow the collection of the younger gen first if the flag is | |
| 1162 // set. This is better than using th policy's should_collect_gen0_first() | |
| 1163 // since that causes us to do an extra unnecessary pair of restart-&-stop-world. | |
| 1164 virtual bool full_collects_younger_generations() const { | |
| 1165 return UseCMSCompactAtFullCollection && !CollectGen0First; | |
| 1166 } | |
| 1167 | |
| 1168 void space_iterate(SpaceClosure* blk, bool usedOnly = false); | |
| 1169 | |
| 1170 // Support for compaction | |
| 1171 CompactibleSpace* first_compaction_space() const; | |
| 1172 // Adjust quantites in the generation affected by | |
| 1173 // the compaction. | |
| 1174 void reset_after_compaction(); | |
| 1175 | |
| 1176 // Allocation support | |
| 1177 HeapWord* allocate(size_t size, bool tlab); | |
| 1178 HeapWord* have_lock_and_allocate(size_t size, bool tlab); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1179 oop promote(oop obj, size_t obj_size); |
| 0 | 1180 HeapWord* par_allocate(size_t size, bool tlab) { |
| 1181 return allocate(size, tlab); | |
| 1182 } | |
| 1183 | |
| 1184 // Incremental mode triggering. | |
| 1185 HeapWord* allocation_limit_reached(Space* space, HeapWord* top, | |
| 1186 size_t word_size); | |
| 1187 | |
| 1188 // Used by CMSStats to track direct allocation. The value is sampled and | |
| 1189 // reset after each young gen collection. | |
| 1190 size_t direct_allocated_words() const { return _direct_allocated_words; } | |
| 1191 void reset_direct_allocated_words() { _direct_allocated_words = 0; } | |
| 1192 | |
| 1193 // Overrides for parallel promotion. | |
| 1194 virtual oop par_promote(int thread_num, | |
| 1195 oop obj, markOop m, size_t word_sz); | |
| 1196 // This one should not be called for CMS. | |
| 1197 virtual void par_promote_alloc_undo(int thread_num, | |
| 1198 HeapWord* obj, size_t word_sz); | |
| 1199 virtual void par_promote_alloc_done(int thread_num); | |
| 1200 virtual void par_oop_since_save_marks_iterate_done(int thread_num); | |
| 1201 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1836
diff
changeset
|
1202 virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes) const; |
| 0 | 1203 |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
1204 // Inform this (non-young) generation that a promotion failure was |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
1205 // encountered during a collection of a younger generation that |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
1206 // promotes into this generation. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
1207 virtual void promotion_failure_occurred(); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
935
diff
changeset
|
1208 |
| 0 | 1209 bool should_collect(bool full, size_t size, bool tlab); |
|
94
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1210 virtual bool should_concurrent_collect() const; |
|
0834225a7916
6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents:
0
diff
changeset
|
1211 virtual bool is_too_full() const; |
| 0 | 1212 void collect(bool full, |
| 1213 bool clear_all_soft_refs, | |
| 1214 size_t size, | |
| 1215 bool tlab); | |
| 1216 | |
| 1217 HeapWord* expand_and_allocate(size_t word_size, | |
| 1218 bool tlab, | |
| 1219 bool parallel = false); | |
| 1220 | |
| 1221 // GC prologue and epilogue | |
| 1222 void gc_prologue(bool full); | |
| 1223 void gc_prologue_work(bool full, bool registerClosure, | |
| 1224 ModUnionClosure* modUnionClosure); | |
| 1225 void gc_epilogue(bool full); | |
| 1226 void gc_epilogue_work(bool full); | |
| 1227 | |
| 1228 // Time since last GC of this generation | |
| 1229 jlong time_of_last_gc(jlong now) { | |
| 1230 return collector()->time_of_last_gc(now); | |
| 1231 } | |
| 1232 void update_time_of_last_gc(jlong now) { | |
| 1233 collector()-> update_time_of_last_gc(now); | |
| 1234 } | |
| 1235 | |
| 1236 // Allocation failure | |
| 1237 void expand(size_t bytes, size_t expand_bytes, | |
| 1238 CMSExpansionCause::Cause cause); | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
196
diff
changeset
|
1239 virtual bool expand(size_t bytes, size_t expand_bytes); |
| 0 | 1240 void shrink(size_t bytes); |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1241 void shrink_by(size_t bytes); |
| 0 | 1242 HeapWord* expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz); |
| 1243 bool expand_and_ensure_spooling_space(PromotionInfo* promo); | |
| 1244 | |
| 1245 // Iteration support and related enquiries | |
| 1246 void save_marks(); | |
| 1247 bool no_allocs_since_save_marks(); | |
| 1248 void object_iterate_since_last_GC(ObjectClosure* cl); | |
| 1249 void younger_refs_iterate(OopsInGenClosure* cl); | |
| 1250 | |
| 1251 // Iteration support specific to CMS generations | |
| 1252 void save_sweep_limit(); | |
| 1253 | |
| 1254 // More iteration support | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1255 virtual void oop_iterate(MemRegion mr, ExtendedOopClosure* cl); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1256 virtual void oop_iterate(ExtendedOopClosure* cl); |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
452
diff
changeset
|
1257 virtual void safe_object_iterate(ObjectClosure* cl); |
| 0 | 1258 virtual void object_iterate(ObjectClosure* cl); |
| 1259 | |
| 1260 // Need to declare the full complement of closures, whether we'll | |
| 1261 // override them or not, or get message from the compiler: | |
| 1262 // oop_since_save_marks_iterate_nv hides virtual function... | |
| 1263 #define CMS_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
| 1264 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
| 1265 ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DECL) | |
| 1266 | |
| 1267 // Smart allocation XXX -- move to CFLSpace? | |
| 1268 void setNearLargestChunk(); | |
| 1269 bool isNearLargestChunk(HeapWord* addr); | |
| 1270 | |
| 1271 // Get the chunk at the end of the space. Delagates to | |
| 1272 // the space. | |
| 1273 FreeChunk* find_chunk_at_end(); | |
| 1274 | |
| 1275 void post_compact(); | |
| 1276 | |
| 1277 // Debugging | |
| 1278 void prepare_for_verify(); | |
| 6008 | 1279 void verify(); |
| 0 | 1280 void print_statistics() PRODUCT_RETURN; |
| 1281 | |
| 1282 // Performance Counters support | |
| 1283 virtual void update_counters(); | |
| 1284 virtual void update_counters(size_t used); | |
| 1285 void initialize_performance_counters(); | |
| 1286 CollectorCounters* counters() { return collector()->counters(); } | |
| 1287 | |
| 1288 // Support for parallel remark of survivor space | |
| 1289 void* get_data_recorder(int thr_num) { | |
| 1290 //Delegate to collector | |
| 1291 return collector()->get_data_recorder(thr_num); | |
| 1292 } | |
| 1293 | |
| 1294 // Printing | |
| 1295 const char* name() const; | |
| 1296 virtual const char* short_name() const { return "CMS"; } | |
| 1297 void print() const; | |
| 1298 void printOccupancy(const char* s); | |
| 1299 bool must_be_youngest() const { return false; } | |
| 1300 bool must_be_oldest() const { return true; } | |
| 1301 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1302 // Resize the generation after a compacting GC. The |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1303 // generation can be treated as a contiguous space |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1304 // after the compaction. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1305 virtual void compute_new_size(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1306 // Resize the generation after a non-compacting |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1307 // collection. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8035
diff
changeset
|
1308 void compute_new_size_free_list(); |
| 0 | 1309 |
| 1310 CollectionTypes debug_collection_type() { return _debug_collection_type; } | |
| 1311 void rotate_debug_collection_type(); | |
| 1312 }; | |
| 1313 | |
| 1314 class ASConcurrentMarkSweepGeneration : public ConcurrentMarkSweepGeneration { | |
| 1315 | |
| 1316 // Return the size policy from the heap's collector | |
| 1317 // policy casted to CMSAdaptiveSizePolicy*. | |
| 1318 CMSAdaptiveSizePolicy* cms_size_policy() const; | |
| 1319 | |
| 1320 // Resize the generation based on the adaptive size | |
| 1321 // policy. | |
| 1322 void resize(size_t cur_promo, size_t desired_promo); | |
| 1323 | |
| 1324 // Return the GC counters from the collector policy | |
| 1325 CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters(); | |
| 1326 | |
| 1327 virtual void shrink_by(size_t bytes); | |
| 1328 | |
| 1329 public: | |
| 1330 ASConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size, | |
| 1331 int level, CardTableRS* ct, | |
| 1332 bool use_adaptive_freelists, | |
| 6026 | 1333 FreeBlockDictionary<FreeChunk>::DictionaryChoice |
| 0 | 1334 dictionaryChoice) : |
| 1335 ConcurrentMarkSweepGeneration(rs, initial_byte_size, level, ct, | |
| 1336 use_adaptive_freelists, dictionaryChoice) {} | |
| 1337 | |
| 1338 virtual const char* short_name() const { return "ASCMS"; } | |
| 1339 virtual Generation::Name kind() { return Generation::ASConcurrentMarkSweep; } | |
| 1340 | |
| 1341 virtual void update_counters(); | |
| 1342 virtual void update_counters(size_t used); | |
| 1343 }; | |
| 1344 | |
| 1345 // | |
| 1346 // Closures of various sorts used by CMS to accomplish its work | |
| 1347 // | |
| 1348 | |
| 1349 // This closure is used to check that a certain set of oops is empty. | |
| 1350 class FalseClosure: public OopClosure { | |
| 1351 public: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1352 void do_oop(oop* p) { guarantee(false, "Should be an empty set"); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1353 void do_oop(narrowOop* p) { guarantee(false, "Should be an empty set"); } |
| 0 | 1354 }; |
| 1355 | |
| 1356 // This closure is used to do concurrent marking from the roots | |
| 1357 // following the first checkpoint. | |
| 1358 class MarkFromRootsClosure: public BitMapClosure { | |
| 1359 CMSCollector* _collector; | |
| 1360 MemRegion _span; | |
| 1361 CMSBitMap* _bitMap; | |
| 1362 CMSBitMap* _mut; | |
| 1363 CMSMarkStack* _markStack; | |
| 1364 bool _yield; | |
| 1365 int _skipBits; | |
| 1366 HeapWord* _finger; | |
| 1367 HeapWord* _threshold; | |
| 1368 DEBUG_ONLY(bool _verifying;) | |
| 1369 | |
| 1370 public: | |
| 1371 MarkFromRootsClosure(CMSCollector* collector, MemRegion span, | |
| 1372 CMSBitMap* bitMap, | |
| 1373 CMSMarkStack* markStack, | |
| 1374 bool should_yield, bool verifying = false); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
1375 bool do_bit(size_t offset); |
| 0 | 1376 void reset(HeapWord* addr); |
| 1377 inline void do_yield_check(); | |
| 1378 | |
| 1379 private: | |
| 1380 void scanOopsInOop(HeapWord* ptr); | |
| 1381 void do_yield_work(); | |
| 1382 }; | |
| 1383 | |
| 1384 // This closure is used to do concurrent multi-threaded | |
| 1385 // marking from the roots following the first checkpoint. | |
| 1386 // XXX This should really be a subclass of The serial version | |
| 1387 // above, but i have not had the time to refactor things cleanly. | |
| 1388 // That willbe done for Dolphin. | |
| 1389 class Par_MarkFromRootsClosure: public BitMapClosure { | |
| 1390 CMSCollector* _collector; | |
| 1391 MemRegion _whole_span; | |
| 1392 MemRegion _span; | |
| 1393 CMSBitMap* _bit_map; | |
| 1394 CMSBitMap* _mut; | |
| 1395 OopTaskQueue* _work_queue; | |
| 1396 CMSMarkStack* _overflow_stack; | |
| 1397 bool _yield; | |
| 1398 int _skip_bits; | |
| 1399 HeapWord* _finger; | |
| 1400 HeapWord* _threshold; | |
| 1401 CMSConcMarkingTask* _task; | |
| 1402 public: | |
| 1403 Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, | |
| 1404 MemRegion span, | |
| 1405 CMSBitMap* bit_map, | |
| 1406 OopTaskQueue* work_queue, | |
| 1407 CMSMarkStack* overflow_stack, | |
| 1408 bool should_yield); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
1409 bool do_bit(size_t offset); |
| 0 | 1410 inline void do_yield_check(); |
| 1411 | |
| 1412 private: | |
| 1413 void scan_oops_in_oop(HeapWord* ptr); | |
| 1414 void do_yield_work(); | |
| 1415 bool get_work_from_overflow_stack(); | |
| 1416 }; | |
| 1417 | |
| 1418 // The following closures are used to do certain kinds of verification of | |
| 1419 // CMS marking. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1420 class PushAndMarkVerifyClosure: public CMSOopClosure { |
| 0 | 1421 CMSCollector* _collector; |
| 1422 MemRegion _span; | |
| 1423 CMSBitMap* _verification_bm; | |
| 1424 CMSBitMap* _cms_bm; | |
| 1425 CMSMarkStack* _mark_stack; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1426 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1427 void do_oop(oop p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1428 template <class T> inline void do_oop_work(T *p) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1429 oop obj = oopDesc::load_decode_heap_oop(p); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1430 do_oop(obj); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1431 } |
| 0 | 1432 public: |
| 1433 PushAndMarkVerifyClosure(CMSCollector* cms_collector, | |
| 1434 MemRegion span, | |
| 1435 CMSBitMap* verification_bm, | |
| 1436 CMSBitMap* cms_bm, | |
| 1437 CMSMarkStack* mark_stack); | |
| 1438 void do_oop(oop* p); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
94
diff
changeset
|
1439 void do_oop(narrowOop* p); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1440 |
| 0 | 1441 // Deal with a stack overflow condition |
| 1442 void handle_stack_overflow(HeapWord* lost); | |
| 1443 }; | |
| 1444 | |
| 1445 class MarkFromRootsVerifyClosure: public BitMapClosure { | |
| 1446 CMSCollector* _collector; | |
| 1447 MemRegion _span; | |
| 1448 CMSBitMap* _verification_bm; | |
| 1449 CMSBitMap* _cms_bm; | |
| 1450 CMSMarkStack* _mark_stack; | |
| 1451 HeapWord* _finger; | |
| 1452 PushAndMarkVerifyClosure _pam_verify_closure; | |
| 1453 public: | |
| 1454 MarkFromRootsVerifyClosure(CMSCollector* collector, MemRegion span, | |
| 1455 CMSBitMap* verification_bm, | |
| 1456 CMSBitMap* cms_bm, | |
| 1457 CMSMarkStack* mark_stack); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
1458 bool do_bit(size_t offset); |
| 0 | 1459 void reset(HeapWord* addr); |
| 1460 }; | |
| 1461 | |
| 1462 | |
| 1463 // This closure is used to check that a certain set of bits is | |
| 1464 // "empty" (i.e. the bit vector doesn't have any 1-bits). | |
| 1465 class FalseBitMapClosure: public BitMapClosure { | |
| 1466 public: | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
1467 bool do_bit(size_t offset) { |
| 0 | 1468 guarantee(false, "Should not have a 1 bit"); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
143
diff
changeset
|
1469 return true; |
| 0 | 1470 } |
| 1471 }; | |
| 1472 | |
| 1473 // This closure is used during the second checkpointing phase | |
| 1474 // to rescan the marked objects on the dirty cards in the mod | |
| 1475 // union table and the card table proper. It's invoked via | |
| 1476 // MarkFromDirtyCardsClosure below. It uses either | |
| 1477 // [Par_]MarkRefsIntoAndScanClosure (Par_ in the parallel case) | |
| 1478 // declared in genOopClosures.hpp to accomplish some of its work. | |
| 1479 // In the parallel case the bitMap is shared, so access to | |
| 1480 // it needs to be suitably synchronized for updates by embedded | |
| 1481 // closures that update it; however, this closure itself only | |
| 1482 // reads the bit_map and because it is idempotent, is immune to | |
| 1483 // reading stale values. | |
| 1484 class ScanMarkedObjectsAgainClosure: public UpwardsObjectClosure { | |
| 1485 #ifdef ASSERT | |
| 1486 CMSCollector* _collector; | |
| 1487 MemRegion _span; | |
| 1488 union { | |
| 1489 CMSMarkStack* _mark_stack; | |
| 1490 OopTaskQueue* _work_queue; | |
| 1491 }; | |
| 1492 #endif // ASSERT | |
| 1493 bool _parallel; | |
| 1494 CMSBitMap* _bit_map; | |
| 1495 union { | |
| 1496 MarkRefsIntoAndScanClosure* _scan_closure; | |
| 1497 Par_MarkRefsIntoAndScanClosure* _par_scan_closure; | |
| 1498 }; | |
| 1499 | |
| 1500 public: | |
| 1501 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | |
| 1502 MemRegion span, | |
| 1503 ReferenceProcessor* rp, | |
| 1504 CMSBitMap* bit_map, | |
| 1505 CMSMarkStack* mark_stack, | |
| 1506 MarkRefsIntoAndScanClosure* cl): | |
| 1507 #ifdef ASSERT | |
| 1508 _collector(collector), | |
| 1509 _span(span), | |
| 1510 _mark_stack(mark_stack), | |
| 1511 #endif // ASSERT | |
| 1512 _parallel(false), | |
| 1513 _bit_map(bit_map), | |
| 1514 _scan_closure(cl) { } | |
| 1515 | |
| 1516 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | |
| 1517 MemRegion span, | |
| 1518 ReferenceProcessor* rp, | |
| 1519 CMSBitMap* bit_map, | |
| 1520 OopTaskQueue* work_queue, | |
| 1521 Par_MarkRefsIntoAndScanClosure* cl): | |
| 1522 #ifdef ASSERT | |
| 1523 _collector(collector), | |
| 1524 _span(span), | |
| 1525 _work_queue(work_queue), | |
| 1526 #endif // ASSERT | |
| 1527 _parallel(true), | |
| 1528 _bit_map(bit_map), | |
| 1529 _par_scan_closure(cl) { } | |
| 1530 | |
| 1531 void do_object(oop obj) { | |
| 1532 guarantee(false, "Call do_object_b(oop, MemRegion) instead"); | |
| 1533 } | |
| 1534 bool do_object_b(oop obj) { | |
| 1535 guarantee(false, "Call do_object_b(oop, MemRegion) form instead"); | |
| 1536 return false; | |
| 1537 } | |
| 1538 bool do_object_bm(oop p, MemRegion mr); | |
| 1539 }; | |
| 1540 | |
| 1541 // This closure is used during the second checkpointing phase | |
| 1542 // to rescan the marked objects on the dirty cards in the mod | |
| 1543 // union table and the card table proper. It invokes | |
| 1544 // ScanMarkedObjectsAgainClosure above to accomplish much of its work. | |
| 1545 // In the parallel case, the bit map is shared and requires | |
| 1546 // synchronized access. | |
| 1547 class MarkFromDirtyCardsClosure: public MemRegionClosure { | |
| 1548 CompactibleFreeListSpace* _space; | |
| 1549 ScanMarkedObjectsAgainClosure _scan_cl; | |
| 1550 size_t _num_dirty_cards; | |
| 1551 | |
| 1552 public: | |
| 1553 MarkFromDirtyCardsClosure(CMSCollector* collector, | |
| 1554 MemRegion span, | |
| 1555 CompactibleFreeListSpace* space, | |
| 1556 CMSBitMap* bit_map, | |
| 1557 CMSMarkStack* mark_stack, | |
| 1558 MarkRefsIntoAndScanClosure* cl): | |
| 1559 _space(space), | |
| 1560 _num_dirty_cards(0), | |
| 1561 _scan_cl(collector, span, collector->ref_processor(), bit_map, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1562 mark_stack, cl) { } |
| 0 | 1563 |
| 1564 MarkFromDirtyCardsClosure(CMSCollector* collector, | |
| 1565 MemRegion span, | |
| 1566 CompactibleFreeListSpace* space, | |
| 1567 CMSBitMap* bit_map, | |
| 1568 OopTaskQueue* work_queue, | |
| 1569 Par_MarkRefsIntoAndScanClosure* cl): | |
| 1570 _space(space), | |
| 1571 _num_dirty_cards(0), | |
| 1572 _scan_cl(collector, span, collector->ref_processor(), bit_map, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1573 work_queue, cl) { } |
| 0 | 1574 |
| 1575 void do_MemRegion(MemRegion mr); | |
| 1576 void set_space(CompactibleFreeListSpace* space) { _space = space; } | |
| 1577 size_t num_dirty_cards() { return _num_dirty_cards; } | |
| 1578 }; | |
| 1579 | |
| 1580 // This closure is used in the non-product build to check | |
| 1581 // that there are no MemRegions with a certain property. | |
| 1582 class FalseMemRegionClosure: public MemRegionClosure { | |
| 1583 void do_MemRegion(MemRegion mr) { | |
| 1584 guarantee(!mr.is_empty(), "Shouldn't be empty"); | |
| 1585 guarantee(false, "Should never be here"); | |
| 1586 } | |
| 1587 }; | |
| 1588 | |
| 1589 // This closure is used during the precleaning phase | |
| 1590 // to "carefully" rescan marked objects on dirty cards. | |
| 1591 // It uses MarkRefsIntoAndScanClosure declared in genOopClosures.hpp | |
| 1592 // to accomplish some of its work. | |
| 1593 class ScanMarkedObjectsAgainCarefullyClosure: public ObjectClosureCareful { | |
| 1594 CMSCollector* _collector; | |
| 1595 MemRegion _span; | |
| 1596 bool _yield; | |
| 1597 Mutex* _freelistLock; | |
| 1598 CMSBitMap* _bitMap; | |
| 1599 CMSMarkStack* _markStack; | |
| 1600 MarkRefsIntoAndScanClosure* _scanningClosure; | |
| 1601 | |
| 1602 public: | |
| 1603 ScanMarkedObjectsAgainCarefullyClosure(CMSCollector* collector, | |
| 1604 MemRegion span, | |
| 1605 CMSBitMap* bitMap, | |
| 1606 CMSMarkStack* markStack, | |
| 1607 MarkRefsIntoAndScanClosure* cl, | |
| 1608 bool should_yield): | |
| 1609 _collector(collector), | |
| 1610 _span(span), | |
| 1611 _yield(should_yield), | |
| 1612 _bitMap(bitMap), | |
| 1613 _markStack(markStack), | |
| 1614 _scanningClosure(cl) { | |
| 1615 } | |
| 1616 | |
| 1617 void do_object(oop p) { | |
| 1618 guarantee(false, "call do_object_careful instead"); | |
| 1619 } | |
| 1620 | |
| 1621 size_t do_object_careful(oop p) { | |
| 1622 guarantee(false, "Unexpected caller"); | |
| 1623 return 0; | |
| 1624 } | |
| 1625 | |
| 1626 size_t do_object_careful_m(oop p, MemRegion mr); | |
| 1627 | |
| 1628 void setFreelistLock(Mutex* m) { | |
| 1629 _freelistLock = m; | |
| 1630 _scanningClosure->set_freelistLock(m); | |
| 1631 } | |
| 1632 | |
| 1633 private: | |
| 1634 inline bool do_yield_check(); | |
| 1635 | |
| 1636 void do_yield_work(); | |
| 1637 }; | |
| 1638 | |
| 1639 class SurvivorSpacePrecleanClosure: public ObjectClosureCareful { | |
| 1640 CMSCollector* _collector; | |
| 1641 MemRegion _span; | |
| 1642 bool _yield; | |
| 1643 CMSBitMap* _bit_map; | |
| 1644 CMSMarkStack* _mark_stack; | |
| 1645 PushAndMarkClosure* _scanning_closure; | |
| 1646 unsigned int _before_count; | |
| 1647 | |
| 1648 public: | |
| 1649 SurvivorSpacePrecleanClosure(CMSCollector* collector, | |
| 1650 MemRegion span, | |
| 1651 CMSBitMap* bit_map, | |
| 1652 CMSMarkStack* mark_stack, | |
| 1653 PushAndMarkClosure* cl, | |
| 1654 unsigned int before_count, | |
| 1655 bool should_yield): | |
| 1656 _collector(collector), | |
| 1657 _span(span), | |
| 1658 _yield(should_yield), | |
| 1659 _bit_map(bit_map), | |
| 1660 _mark_stack(mark_stack), | |
| 1661 _scanning_closure(cl), | |
| 1662 _before_count(before_count) | |
| 1663 { } | |
| 1664 | |
| 1665 void do_object(oop p) { | |
| 1666 guarantee(false, "call do_object_careful instead"); | |
| 1667 } | |
| 1668 | |
| 1669 size_t do_object_careful(oop p); | |
| 1670 | |
| 1671 size_t do_object_careful_m(oop p, MemRegion mr) { | |
| 1672 guarantee(false, "Unexpected caller"); | |
| 1673 return 0; | |
| 1674 } | |
| 1675 | |
| 1676 private: | |
| 1677 inline void do_yield_check(); | |
| 1678 void do_yield_work(); | |
| 1679 }; | |
| 1680 | |
| 1681 // This closure is used to accomplish the sweeping work | |
| 1682 // after the second checkpoint but before the concurrent reset | |
| 1683 // phase. | |
| 1684 // | |
| 1685 // Terminology | |
| 1686 // left hand chunk (LHC) - block of one or more chunks currently being | |
| 1687 // coalesced. The LHC is available for coalescing with a new chunk. | |
| 1688 // right hand chunk (RHC) - block that is currently being swept that is | |
| 1689 // free or garbage that can be coalesced with the LHC. | |
| 1690 // _inFreeRange is true if there is currently a LHC | |
| 1691 // _lastFreeRangeCoalesced is true if the LHC consists of more than one chunk. | |
| 1692 // _freeRangeInFreeLists is true if the LHC is in the free lists. | |
| 1693 // _freeFinger is the address of the current LHC | |
| 1694 class SweepClosure: public BlkClosureCareful { | |
| 1695 CMSCollector* _collector; // collector doing the work | |
| 1696 ConcurrentMarkSweepGeneration* _g; // Generation being swept | |
| 1697 CompactibleFreeListSpace* _sp; // Space being swept | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1698 HeapWord* _limit;// the address at or above which the sweep should stop |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1699 // because we do not expect newly garbage blocks |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1700 // eligible for sweeping past that address. |
| 0 | 1701 Mutex* _freelistLock; // Free list lock (in space) |
| 1702 CMSBitMap* _bitMap; // Marking bit map (in | |
| 1703 // generation) | |
| 1704 bool _inFreeRange; // Indicates if we are in the | |
| 1705 // midst of a free run | |
| 1706 bool _freeRangeInFreeLists; | |
| 1707 // Often, we have just found | |
| 1708 // a free chunk and started | |
| 1709 // a new free range; we do not | |
| 1710 // eagerly remove this chunk from | |
| 1711 // the free lists unless there is | |
| 1712 // a possibility of coalescing. | |
| 1713 // When true, this flag indicates | |
| 1714 // that the _freeFinger below | |
| 1715 // points to a potentially free chunk | |
| 1716 // that may still be in the free lists | |
| 1717 bool _lastFreeRangeCoalesced; | |
| 1718 // free range contains chunks | |
| 1719 // coalesced | |
| 1720 bool _yield; | |
| 1721 // Whether sweeping should be | |
| 1722 // done with yields. For instance | |
| 1723 // when done by the foreground | |
| 1724 // collector we shouldn't yield. | |
| 1725 HeapWord* _freeFinger; // When _inFreeRange is set, the | |
| 1726 // pointer to the "left hand | |
| 1727 // chunk" | |
| 1728 size_t _freeRangeSize; | |
| 1729 // When _inFreeRange is set, this | |
| 1730 // indicates the accumulated size | |
| 1731 // of the "left hand chunk" | |
| 1732 NOT_PRODUCT( | |
| 1733 size_t _numObjectsFreed; | |
| 1734 size_t _numWordsFreed; | |
| 1735 size_t _numObjectsLive; | |
| 1736 size_t _numWordsLive; | |
| 1737 size_t _numObjectsAlreadyFree; | |
| 1738 size_t _numWordsAlreadyFree; | |
| 1739 FreeChunk* _last_fc; | |
| 1740 ) | |
| 1741 private: | |
| 1742 // Code that is common to a free chunk or garbage when | |
| 1743 // encountered during sweeping. | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1972
diff
changeset
|
1744 void do_post_free_or_garbage_chunk(FreeChunk *fc, size_t chunkSize); |
| 0 | 1745 // Process a free chunk during sweeping. |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1972
diff
changeset
|
1746 void do_already_free_chunk(FreeChunk *fc); |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1747 // Work method called when processing an already free or a |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1748 // freshly garbage chunk to do a lookahead and possibly a |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1749 // premptive flush if crossing over _limit. |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1750 void lookahead_and_flush(FreeChunk* fc, size_t chunkSize); |
| 0 | 1751 // Process a garbage chunk during sweeping. |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1972
diff
changeset
|
1752 size_t do_garbage_chunk(FreeChunk *fc); |
| 0 | 1753 // Process a live chunk during sweeping. |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1972
diff
changeset
|
1754 size_t do_live_chunk(FreeChunk* fc); |
| 0 | 1755 |
| 1756 // Accessors. | |
| 1757 HeapWord* freeFinger() const { return _freeFinger; } | |
| 1758 void set_freeFinger(HeapWord* v) { _freeFinger = v; } | |
| 1759 bool inFreeRange() const { return _inFreeRange; } | |
| 1760 void set_inFreeRange(bool v) { _inFreeRange = v; } | |
| 1761 bool lastFreeRangeCoalesced() const { return _lastFreeRangeCoalesced; } | |
| 1762 void set_lastFreeRangeCoalesced(bool v) { _lastFreeRangeCoalesced = v; } | |
| 1763 bool freeRangeInFreeLists() const { return _freeRangeInFreeLists; } | |
| 1764 void set_freeRangeInFreeLists(bool v) { _freeRangeInFreeLists = v; } | |
| 1765 | |
| 1766 // Initialize a free range. | |
| 1767 void initialize_free_range(HeapWord* freeFinger, bool freeRangeInFreeLists); | |
| 1768 // Return this chunk to the free lists. | |
|
2132
4947ee68d19c
7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents:
1972
diff
changeset
|
1769 void flush_cur_free_chunk(HeapWord* chunk, size_t size); |
| 0 | 1770 |
| 1771 // Check if we should yield and do so when necessary. | |
| 1772 inline void do_yield_check(HeapWord* addr); | |
| 1773 | |
| 1774 // Yield | |
| 1775 void do_yield_work(HeapWord* addr); | |
| 1776 | |
| 1777 // Debugging/Printing | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1778 void print_free_block_coalesced(FreeChunk* fc) const; |
| 0 | 1779 |
| 1780 public: | |
| 1781 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g, | |
| 1782 CMSBitMap* bitMap, bool should_yield); | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1783 ~SweepClosure() PRODUCT_RETURN; |
| 0 | 1784 |
| 1785 size_t do_blk_careful(HeapWord* addr); | |
|
3746
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1786 void print() const { print_on(tty); } |
|
537a4053b0f9
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents:
3356
diff
changeset
|
1787 void print_on(outputStream *st) const; |
| 0 | 1788 }; |
| 1789 | |
| 1790 // Closures related to weak references processing | |
| 1791 | |
| 1792 // During CMS' weak reference processing, this is a | |
| 1793 // work-routine/closure used to complete transitive | |
| 1794 // marking of objects as live after a certain point | |
| 1795 // in which an initial set has been completely accumulated. | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1796 // This closure is currently used both during the final |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1797 // remark stop-world phase, as well as during the concurrent |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1798 // precleaning of the discovered reference lists. |
| 0 | 1799 class CMSDrainMarkingStackClosure: public VoidClosure { |
| 1800 CMSCollector* _collector; | |
| 1801 MemRegion _span; | |
| 1802 CMSMarkStack* _mark_stack; | |
| 1803 CMSBitMap* _bit_map; | |
| 1804 CMSKeepAliveClosure* _keep_alive; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1805 bool _concurrent_precleaning; |
| 0 | 1806 public: |
| 1807 CMSDrainMarkingStackClosure(CMSCollector* collector, MemRegion span, | |
| 1808 CMSBitMap* bit_map, CMSMarkStack* mark_stack, | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1809 CMSKeepAliveClosure* keep_alive, |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1810 bool cpc): |
| 0 | 1811 _collector(collector), |
| 1812 _span(span), | |
| 1813 _bit_map(bit_map), | |
| 1814 _mark_stack(mark_stack), | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1815 _keep_alive(keep_alive), |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1816 _concurrent_precleaning(cpc) { |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1817 assert(_concurrent_precleaning == _keep_alive->concurrent_precleaning(), |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1818 "Mismatch"); |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
356
diff
changeset
|
1819 } |
| 0 | 1820 |
| 1821 void do_void(); | |
| 1822 }; | |
| 1823 | |
| 1824 // A parallel version of CMSDrainMarkingStackClosure above. | |
| 1825 class CMSParDrainMarkingStackClosure: public VoidClosure { | |
| 1826 CMSCollector* _collector; | |
| 1827 MemRegion _span; | |
| 1828 OopTaskQueue* _work_queue; | |
| 1829 CMSBitMap* _bit_map; | |
| 1830 CMSInnerParMarkAndPushClosure _mark_and_push; | |
| 1831 | |
| 1832 public: | |
| 1833 CMSParDrainMarkingStackClosure(CMSCollector* collector, | |
| 1834 MemRegion span, CMSBitMap* bit_map, | |
| 1835 OopTaskQueue* work_queue): | |
| 1836 _collector(collector), | |
| 1837 _span(span), | |
| 1838 _bit_map(bit_map), | |
| 1839 _work_queue(work_queue), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1840 _mark_and_push(collector, span, bit_map, work_queue) { } |
| 0 | 1841 |
| 1842 public: | |
| 1843 void trim_queue(uint max); | |
| 1844 void do_void(); | |
| 1845 }; | |
| 1846 | |
| 1847 // Allow yielding or short-circuiting of reference list | |
| 1848 // prelceaning work. | |
| 1849 class CMSPrecleanRefsYieldClosure: public YieldClosure { | |
| 1850 CMSCollector* _collector; | |
| 1851 void do_yield_work(); | |
| 1852 public: | |
| 1853 CMSPrecleanRefsYieldClosure(CMSCollector* collector): | |
| 1854 _collector(collector) {} | |
| 1855 virtual bool should_return(); | |
| 1856 }; | |
| 1857 | |
| 1858 | |
| 1859 // Convenience class that locks free list locks for given CMS collector | |
| 1860 class FreelistLocker: public StackObj { | |
| 1861 private: | |
| 1862 CMSCollector* _collector; | |
| 1863 public: | |
| 1864 FreelistLocker(CMSCollector* collector): | |
| 1865 _collector(collector) { | |
| 1866 _collector->getFreelistLocks(); | |
| 1867 } | |
| 1868 | |
| 1869 ~FreelistLocker() { | |
| 1870 _collector->releaseFreelistLocks(); | |
| 1871 } | |
| 1872 }; | |
| 1873 | |
| 1874 // Mark all dead objects in a given space. | |
| 1875 class MarkDeadObjectsClosure: public BlkClosure { | |
| 1876 const CMSCollector* _collector; | |
| 1877 const CompactibleFreeListSpace* _sp; | |
| 1878 CMSBitMap* _live_bit_map; | |
| 1879 CMSBitMap* _dead_bit_map; | |
| 1880 public: | |
| 1881 MarkDeadObjectsClosure(const CMSCollector* collector, | |
| 1882 const CompactibleFreeListSpace* sp, | |
| 1883 CMSBitMap *live_bit_map, | |
| 1884 CMSBitMap *dead_bit_map) : | |
| 1885 _collector(collector), | |
| 1886 _sp(sp), | |
| 1887 _live_bit_map(live_bit_map), | |
| 1888 _dead_bit_map(dead_bit_map) {} | |
| 1889 size_t do_blk(HeapWord* addr); | |
| 1890 }; | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1891 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1892 class TraceCMSMemoryManagerStats : public TraceMemoryManagerStats { |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1893 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1894 public: |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2369
diff
changeset
|
1895 TraceCMSMemoryManagerStats(CMSCollector::CollectorState phase, GCCause::Cause cause); |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1896 }; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
1897 |
| 1972 | 1898 |
| 1899 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP |