annotate src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 2165:0fa27f37d4d4

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