Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 1145:e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Wed, 23 Dec 2009 09:23:54 -0800 |
| parents | 6270f80a7331 |
| children | 2a1472c30599 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 579 | 2 * Copyright 2001-2009 Sun Microsystems, Inc. All Rights Reserved. |
| 342 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 class G1CollectedHeap; | |
| 26 class CMTask; | |
| 27 typedef GenericTaskQueue<oop> CMTaskQueue; | |
| 28 typedef GenericTaskQueueSet<oop> CMTaskQueueSet; | |
| 29 | |
| 30 // A generic CM bit map. This is essentially a wrapper around the BitMap | |
| 31 // class, with one bit per (1<<_shifter) HeapWords. | |
| 32 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
33 class CMBitMapRO VALUE_OBJ_CLASS_SPEC { |
| 342 | 34 protected: |
| 35 HeapWord* _bmStartWord; // base address of range covered by map | |
| 36 size_t _bmWordSize; // map size (in #HeapWords covered) | |
| 37 const int _shifter; // map to char or bit | |
| 38 VirtualSpace _virtual_space; // underlying the bit map | |
| 39 BitMap _bm; // the bit map itself | |
| 40 | |
| 41 public: | |
| 42 // constructor | |
| 43 CMBitMapRO(ReservedSpace rs, int shifter); | |
| 44 | |
| 45 enum { do_yield = true }; | |
| 46 | |
| 47 // inquiries | |
| 48 HeapWord* startWord() const { return _bmStartWord; } | |
| 49 size_t sizeInWords() const { return _bmWordSize; } | |
| 50 // the following is one past the last word in space | |
| 51 HeapWord* endWord() const { return _bmStartWord + _bmWordSize; } | |
| 52 | |
| 53 // read marks | |
| 54 | |
| 55 bool isMarked(HeapWord* addr) const { | |
| 56 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 57 "outside underlying space?"); | |
| 58 return _bm.at(heapWordToOffset(addr)); | |
| 59 } | |
| 60 | |
| 61 // iteration | |
| 62 bool iterate(BitMapClosure* cl) { return _bm.iterate(cl); } | |
| 63 bool iterate(BitMapClosure* cl, MemRegion mr); | |
| 64 | |
| 65 // Return the address corresponding to the next marked bit at or after | |
| 66 // "addr", and before "limit", if "limit" is non-NULL. If there is no | |
| 67 // such bit, returns "limit" if that is non-NULL, or else "endWord()". | |
| 68 HeapWord* getNextMarkedWordAddress(HeapWord* addr, | |
| 69 HeapWord* limit = NULL) const; | |
| 70 // Return the address corresponding to the next unmarked bit at or after | |
| 71 // "addr", and before "limit", if "limit" is non-NULL. If there is no | |
| 72 // such bit, returns "limit" if that is non-NULL, or else "endWord()". | |
| 73 HeapWord* getNextUnmarkedWordAddress(HeapWord* addr, | |
| 74 HeapWord* limit = NULL) const; | |
| 75 | |
| 76 // conversion utilities | |
| 77 // XXX Fix these so that offsets are size_t's... | |
| 78 HeapWord* offsetToHeapWord(size_t offset) const { | |
| 79 return _bmStartWord + (offset << _shifter); | |
| 80 } | |
| 81 size_t heapWordToOffset(HeapWord* addr) const { | |
| 82 return pointer_delta(addr, _bmStartWord) >> _shifter; | |
| 83 } | |
| 84 int heapWordDiffToOffsetDiff(size_t diff) const; | |
| 85 HeapWord* nextWord(HeapWord* addr) { | |
| 86 return offsetToHeapWord(heapWordToOffset(addr) + 1); | |
| 87 } | |
| 88 | |
| 89 void mostly_disjoint_range_union(BitMap* from_bitmap, | |
| 90 size_t from_start_index, | |
| 91 HeapWord* to_start_word, | |
| 92 size_t word_num); | |
| 93 | |
| 94 // debugging | |
| 95 NOT_PRODUCT(bool covers(ReservedSpace rs) const;) | |
| 96 }; | |
| 97 | |
| 98 class CMBitMap : public CMBitMapRO { | |
| 99 | |
| 100 public: | |
| 101 // constructor | |
| 102 CMBitMap(ReservedSpace rs, int shifter) : | |
| 103 CMBitMapRO(rs, shifter) {} | |
| 104 | |
| 105 // write marks | |
| 106 void mark(HeapWord* addr) { | |
| 107 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 108 "outside underlying space?"); | |
| 109 _bm.at_put(heapWordToOffset(addr), true); | |
| 110 } | |
| 111 void clear(HeapWord* addr) { | |
| 112 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 113 "outside underlying space?"); | |
| 114 _bm.at_put(heapWordToOffset(addr), false); | |
| 115 } | |
| 116 bool parMark(HeapWord* addr) { | |
| 117 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 118 "outside underlying space?"); | |
| 119 return _bm.par_at_put(heapWordToOffset(addr), true); | |
| 120 } | |
| 121 bool parClear(HeapWord* addr) { | |
| 122 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 123 "outside underlying space?"); | |
| 124 return _bm.par_at_put(heapWordToOffset(addr), false); | |
| 125 } | |
| 126 void markRange(MemRegion mr); | |
| 127 void clearAll(); | |
| 128 void clearRange(MemRegion mr); | |
| 129 | |
| 130 // Starting at the bit corresponding to "addr" (inclusive), find the next | |
| 131 // "1" bit, if any. This bit starts some run of consecutive "1"'s; find | |
| 132 // the end of this run (stopping at "end_addr"). Return the MemRegion | |
| 133 // covering from the start of the region corresponding to the first bit | |
| 134 // of the run to the end of the region corresponding to the last bit of | |
| 135 // the run. If there is no "1" bit at or after "addr", return an empty | |
| 136 // MemRegion. | |
| 137 MemRegion getAndClearMarkedRegion(HeapWord* addr, HeapWord* end_addr); | |
| 138 }; | |
| 139 | |
| 140 // Represents a marking stack used by the CM collector. | |
| 141 // Ideally this should be GrowableArray<> just like MSC's marking stack(s). | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
142 class CMMarkStack VALUE_OBJ_CLASS_SPEC { |
| 342 | 143 ConcurrentMark* _cm; |
| 144 oop* _base; // bottom of stack | |
| 145 jint _index; // one more than last occupied index | |
| 146 jint _capacity; // max #elements | |
| 147 jint _oops_do_bound; // Number of elements to include in next iteration. | |
| 148 NOT_PRODUCT(jint _max_depth;) // max depth plumbed during run | |
| 149 | |
| 150 bool _overflow; | |
| 151 DEBUG_ONLY(bool _drain_in_progress;) | |
| 152 DEBUG_ONLY(bool _drain_in_progress_yields;) | |
| 153 | |
| 154 public: | |
| 155 CMMarkStack(ConcurrentMark* cm); | |
| 156 ~CMMarkStack(); | |
| 157 | |
| 158 void allocate(size_t size); | |
| 159 | |
| 160 oop pop() { | |
| 161 if (!isEmpty()) { | |
| 162 return _base[--_index] ; | |
| 163 } | |
| 164 return NULL; | |
| 165 } | |
| 166 | |
| 167 // If overflow happens, don't do the push, and record the overflow. | |
| 168 // *Requires* that "ptr" is already marked. | |
| 169 void push(oop ptr) { | |
| 170 if (isFull()) { | |
| 171 // Record overflow. | |
| 172 _overflow = true; | |
| 173 return; | |
| 174 } else { | |
| 175 _base[_index++] = ptr; | |
| 176 NOT_PRODUCT(_max_depth = MAX2(_max_depth, _index)); | |
| 177 } | |
| 178 } | |
| 179 // Non-block impl. Note: concurrency is allowed only with other | |
| 180 // "par_push" operations, not with "pop" or "drain". We would need | |
| 181 // parallel versions of them if such concurrency was desired. | |
| 182 void par_push(oop ptr); | |
| 183 | |
| 184 // Pushes the first "n" elements of "ptr_arr" on the stack. | |
| 185 // Non-block impl. Note: concurrency is allowed only with other | |
| 186 // "par_adjoin_arr" or "push" operations, not with "pop" or "drain". | |
| 187 void par_adjoin_arr(oop* ptr_arr, int n); | |
| 188 | |
| 189 // Pushes the first "n" elements of "ptr_arr" on the stack. | |
| 190 // Locking impl: concurrency is allowed only with | |
| 191 // "par_push_arr" and/or "par_pop_arr" operations, which use the same | |
| 192 // locking strategy. | |
| 193 void par_push_arr(oop* ptr_arr, int n); | |
| 194 | |
| 195 // If returns false, the array was empty. Otherwise, removes up to "max" | |
| 196 // elements from the stack, and transfers them to "ptr_arr" in an | |
| 197 // unspecified order. The actual number transferred is given in "n" ("n | |
| 198 // == 0" is deliberately redundant with the return value.) Locking impl: | |
| 199 // concurrency is allowed only with "par_push_arr" and/or "par_pop_arr" | |
| 200 // operations, which use the same locking strategy. | |
| 201 bool par_pop_arr(oop* ptr_arr, int max, int* n); | |
| 202 | |
| 203 // Drain the mark stack, applying the given closure to all fields of | |
| 204 // objects on the stack. (That is, continue until the stack is empty, | |
| 205 // even if closure applications add entries to the stack.) The "bm" | |
| 206 // argument, if non-null, may be used to verify that only marked objects | |
| 207 // are on the mark stack. If "yield_after" is "true", then the | |
| 208 // concurrent marker performing the drain offers to yield after | |
| 209 // processing each object. If a yield occurs, stops the drain operation | |
| 210 // and returns false. Otherwise, returns true. | |
| 211 template<class OopClosureClass> | |
| 212 bool drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after = false); | |
| 213 | |
| 214 bool isEmpty() { return _index == 0; } | |
| 215 bool isFull() { return _index == _capacity; } | |
| 216 int maxElems() { return _capacity; } | |
| 217 | |
| 218 bool overflow() { return _overflow; } | |
| 219 void clear_overflow() { _overflow = false; } | |
| 220 | |
| 221 int size() { return _index; } | |
| 222 | |
| 223 void setEmpty() { _index = 0; clear_overflow(); } | |
| 224 | |
| 225 // Record the current size; a subsequent "oops_do" will iterate only over | |
| 226 // indices valid at the time of this call. | |
| 227 void set_oops_do_bound(jint bound = -1) { | |
| 228 if (bound == -1) { | |
| 229 _oops_do_bound = _index; | |
| 230 } else { | |
| 231 _oops_do_bound = bound; | |
| 232 } | |
| 233 } | |
| 234 jint oops_do_bound() { return _oops_do_bound; } | |
| 235 // iterate over the oops in the mark stack, up to the bound recorded via | |
| 236 // the call above. | |
| 237 void oops_do(OopClosure* f); | |
| 238 }; | |
| 239 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
240 class CMRegionStack VALUE_OBJ_CLASS_SPEC { |
| 342 | 241 MemRegion* _base; |
| 242 jint _capacity; | |
| 243 jint _index; | |
| 244 jint _oops_do_bound; | |
| 245 bool _overflow; | |
| 246 public: | |
| 247 CMRegionStack(); | |
| 248 ~CMRegionStack(); | |
| 249 void allocate(size_t size); | |
| 250 | |
| 251 // This is lock-free; assumes that it will only be called in parallel | |
| 252 // with other "push" operations (no pops). | |
| 253 void push(MemRegion mr); | |
| 254 | |
| 255 // Lock-free; assumes that it will only be called in parallel | |
| 256 // with other "pop" operations (no pushes). | |
| 257 MemRegion pop(); | |
| 258 | |
| 259 bool isEmpty() { return _index == 0; } | |
| 260 bool isFull() { return _index == _capacity; } | |
| 261 | |
| 262 bool overflow() { return _overflow; } | |
| 263 void clear_overflow() { _overflow = false; } | |
| 264 | |
| 265 int size() { return _index; } | |
| 266 | |
| 267 // It iterates over the entries in the region stack and it | |
| 268 // invalidates (i.e. assigns MemRegion()) the ones that point to | |
| 269 // regions in the collection set. | |
| 270 bool invalidate_entries_into_cset(); | |
| 271 | |
| 272 // This gives an upper bound up to which the iteration in | |
| 273 // invalidate_entries_into_cset() will reach. This prevents | |
| 274 // newly-added entries to be unnecessarily scanned. | |
| 275 void set_oops_do_bound() { | |
| 276 _oops_do_bound = _index; | |
| 277 } | |
| 278 | |
| 279 void setEmpty() { _index = 0; clear_overflow(); } | |
| 280 }; | |
| 281 | |
| 282 // this will enable a variety of different statistics per GC task | |
| 283 #define _MARKING_STATS_ 0 | |
| 284 // this will enable the higher verbose levels | |
| 285 #define _MARKING_VERBOSE_ 0 | |
| 286 | |
| 287 #if _MARKING_STATS_ | |
| 288 #define statsOnly(statement) \ | |
| 289 do { \ | |
| 290 statement ; \ | |
| 291 } while (0) | |
| 292 #else // _MARKING_STATS_ | |
| 293 #define statsOnly(statement) \ | |
| 294 do { \ | |
| 295 } while (0) | |
| 296 #endif // _MARKING_STATS_ | |
| 297 | |
| 298 typedef enum { | |
| 299 no_verbose = 0, // verbose turned off | |
| 300 stats_verbose, // only prints stats at the end of marking | |
| 301 low_verbose, // low verbose, mostly per region and per major event | |
| 302 medium_verbose, // a bit more detailed than low | |
| 303 high_verbose // per object verbose | |
| 304 } CMVerboseLevel; | |
| 305 | |
| 306 | |
| 307 class ConcurrentMarkThread; | |
| 308 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
309 class ConcurrentMark: public CHeapObj { |
| 342 | 310 friend class ConcurrentMarkThread; |
| 311 friend class CMTask; | |
| 312 friend class CMBitMapClosure; | |
| 313 friend class CSMarkOopClosure; | |
| 314 friend class CMGlobalObjectClosure; | |
| 315 friend class CMRemarkTask; | |
| 316 friend class CMConcurrentMarkingTask; | |
| 317 friend class G1ParNoteEndTask; | |
| 318 friend class CalcLiveObjectsClosure; | |
| 319 | |
| 320 protected: | |
| 321 ConcurrentMarkThread* _cmThread; // the thread doing the work | |
| 322 G1CollectedHeap* _g1h; // the heap. | |
| 323 size_t _parallel_marking_threads; // the number of marking | |
| 324 // threads we'll use | |
| 325 double _sleep_factor; // how much we have to sleep, with | |
| 326 // respect to the work we just did, to | |
| 327 // meet the marking overhead goal | |
| 328 double _marking_task_overhead; // marking target overhead for | |
| 329 // a single task | |
| 330 | |
| 331 // same as the two above, but for the cleanup task | |
| 332 double _cleanup_sleep_factor; | |
| 333 double _cleanup_task_overhead; | |
| 334 | |
| 335 // Stuff related to age cohort processing. | |
| 336 struct ParCleanupThreadState { | |
| 337 char _pre[64]; | |
| 338 UncleanRegionList list; | |
| 339 char _post[64]; | |
| 340 }; | |
| 341 ParCleanupThreadState** _par_cleanup_thread_state; | |
| 342 | |
| 343 // CMS marking support structures | |
| 344 CMBitMap _markBitMap1; | |
| 345 CMBitMap _markBitMap2; | |
| 346 CMBitMapRO* _prevMarkBitMap; // completed mark bitmap | |
| 347 CMBitMap* _nextMarkBitMap; // under-construction mark bitmap | |
| 348 bool _at_least_one_mark_complete; | |
| 349 | |
| 350 BitMap _region_bm; | |
| 351 BitMap _card_bm; | |
| 352 | |
| 353 // Heap bounds | |
| 354 HeapWord* _heap_start; | |
| 355 HeapWord* _heap_end; | |
| 356 | |
| 357 // For gray objects | |
| 358 CMMarkStack _markStack; // Grey objects behind global finger. | |
| 359 CMRegionStack _regionStack; // Grey regions behind global finger. | |
| 360 HeapWord* volatile _finger; // the global finger, region aligned, | |
| 361 // always points to the end of the | |
| 362 // last claimed region | |
| 363 | |
| 364 // marking tasks | |
| 365 size_t _max_task_num; // maximum task number | |
| 366 size_t _active_tasks; // task num currently active | |
| 367 CMTask** _tasks; // task queue array (max_task_num len) | |
| 368 CMTaskQueueSet* _task_queues; // task queue set | |
| 369 ParallelTaskTerminator _terminator; // for termination | |
| 370 | |
| 371 // Two sync barriers that are used to synchronise tasks when an | |
| 372 // overflow occurs. The algorithm is the following. All tasks enter | |
| 373 // the first one to ensure that they have all stopped manipulating | |
| 374 // the global data structures. After they exit it, they re-initialise | |
| 375 // their data structures and task 0 re-initialises the global data | |
| 376 // structures. Then, they enter the second sync barrier. This | |
| 377 // ensure, that no task starts doing work before all data | |
| 378 // structures (local and global) have been re-initialised. When they | |
| 379 // exit it, they are free to start working again. | |
| 380 WorkGangBarrierSync _first_overflow_barrier_sync; | |
| 381 WorkGangBarrierSync _second_overflow_barrier_sync; | |
| 382 | |
| 383 | |
| 384 // this is set by any task, when an overflow on the global data | |
| 385 // structures is detected. | |
| 386 volatile bool _has_overflown; | |
| 387 // true: marking is concurrent, false: we're in remark | |
| 388 volatile bool _concurrent; | |
| 389 // set at the end of a Full GC so that marking aborts | |
| 390 volatile bool _has_aborted; | |
| 391 // used when remark aborts due to an overflow to indicate that | |
| 392 // another concurrent marking phase should start | |
| 393 volatile bool _restart_for_overflow; | |
| 394 | |
| 395 // This is true from the very start of concurrent marking until the | |
| 396 // point when all the tasks complete their work. It is really used | |
| 397 // to determine the points between the end of concurrent marking and | |
| 398 // time of remark. | |
| 399 volatile bool _concurrent_marking_in_progress; | |
| 400 | |
| 401 // verbose level | |
| 402 CMVerboseLevel _verbose_level; | |
| 403 | |
| 404 // These two fields are used to implement the optimisation that | |
| 405 // avoids pushing objects on the global/region stack if there are | |
| 406 // no collection set regions above the lowest finger. | |
| 407 | |
| 408 // This is the lowest finger (among the global and local fingers), | |
| 409 // which is calculated before a new collection set is chosen. | |
| 410 HeapWord* _min_finger; | |
| 411 // If this flag is true, objects/regions that are marked below the | |
| 412 // finger should be pushed on the stack(s). If this is flag is | |
| 413 // false, it is safe not to push them on the stack(s). | |
| 414 bool _should_gray_objects; | |
| 415 | |
| 416 // All of these times are in ms. | |
| 417 NumberSeq _init_times; | |
| 418 NumberSeq _remark_times; | |
| 419 NumberSeq _remark_mark_times; | |
| 420 NumberSeq _remark_weak_ref_times; | |
| 421 NumberSeq _cleanup_times; | |
| 422 double _total_counting_time; | |
| 423 double _total_rs_scrub_time; | |
| 424 | |
| 425 double* _accum_task_vtime; // accumulated task vtime | |
| 426 | |
| 427 WorkGang* _parallel_workers; | |
| 428 | |
| 429 void weakRefsWork(bool clear_all_soft_refs); | |
| 430 | |
| 431 void swapMarkBitMaps(); | |
| 432 | |
| 433 // It resets the global marking data structures, as well as the | |
| 434 // task local ones; should be called during initial mark. | |
| 435 void reset(); | |
| 436 // It resets all the marking data structures. | |
| 437 void clear_marking_state(); | |
| 438 | |
| 439 // It should be called to indicate which phase we're in (concurrent | |
| 440 // mark or remark) and how many threads are currently active. | |
| 441 void set_phase(size_t active_tasks, bool concurrent); | |
| 442 // We do this after we're done with marking so that the marking data | |
| 443 // structures are initialised to a sensible and predictable state. | |
| 444 void set_non_marking_state(); | |
| 445 | |
| 446 // prints all gathered CM-related statistics | |
| 447 void print_stats(); | |
| 448 | |
| 449 // accessor methods | |
| 450 size_t parallel_marking_threads() { return _parallel_marking_threads; } | |
| 451 double sleep_factor() { return _sleep_factor; } | |
| 452 double marking_task_overhead() { return _marking_task_overhead;} | |
| 453 double cleanup_sleep_factor() { return _cleanup_sleep_factor; } | |
| 454 double cleanup_task_overhead() { return _cleanup_task_overhead;} | |
| 455 | |
| 456 HeapWord* finger() { return _finger; } | |
| 457 bool concurrent() { return _concurrent; } | |
| 458 size_t active_tasks() { return _active_tasks; } | |
| 459 ParallelTaskTerminator* terminator() { return &_terminator; } | |
| 460 | |
| 461 // It claims the next available region to be scanned by a marking | |
| 462 // task. It might return NULL if the next region is empty or we have | |
| 463 // run out of regions. In the latter case, out_of_regions() | |
| 464 // determines whether we've really run out of regions or the task | |
| 465 // should call claim_region() again. This might seem a bit | |
| 466 // awkward. Originally, the code was written so that claim_region() | |
| 467 // either successfully returned with a non-empty region or there | |
| 468 // were no more regions to be claimed. The problem with this was | |
| 469 // that, in certain circumstances, it iterated over large chunks of | |
| 470 // the heap finding only empty regions and, while it was working, it | |
| 471 // was preventing the calling task to call its regular clock | |
| 472 // method. So, this way, each task will spend very little time in | |
| 473 // claim_region() and is allowed to call the regular clock method | |
| 474 // frequently. | |
| 475 HeapRegion* claim_region(int task); | |
| 476 | |
| 477 // It determines whether we've run out of regions to scan. | |
| 478 bool out_of_regions() { return _finger == _heap_end; } | |
| 479 | |
| 480 // Returns the task with the given id | |
| 481 CMTask* task(int id) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
482 assert(0 <= id && id < (int) _active_tasks, |
|
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
483 "task id not within active bounds"); |
| 342 | 484 return _tasks[id]; |
| 485 } | |
| 486 | |
| 487 // Returns the task queue with the given id | |
| 488 CMTaskQueue* task_queue(int id) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
489 assert(0 <= id && id < (int) _active_tasks, |
|
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
490 "task queue id not within active bounds"); |
| 342 | 491 return (CMTaskQueue*) _task_queues->queue(id); |
| 492 } | |
| 493 | |
| 494 // Returns the task queue set | |
| 495 CMTaskQueueSet* task_queues() { return _task_queues; } | |
| 496 | |
| 497 // Access / manipulation of the overflow flag which is set to | |
| 498 // indicate that the global stack or region stack has overflown | |
| 499 bool has_overflown() { return _has_overflown; } | |
| 500 void set_has_overflown() { _has_overflown = true; } | |
| 501 void clear_has_overflown() { _has_overflown = false; } | |
| 502 | |
| 503 bool has_aborted() { return _has_aborted; } | |
| 504 bool restart_for_overflow() { return _restart_for_overflow; } | |
| 505 | |
| 506 // Methods to enter the two overflow sync barriers | |
| 507 void enter_first_sync_barrier(int task_num); | |
| 508 void enter_second_sync_barrier(int task_num); | |
| 509 | |
| 510 public: | |
| 511 // Manipulation of the global mark stack. | |
| 512 // Notice that the first mark_stack_push is CAS-based, whereas the | |
| 513 // two below are Mutex-based. This is OK since the first one is only | |
| 514 // called during evacuation pauses and doesn't compete with the | |
| 515 // other two (which are called by the marking tasks during | |
| 516 // concurrent marking or remark). | |
| 517 bool mark_stack_push(oop p) { | |
| 518 _markStack.par_push(p); | |
| 519 if (_markStack.overflow()) { | |
| 520 set_has_overflown(); | |
| 521 return false; | |
| 522 } | |
| 523 return true; | |
| 524 } | |
| 525 bool mark_stack_push(oop* arr, int n) { | |
| 526 _markStack.par_push_arr(arr, n); | |
| 527 if (_markStack.overflow()) { | |
| 528 set_has_overflown(); | |
| 529 return false; | |
| 530 } | |
| 531 return true; | |
| 532 } | |
| 533 void mark_stack_pop(oop* arr, int max, int* n) { | |
| 534 _markStack.par_pop_arr(arr, max, n); | |
| 535 } | |
| 536 size_t mark_stack_size() { return _markStack.size(); } | |
| 537 size_t partial_mark_stack_size_target() { return _markStack.maxElems()/3; } | |
| 538 bool mark_stack_overflow() { return _markStack.overflow(); } | |
| 539 bool mark_stack_empty() { return _markStack.isEmpty(); } | |
| 540 | |
| 541 // Manipulation of the region stack | |
| 542 bool region_stack_push(MemRegion mr) { | |
| 543 _regionStack.push(mr); | |
| 544 if (_regionStack.overflow()) { | |
| 545 set_has_overflown(); | |
| 546 return false; | |
| 547 } | |
| 548 return true; | |
| 549 } | |
| 550 MemRegion region_stack_pop() { return _regionStack.pop(); } | |
| 551 int region_stack_size() { return _regionStack.size(); } | |
| 552 bool region_stack_overflow() { return _regionStack.overflow(); } | |
| 553 bool region_stack_empty() { return _regionStack.isEmpty(); } | |
| 554 | |
| 555 bool concurrent_marking_in_progress() { | |
| 556 return _concurrent_marking_in_progress; | |
| 557 } | |
| 558 void set_concurrent_marking_in_progress() { | |
| 559 _concurrent_marking_in_progress = true; | |
| 560 } | |
| 561 void clear_concurrent_marking_in_progress() { | |
| 562 _concurrent_marking_in_progress = false; | |
| 563 } | |
| 564 | |
| 565 void update_accum_task_vtime(int i, double vtime) { | |
| 566 _accum_task_vtime[i] += vtime; | |
| 567 } | |
| 568 | |
| 569 double all_task_accum_vtime() { | |
| 570 double ret = 0.0; | |
| 571 for (int i = 0; i < (int)_max_task_num; ++i) | |
| 572 ret += _accum_task_vtime[i]; | |
| 573 return ret; | |
| 574 } | |
| 575 | |
| 576 // Attempts to steal an object from the task queues of other tasks | |
| 577 bool try_stealing(int task_num, int* hash_seed, oop& obj) { | |
| 578 return _task_queues->steal(task_num, hash_seed, obj); | |
| 579 } | |
| 580 | |
| 581 // It grays an object by first marking it. Then, if it's behind the | |
| 582 // global finger, it also pushes it on the global stack. | |
| 583 void deal_with_reference(oop obj); | |
| 584 | |
| 585 ConcurrentMark(ReservedSpace rs, int max_regions); | |
| 586 ~ConcurrentMark(); | |
| 587 ConcurrentMarkThread* cmThread() { return _cmThread; } | |
| 588 | |
| 589 CMBitMapRO* prevMarkBitMap() const { return _prevMarkBitMap; } | |
| 590 CMBitMap* nextMarkBitMap() const { return _nextMarkBitMap; } | |
| 591 | |
| 592 // The following three are interaction between CM and | |
| 593 // G1CollectedHeap | |
| 594 | |
| 595 // This notifies CM that a root during initial-mark needs to be | |
| 596 // grayed and it's MT-safe. Currently, we just mark it. But, in the | |
| 597 // future, we can experiment with pushing it on the stack and we can | |
| 598 // do this without changing G1CollectedHeap. | |
| 599 void grayRoot(oop p); | |
| 600 // It's used during evacuation pauses to gray a region, if | |
| 601 // necessary, and it's MT-safe. It assumes that the caller has | |
| 602 // marked any objects on that region. If _should_gray_objects is | |
| 603 // true and we're still doing concurrent marking, the region is | |
| 604 // pushed on the region stack, if it is located below the global | |
| 605 // finger, otherwise we do nothing. | |
| 606 void grayRegionIfNecessary(MemRegion mr); | |
| 607 // It's used during evacuation pauses to mark and, if necessary, | |
| 608 // gray a single object and it's MT-safe. It assumes the caller did | |
| 609 // not mark the object. If _should_gray_objects is true and we're | |
| 610 // still doing concurrent marking, the objects is pushed on the | |
| 611 // global stack, if it is located below the global finger, otherwise | |
| 612 // we do nothing. | |
| 613 void markAndGrayObjectIfNecessary(oop p); | |
| 614 | |
| 1044 | 615 // This iterates over the marking bitmap (either prev or next) and |
| 616 // prints out all objects that are marked on the bitmap and indicates | |
| 617 // whether what they point to is also marked or not. It also iterates | |
| 618 // the objects over TAMS (either prev or next). | |
| 619 void print_reachable(bool use_prev_marking, const char* str); | |
| 342 | 620 |
| 621 // Clear the next marking bitmap (will be called concurrently). | |
| 622 void clearNextBitmap(); | |
| 623 | |
| 624 // main CMS steps and related support | |
| 625 void checkpointRootsInitial(); | |
| 626 | |
| 627 // These two do the work that needs to be done before and after the | |
| 628 // initial root checkpoint. Since this checkpoint can be done at two | |
| 629 // different points (i.e. an explicit pause or piggy-backed on a | |
| 630 // young collection), then it's nice to be able to easily share the | |
| 631 // pre/post code. It might be the case that we can put everything in | |
| 632 // the post method. TP | |
| 633 void checkpointRootsInitialPre(); | |
| 634 void checkpointRootsInitialPost(); | |
| 635 | |
| 636 // Do concurrent phase of marking, to a tentative transitive closure. | |
| 637 void markFromRoots(); | |
| 638 | |
| 639 // Process all unprocessed SATB buffers. It is called at the | |
| 640 // beginning of an evacuation pause. | |
| 641 void drainAllSATBBuffers(); | |
| 642 | |
| 643 void checkpointRootsFinal(bool clear_all_soft_refs); | |
| 644 void checkpointRootsFinalWork(); | |
| 645 void calcDesiredRegions(); | |
| 646 void cleanup(); | |
| 647 void completeCleanup(); | |
| 648 | |
| 649 // Mark in the previous bitmap. NB: this is usually read-only, so use | |
| 650 // this carefully! | |
| 651 void markPrev(oop p); | |
| 652 void clear(oop p); | |
| 653 // Clears marks for all objects in the given range, for both prev and | |
| 654 // next bitmaps. NB: the previous bitmap is usually read-only, so use | |
| 655 // this carefully! | |
| 656 void clearRangeBothMaps(MemRegion mr); | |
| 657 | |
| 658 // Record the current top of the mark and region stacks; a | |
| 659 // subsequent oops_do() on the mark stack and | |
| 660 // invalidate_entries_into_cset() on the region stack will iterate | |
| 661 // only over indices valid at the time of this call. | |
| 662 void set_oops_do_bound() { | |
| 663 _markStack.set_oops_do_bound(); | |
| 664 _regionStack.set_oops_do_bound(); | |
| 665 } | |
| 666 // Iterate over the oops in the mark stack and all local queues. It | |
| 667 // also calls invalidate_entries_into_cset() on the region stack. | |
| 668 void oops_do(OopClosure* f); | |
| 669 // It is called at the end of an evacuation pause during marking so | |
| 670 // that CM is notified of where the new end of the heap is. It | |
| 671 // doesn't do anything if concurrent_marking_in_progress() is false, | |
| 672 // unless the force parameter is true. | |
| 673 void update_g1_committed(bool force = false); | |
| 674 | |
| 675 void complete_marking_in_collection_set(); | |
| 676 | |
| 677 // It indicates that a new collection set is being chosen. | |
| 678 void newCSet(); | |
| 679 // It registers a collection set heap region with CM. This is used | |
| 680 // to determine whether any heap regions are located above the finger. | |
| 681 void registerCSetRegion(HeapRegion* hr); | |
| 682 | |
| 683 // Returns "true" if at least one mark has been completed. | |
| 684 bool at_least_one_mark_complete() { return _at_least_one_mark_complete; } | |
| 685 | |
| 686 bool isMarked(oop p) const { | |
| 687 assert(p != NULL && p->is_oop(), "expected an oop"); | |
| 688 HeapWord* addr = (HeapWord*)p; | |
| 689 assert(addr >= _nextMarkBitMap->startWord() || | |
| 690 addr < _nextMarkBitMap->endWord(), "in a region"); | |
| 691 | |
| 692 return _nextMarkBitMap->isMarked(addr); | |
| 693 } | |
| 694 | |
| 695 inline bool not_yet_marked(oop p) const; | |
| 696 | |
| 697 // XXX Debug code | |
| 698 bool containing_card_is_marked(void* p); | |
| 699 bool containing_cards_are_marked(void* start, void* last); | |
| 700 | |
| 701 bool isPrevMarked(oop p) const { | |
| 702 assert(p != NULL && p->is_oop(), "expected an oop"); | |
| 703 HeapWord* addr = (HeapWord*)p; | |
| 704 assert(addr >= _prevMarkBitMap->startWord() || | |
| 705 addr < _prevMarkBitMap->endWord(), "in a region"); | |
| 706 | |
| 707 return _prevMarkBitMap->isMarked(addr); | |
| 708 } | |
| 709 | |
| 710 inline bool do_yield_check(int worker_i = 0); | |
| 711 inline bool should_yield(); | |
| 712 | |
| 713 // Called to abort the marking cycle after a Full GC takes palce. | |
| 714 void abort(); | |
| 715 | |
| 716 // This prints the global/local fingers. It is used for debugging. | |
| 717 NOT_PRODUCT(void print_finger();) | |
| 718 | |
| 719 void print_summary_info(); | |
| 720 | |
| 1019 | 721 void print_worker_threads_on(outputStream* st) const; |
| 722 | |
| 342 | 723 // The following indicate whether a given verbose level has been |
| 724 // set. Notice that anything above stats is conditional to | |
| 725 // _MARKING_VERBOSE_ having been set to 1 | |
| 726 bool verbose_stats() | |
| 727 { return _verbose_level >= stats_verbose; } | |
| 728 bool verbose_low() | |
| 729 { return _MARKING_VERBOSE_ && _verbose_level >= low_verbose; } | |
| 730 bool verbose_medium() | |
| 731 { return _MARKING_VERBOSE_ && _verbose_level >= medium_verbose; } | |
| 732 bool verbose_high() | |
| 733 { return _MARKING_VERBOSE_ && _verbose_level >= high_verbose; } | |
| 734 }; | |
| 735 | |
| 736 // A class representing a marking task. | |
| 737 class CMTask : public TerminatorTerminator { | |
| 738 private: | |
| 739 enum PrivateConstants { | |
| 740 // the regular clock call is called once the scanned words reaches | |
| 741 // this limit | |
| 742 words_scanned_period = 12*1024, | |
| 743 // the regular clock call is called once the number of visited | |
| 744 // references reaches this limit | |
| 745 refs_reached_period = 384, | |
| 746 // initial value for the hash seed, used in the work stealing code | |
| 747 init_hash_seed = 17, | |
| 748 // how many entries will be transferred between global stack and | |
| 749 // local queues | |
| 750 global_stack_transfer_size = 16 | |
| 751 }; | |
| 752 | |
| 753 int _task_id; | |
| 754 G1CollectedHeap* _g1h; | |
| 755 ConcurrentMark* _cm; | |
| 756 CMBitMap* _nextMarkBitMap; | |
| 757 // the task queue of this task | |
| 758 CMTaskQueue* _task_queue; | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
759 private: |
| 342 | 760 // the task queue set---needed for stealing |
| 761 CMTaskQueueSet* _task_queues; | |
| 762 // indicates whether the task has been claimed---this is only for | |
| 763 // debugging purposes | |
| 764 bool _claimed; | |
| 765 | |
| 766 // number of calls to this task | |
| 767 int _calls; | |
| 768 | |
| 769 // when the virtual timer reaches this time, the marking step should | |
| 770 // exit | |
| 771 double _time_target_ms; | |
| 772 // the start time of the current marking step | |
| 773 double _start_time_ms; | |
| 774 | |
| 775 // the oop closure used for iterations over oops | |
| 776 OopClosure* _oop_closure; | |
| 777 | |
| 778 // the region this task is scanning, NULL if we're not scanning any | |
| 779 HeapRegion* _curr_region; | |
| 780 // the local finger of this task, NULL if we're not scanning a region | |
| 781 HeapWord* _finger; | |
| 782 // limit of the region this task is scanning, NULL if we're not scanning one | |
| 783 HeapWord* _region_limit; | |
| 784 | |
| 785 // This is used only when we scan regions popped from the region | |
| 786 // stack. It records what the last object on such a region we | |
| 787 // scanned was. It is used to ensure that, if we abort region | |
| 788 // iteration, we do not rescan the first part of the region. This | |
| 789 // should be NULL when we're not scanning a region from the region | |
| 790 // stack. | |
| 791 HeapWord* _region_finger; | |
| 792 | |
| 793 // the number of words this task has scanned | |
| 794 size_t _words_scanned; | |
| 795 // When _words_scanned reaches this limit, the regular clock is | |
| 796 // called. Notice that this might be decreased under certain | |
| 797 // circumstances (i.e. when we believe that we did an expensive | |
| 798 // operation). | |
| 799 size_t _words_scanned_limit; | |
| 800 // the initial value of _words_scanned_limit (i.e. what it was | |
| 801 // before it was decreased). | |
| 802 size_t _real_words_scanned_limit; | |
| 803 | |
| 804 // the number of references this task has visited | |
| 805 size_t _refs_reached; | |
| 806 // When _refs_reached reaches this limit, the regular clock is | |
| 807 // called. Notice this this might be decreased under certain | |
| 808 // circumstances (i.e. when we believe that we did an expensive | |
| 809 // operation). | |
| 810 size_t _refs_reached_limit; | |
| 811 // the initial value of _refs_reached_limit (i.e. what it was before | |
| 812 // it was decreased). | |
| 813 size_t _real_refs_reached_limit; | |
| 814 | |
| 815 // used by the work stealing stuff | |
| 816 int _hash_seed; | |
| 817 // if this is true, then the task has aborted for some reason | |
| 818 bool _has_aborted; | |
| 819 // set when the task aborts because it has met its time quota | |
| 820 bool _has_aborted_timed_out; | |
| 821 // true when we're draining SATB buffers; this avoids the task | |
| 822 // aborting due to SATB buffers being available (as we're already | |
| 823 // dealing with them) | |
| 824 bool _draining_satb_buffers; | |
| 825 | |
| 826 // number sequence of past step times | |
| 827 NumberSeq _step_times_ms; | |
| 828 // elapsed time of this task | |
| 829 double _elapsed_time_ms; | |
| 830 // termination time of this task | |
| 831 double _termination_time_ms; | |
| 832 // when this task got into the termination protocol | |
| 833 double _termination_start_time_ms; | |
| 834 | |
| 835 // true when the task is during a concurrent phase, false when it is | |
| 836 // in the remark phase (so, in the latter case, we do not have to | |
| 837 // check all the things that we have to check during the concurrent | |
| 838 // phase, i.e. SATB buffer availability...) | |
| 839 bool _concurrent; | |
| 840 | |
| 841 TruncatedSeq _marking_step_diffs_ms; | |
| 842 | |
| 843 // LOTS of statistics related with this task | |
| 844 #if _MARKING_STATS_ | |
| 845 NumberSeq _all_clock_intervals_ms; | |
| 846 double _interval_start_time_ms; | |
| 847 | |
| 848 int _aborted; | |
| 849 int _aborted_overflow; | |
| 850 int _aborted_cm_aborted; | |
| 851 int _aborted_yield; | |
| 852 int _aborted_timed_out; | |
| 853 int _aborted_satb; | |
| 854 int _aborted_termination; | |
| 855 | |
| 856 int _steal_attempts; | |
| 857 int _steals; | |
| 858 | |
| 859 int _clock_due_to_marking; | |
| 860 int _clock_due_to_scanning; | |
| 861 | |
| 862 int _local_pushes; | |
| 863 int _local_pops; | |
| 864 int _local_max_size; | |
| 865 int _objs_scanned; | |
| 866 | |
| 867 int _global_pushes; | |
| 868 int _global_pops; | |
| 869 int _global_max_size; | |
| 870 | |
| 871 int _global_transfers_to; | |
| 872 int _global_transfers_from; | |
| 873 | |
| 874 int _region_stack_pops; | |
| 875 | |
| 876 int _regions_claimed; | |
| 877 int _objs_found_on_bitmap; | |
| 878 | |
| 879 int _satb_buffers_processed; | |
| 880 #endif // _MARKING_STATS_ | |
| 881 | |
| 882 // it updates the local fields after this task has claimed | |
| 883 // a new region to scan | |
| 884 void setup_for_region(HeapRegion* hr); | |
| 885 // it brings up-to-date the limit of the region | |
| 886 void update_region_limit(); | |
| 887 // it resets the local fields after a task has finished scanning a | |
| 888 // region | |
| 889 void giveup_current_region(); | |
| 890 | |
| 891 // called when either the words scanned or the refs visited limit | |
| 892 // has been reached | |
| 893 void reached_limit(); | |
| 894 // recalculates the words scanned and refs visited limits | |
| 895 void recalculate_limits(); | |
| 896 // decreases the words scanned and refs visited limits when we reach | |
| 897 // an expensive operation | |
| 898 void decrease_limits(); | |
| 899 // it checks whether the words scanned or refs visited reached their | |
| 900 // respective limit and calls reached_limit() if they have | |
| 901 void check_limits() { | |
| 902 if (_words_scanned >= _words_scanned_limit || | |
| 903 _refs_reached >= _refs_reached_limit) | |
| 904 reached_limit(); | |
| 905 } | |
| 906 // this is supposed to be called regularly during a marking step as | |
| 907 // it checks a bunch of conditions that might cause the marking step | |
| 908 // to abort | |
| 909 void regular_clock_call(); | |
| 910 bool concurrent() { return _concurrent; } | |
| 911 | |
| 912 public: | |
| 913 // It resets the task; it should be called right at the beginning of | |
| 914 // a marking phase. | |
| 915 void reset(CMBitMap* _nextMarkBitMap); | |
| 916 // it clears all the fields that correspond to a claimed region. | |
| 917 void clear_region_fields(); | |
| 918 | |
| 919 void set_concurrent(bool concurrent) { _concurrent = concurrent; } | |
| 920 | |
| 921 // The main method of this class which performs a marking step | |
| 922 // trying not to exceed the given duration. However, it might exit | |
| 923 // prematurely, according to some conditions (i.e. SATB buffers are | |
| 924 // available for processing). | |
| 925 void do_marking_step(double target_ms); | |
| 926 | |
| 927 // These two calls start and stop the timer | |
| 928 void record_start_time() { | |
| 929 _elapsed_time_ms = os::elapsedTime() * 1000.0; | |
| 930 } | |
| 931 void record_end_time() { | |
| 932 _elapsed_time_ms = os::elapsedTime() * 1000.0 - _elapsed_time_ms; | |
| 933 } | |
| 934 | |
| 935 // returns the task ID | |
| 936 int task_id() { return _task_id; } | |
| 937 | |
| 938 // From TerminatorTerminator. It determines whether this task should | |
| 939 // exit the termination protocol after it's entered it. | |
| 940 virtual bool should_exit_termination(); | |
| 941 | |
| 942 HeapWord* finger() { return _finger; } | |
| 943 | |
| 944 bool has_aborted() { return _has_aborted; } | |
| 945 void set_has_aborted() { _has_aborted = true; } | |
| 946 void clear_has_aborted() { _has_aborted = false; } | |
| 947 bool claimed() { return _claimed; } | |
| 948 | |
| 949 void set_oop_closure(OopClosure* oop_closure) { | |
| 950 _oop_closure = oop_closure; | |
| 951 } | |
| 952 | |
| 953 // It grays the object by marking it and, if necessary, pushing it | |
| 954 // on the local queue | |
| 955 void deal_with_reference(oop obj); | |
| 956 | |
| 957 // It scans an object and visits its children. | |
| 958 void scan_object(oop obj) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
959 assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant"); |
| 342 | 960 |
| 961 if (_cm->verbose_high()) | |
| 962 gclog_or_tty->print_cr("[%d] we're scanning object "PTR_FORMAT, | |
| 963 _task_id, (void*) obj); | |
| 964 | |
| 965 size_t obj_size = obj->size(); | |
| 966 _words_scanned += obj_size; | |
| 967 | |
| 968 obj->oop_iterate(_oop_closure); | |
| 969 statsOnly( ++_objs_scanned ); | |
| 970 check_limits(); | |
| 971 } | |
| 972 | |
| 973 // It pushes an object on the local queue. | |
| 974 void push(oop obj); | |
| 975 | |
| 976 // These two move entries to/from the global stack. | |
| 977 void move_entries_to_global_stack(); | |
| 978 void get_entries_from_global_stack(); | |
| 979 | |
| 980 // It pops and scans objects from the local queue. If partially is | |
| 981 // true, then it stops when the queue size is of a given limit. If | |
| 982 // partially is false, then it stops when the queue is empty. | |
| 983 void drain_local_queue(bool partially); | |
| 984 // It moves entries from the global stack to the local queue and | |
| 985 // drains the local queue. If partially is true, then it stops when | |
| 986 // both the global stack and the local queue reach a given size. If | |
| 987 // partially if false, it tries to empty them totally. | |
| 988 void drain_global_stack(bool partially); | |
| 989 // It keeps picking SATB buffers and processing them until no SATB | |
| 990 // buffers are available. | |
| 991 void drain_satb_buffers(); | |
| 992 // It keeps popping regions from the region stack and processing | |
| 993 // them until the region stack is empty. | |
| 994 void drain_region_stack(BitMapClosure* closure); | |
| 995 | |
| 996 // moves the local finger to a new location | |
| 997 inline void move_finger_to(HeapWord* new_finger) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
998 assert(new_finger >= _finger && new_finger < _region_limit, "invariant"); |
| 342 | 999 _finger = new_finger; |
| 1000 } | |
| 1001 | |
| 1002 // moves the region finger to a new location | |
| 1003 inline void move_region_finger_to(HeapWord* new_finger) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
1004 assert(new_finger < _cm->finger(), "invariant"); |
| 342 | 1005 _region_finger = new_finger; |
| 1006 } | |
| 1007 | |
| 1008 CMTask(int task_num, ConcurrentMark *cm, | |
| 1009 CMTaskQueue* task_queue, CMTaskQueueSet* task_queues); | |
| 1010 | |
| 1011 // it prints statistics associated with this task | |
| 1012 void print_stats(); | |
| 1013 | |
| 1014 #if _MARKING_STATS_ | |
| 1015 void increase_objs_found_on_bitmap() { ++_objs_found_on_bitmap; } | |
| 1016 #endif // _MARKING_STATS_ | |
| 1017 }; |