truffle: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 3776:23d434c6290d

7055073: G1: code cleanup in the concurrentMark.* files Summary: Only cosmetic changes to make the concurrentMark.* more consistent, code-style-wise, with the rest of the codebase. Reviewed-by: johnc, ysr

author	tonyp
date	Mon, 20 Jun 2011 22:03:13 -0400
parents	6747fd0512e0
children	5f6f2615433a

comparison

equal deleted inserted replaced

-:f75137faa7fe
+:23d434c6290d
 HeapWord* limit) const {
 // First we must round addr *up* to a possible object boundary.
 addr = (HeapWord*)align_size_up((intptr_t)addr,
 HeapWordSize << _shifter);
 size_t addrOffset = heapWordToOffset(addr);
-if (limit == NULL) limit = _bmStartWord + _bmWordSize;
+if (limit == NULL) {
+limit = _bmStartWord + _bmWordSize;
+}
 size_t limitOffset = heapWordToOffset(limit);
 size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);
 HeapWord* nextAddr = offsetToHeapWord(nextOffset);
 assert(nextAddr >= addr, "get_next_one postcondition");
 assert(nextAddr == limit || isMarked(nextAddr),
 }
 HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(HeapWord* addr,
 HeapWord* limit) const {
 size_t addrOffset = heapWordToOffset(addr);
-if (limit == NULL) limit = _bmStartWord + _bmWordSize;
+if (limit == NULL) {
+limit = _bmStartWord + _bmWordSize;
+}
 size_t limitOffset = heapWordToOffset(limit);
 size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);
 HeapWord* nextAddr = offsetToHeapWord(nextOffset);
 assert(nextAddr >= addr, "get_next_one postcondition");
 assert(nextAddr == limit || !isMarked(nextAddr),
 #endif
 {}
 void CMMarkStack::allocate(size_t size) {
 _base = NEW_C_HEAP_ARRAY(oop, size);
-if (_base == NULL)
+if (_base == NULL) {
 vm_exit_during_initialization("Failed to allocate "
 "CM region mark stack");
+}
 _index = 0;
-// QQQQ cast ...
 _capacity = (jint) size;
 _oops_do_bound = -1;
 NOT_PRODUCT(_max_depth = 0);
 }
 CMMarkStack::~CMMarkStack() {
-if (_base != NULL) FREE_C_HEAP_ARRAY(oop, _base);
+if (_base != NULL) {
+FREE_C_HEAP_ARRAY(oop, _base);
+}
 }
 void CMMarkStack::par_push(oop ptr) {
 while (true) {
 if (isFull()) {
 CMRegionStack::CMRegionStack() : _base(NULL) {}
 void CMRegionStack::allocate(size_t size) {
 _base = NEW_C_HEAP_ARRAY(MemRegion, size);
-if (_base == NULL)
+if (_base == NULL) {
-vm_exit_during_initialization("Failed to allocate "
+vm_exit_during_initialization("Failed to allocate CM region mark stack");
-"CM region mark stack");
+}
 _index = 0;
-// QQQQ cast ...
 _capacity = (jint) size;
 }
 CMRegionStack::~CMRegionStack() {
-if (_base != NULL) FREE_C_HEAP_ARRAY(oop, _base);
+if (_base != NULL) {
+FREE_C_HEAP_ARRAY(oop, _base);
+}
 }
 void CMRegionStack::push_lock_free(MemRegion mr) {
 assert(mr.word_size() > 0, "Precondition");
 while (true) {
 "only grey objects on this stack");
 // iterate over the oops in this oop, marking and pushing
 // the ones in CMS generation.
 newOop->oop_iterate(cl);
 if (yield_after && _cm->do_yield_check()) {
-res = false; break;
+res = false;
+break;
 }
 }
 debug_only(_drain_in_progress = false);
 return res;
 }
 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
 _cleanup_times(),
 _total_counting_time(0.0),
 _total_rs_scrub_time(0.0),
-_parallel_workers(NULL)
+_parallel_workers(NULL) {
-{
+CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel;
-CMVerboseLevel verbose_level =
+if (verbose_level < no_verbose) {
-(CMVerboseLevel) G1MarkingVerboseLevel;
-if (verbose_level < no_verbose)
 verbose_level = no_verbose;
-if (verbose_level > high_verbose)
+}
+if (verbose_level > high_verbose) {
 verbose_level = high_verbose;
+}
 _verbose_level = verbose_level;
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
 "heap end = "PTR_FORMAT, _heap_start, _heap_end);
+}
 _markStack.allocate(MarkStackSize);
 _regionStack.allocate(G1MarkRegionStackSize);
 // Create & start a ConcurrentMark thread.
 _parallel_marking_threads = MAX2((ParallelGCThreads + 2) / 4, (size_t)1);
 _sleep_factor             = 0.0;
 _marking_task_overhead    = 1.0;
 }
-if (parallel_marking_threads() > 1)
+if (parallel_marking_threads() > 1) {
 _cleanup_task_overhead = 1.0;
-else
+} else {
 _cleanup_task_overhead = marking_task_overhead();
+}
 _cleanup_sleep_factor =
 (1.0 - cleanup_task_overhead()) / cleanup_task_overhead();
 #if 0
 gclog_or_tty->print_cr("Marking Threads          %d", parallel_marking_threads());
 // second one could unnecessarily push regions on the region
 // stack. This causes the invariant that the region stack is empty
 // at the beginning of remark to be false. By ensuring that we do
 // not observe heap expansions after marking is complete, then we do
 // not have this problem.
-if (!concurrent_marking_in_progress() && !force)
+if (!concurrent_marking_in_progress() && !force) return;
-return;
 MemRegion committed = _g1h->g1_committed();
 assert(committed.start() == _heap_start, "start shouldn't change");
 HeapWord* new_end = committed.end();
 if (new_end > _heap_end) {
 assert(_heap_start < _heap_end, "heap bounds should look ok");
 // reset all the marking data structures and any necessary flags
 clear_marking_state();
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] resetting");
+}
 // We do reset all of them, since different phases will use
 // different number of active threads. So, it's easiest to have all
 // of them ready.
 for (int i = 0; i < (int) _max_task_num; ++i) {
 HeapWord* end    = _nextMarkBitMap->endWord();
 HeapWord* cur    = start;
 size_t chunkSize = M;
 while (cur < end) {
 HeapWord* next = cur + chunkSize;
-if (next > end)
+if (next > end) {
 next = end;
+}
 MemRegion mr(cur,next);
 _nextMarkBitMap->clearRange(mr);
 cur = next;
 do_yield_check();
 * barrier is one of the last things do_marking_step() does, and it
 * doesn't manipulate any data structures afterwards.
 */
 void ConcurrentMark::enter_first_sync_barrier(int task_num) {
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] entering first barrier", task_num);
+}
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
 _first_overflow_barrier_sync.enter();
 ConcurrentGCThread::stsJoin();
 }
 // at this point everyone should have synced up and not be doing any
 // more work
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] leaving first barrier", task_num);
+}
 // let task 0 do this
 if (task_num == 0) {
 // task 0 is responsible for clearing the global data structures
 // We should be here because of an overflow. During STW we should
 // after this, each task should reset its own data structures then
 // then go into the second barrier
 }
 void ConcurrentMark::enter_second_sync_barrier(int task_num) {
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] entering second barrier", task_num);
+}
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
 _second_overflow_barrier_sync.enter();
 if (concurrent()) {
 ConcurrentGCThread::stsJoin();
 }
 // at this point everything should be re-initialised and ready to go
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] leaving second barrier", task_num);
+}
 }
 #ifndef PRODUCT
 void ForceOverflowSettings::init() {
 _num_remaining = G1ConcMarkForceOverflow;
 // pause without CM observing this change. So the assertions below
 // is a bit conservative; but better than nothing.
 assert(_g1h->g1_committed().contains(addr),
 "address should be within the heap bounds");
-if (!_nextMarkBitMap->isMarked(addr))
+if (!_nextMarkBitMap->isMarked(addr)) {
 _nextMarkBitMap->parMark(addr);
+}
 }
 void ConcurrentMark::grayRegionIfNecessary(MemRegion mr) {
 // The objects on the region have already been marked "in bulk" by
 // the caller. We only need to decide whether to push the region on
 // the region stack or not.
-if (!concurrent_marking_in_progress() || !_should_gray_objects)
+if (!concurrent_marking_in_progress() || !_should_gray_objects) {
 // We're done with marking and waiting for remark. We do not need to
 // push anything else on the region stack.
 return;
+}
 HeapWord* finger = _finger;
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] attempting to push "
 "region ["PTR_FORMAT", "PTR_FORMAT"), finger is at "
 PTR_FORMAT, mr.start(), mr.end(), finger);
+}
 if (mr.start() < finger) {
 // The finger is always heap region aligned and it is not possible
 // for mr to span heap regions.
 assert(mr.end() <= finger, "invariant");
 "region boundaries should fall within the committed space");
 assert(_heap_start <= mr.start(),
 "region boundaries should fall within the committed space");
 assert(mr.end() <= _heap_end,
 "region boundaries should fall within the committed space");
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] region ["PTR_FORMAT", "PTR_FORMAT") "
 "below the finger, pushing it",
 mr.start(), mr.end());
+}
 if (!region_stack_push_lock_free(mr)) {
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] region stack has overflown.");
+}
 }
 }
 }
 void ConcurrentMark::markAndGrayObjectIfNecessary(oop p) {
 HeapWord* addr = (HeapWord*)p;
 if (!_nextMarkBitMap->isMarked(addr)) {
 // We definitely need to mark it, irrespective whether we bail out
 // because we're done with marking.
 if (_nextMarkBitMap->parMark(addr)) {
-if (!concurrent_marking_in_progress() || !_should_gray_objects)
+if (!concurrent_marking_in_progress() || !_should_gray_objects) {
 // If we're done with concurrent marking and we're waiting for
 // remark, then we're not pushing anything on the stack.
 return;
+}
 // No OrderAccess:store_load() is needed. It is implicit in the
 // CAS done in parMark(addr) above
 HeapWord* finger = _finger;
 if (addr < finger) {
 if (!mark_stack_push(oop(addr))) {
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[global] global stack overflow "
 "during parMark");
+}
 }
 }
 }
 }
 }
 size_t active_workers = MAX2((size_t) 1, parallel_marking_threads());
 force_overflow_conc()->init();
 set_phase(active_workers, true /* concurrent */);
 CMConcurrentMarkingTask markingTask(this, cmThread());
-if (parallel_marking_threads() > 0)
+if (parallel_marking_threads() > 0) {
 _parallel_workers->run_task(&markingTask);
-else
+} else {
 markingTask.work(0);
+}
 print_stats();
 }
 void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
 // world is stopped at this checkpoint
 if (has_overflown()) {
 // Oops.  We overflowed.  Restart concurrent marking.
 _restart_for_overflow = true;
 // Clear the flag. We do not need it any more.
 clear_has_overflown();
-if (G1TraceMarkStackOverflow)
+if (G1TraceMarkStackOverflow) {
 gclog_or_tty->print_cr("\nRemark led to restart for overflow.");
+}
 } else {
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 // We're done with marking.
 // This is the end of  the marking cycle, we're expected all
 // threads to have SATB queues with active set to true.
 // the humongous regions (in case this changes in the future).
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 size_t end_index = index + 1;
 while (end_index < g1h->n_regions()) {
 HeapRegion* chr = g1h->region_at(end_index);
-if (!chr->continuesHumongous()) {
+if (!chr->continuesHumongous()) break;
-break;
-}
 end_index += 1;
 }
 _region_bm->par_at_put_range((BitMap::idx_t) index,
 (BitMap::idx_t) end_index, true);
 }
 }
 bool doHeapRegion(HeapRegion* hr) {
-if (!_final && _regions_done == 0)
+if (!_final && _regions_done == 0) {
 _start_vtime_sec = os::elapsedVTime();
+}
 if (hr->continuesHumongous()) {
 // We will ignore these here and process them when their
 // associated "starts humongous" region is processed (see
 // set_bit_for_heap_region()). Note that we cannot rely on their
 // Find the next marked object after this one.
 start = _bm->getNextMarkedWordAddress(start + 1, nextTop);
 _changed = true;
 }
 // Handle the last range, if any.
-if (start_card_num != -1)
+if (start_card_num != -1) {
 mark_card_num_range(start_card_num, last_card_num);
+}
 if (_final) {
 // Mark the allocated-since-marking portion...
 HeapWord* tp = hr->top();
 if (nextTop < tp) {
 start_card_num =
 size_t *_used_bytes;
 BitMap* _region_bm;
 BitMap* _card_bm;
 public:
 G1ParFinalCountTask(G1CollectedHeap* g1h, CMBitMap* bm,
-BitMap* region_bm, BitMap* card_bm) :
+BitMap* region_bm, BitMap* card_bm)
-AbstractGangTask("G1 final counting"), _g1h(g1h),
+: AbstractGangTask("G1 final counting"), _g1h(g1h),
-_bm(bm), _region_bm(region_bm), _card_bm(card_bm)
+_bm(bm), _region_bm(region_bm), _card_bm(card_bm) {
-{
+if (ParallelGCThreads > 0) {
-if (ParallelGCThreads > 0)
 _n_workers = _g1h->workers()->total_workers();
-else
+} else {
 _n_workers = 1;
+}
 _live_bytes = NEW_C_HEAP_ARRAY(size_t, _n_workers);
 _used_bytes = NEW_C_HEAP_ARRAY(size_t, _n_workers);
 }
 ~G1ParFinalCountTask() {
 _humongous_proxy_set,
 _hrrs_cleanup_task,
 true /* par */);
 double region_time = (os::elapsedTime() - start);
 _claimed_region_time += region_time;
-if (region_time > _max_region_time) _max_region_time = region_time;
+if (region_time > _max_region_time) {
+_max_region_time = region_time;
+}
 }
 return false;
 }
 void ConcurrentMark::cleanup() {
 template <class T> void do_oop_work(T* p) {
 oop obj = oopDesc::load_decode_heap_oop(p);
 HeapWord* addr = (HeapWord*)obj;
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("\t[0] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
 p, (void*) obj);
+}
 if (_g1->is_in_g1_reserved(addr) && _g1->is_obj_ill(obj)) {
 _bitMap->mark(addr);
 _cm->mark_stack_push(obj);
 }
 virtual void do_oop(      oop* p) { do_oop_work(p); }
 template <class T> void do_oop_work(T* p) {
 if (!_cm->has_overflown()) {
 oop obj = oopDesc::load_decode_heap_oop(p);
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("\t[%d] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
 _task->task_id(), p, (void*) obj);
+}
 _task->deal_with_reference(obj);
 _ref_counter--;
 if (_ref_counter == 0) {
 false /* do_termination */);
 } while (_task->has_aborted() && !_cm->has_overflown());
 _ref_counter = _ref_counter_limit;
 }
 } else {
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("\t[%d] CM Overflow", _task->task_id());
+}
 }
 }
 };
 class G1CMParDrainMarkingStackClosure: public VoidClosure {
 _cm(cm), _task(task)
 {}
 void do_void() {
 do {
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[%d] Drain: Calling do marking_step", _task->task_id());
+gclog_or_tty->print_cr("\t[%d] Drain: Calling do marking_step",
+_task->task_id());
+}
 // We call CMTask::do_marking_step() to completely drain the local and
 // global marking stacks. The routine is called in a loop, which we'll
 // exit if there's nothing more to do (i.e. we'completely drained the
 // entries that were pushed as a result of applying the
 CMGlobalObjectClosure oc(this);
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 satb_mq_set.set_closure(&oc);
 while (satb_mq_set.apply_closure_to_completed_buffer()) {
-if (verbose_medium())
+if (verbose_medium()) {
 gclog_or_tty->print_cr("[global] processed an SATB buffer");
+}
 }
 // no need to check whether we should do this, as this is only
 // called during an evacuation pause
 satb_mq_set.iterate_closure_all_threads();
 // notice that _finger == end cannot be guaranteed here since,
 // someone else might have moved the finger even further
 assert(_finger >= end, "the finger should have moved forward");
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] we were successful with region = "
 PTR_FORMAT, task_num, curr_region);
+}
 if (limit > bottom) {
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is not empty, "
 "returning it ", task_num, curr_region);
+}
 return curr_region;
 } else {
 assert(limit == bottom,
 "the region limit should be at bottom");
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is empty, "
 "returning NULL", task_num, curr_region);
+}
 // we return NULL and the caller should try calling
 // claim_region() again.
 return NULL;
 }
 } else {
 assert(_finger > finger, "the finger should have moved forward");
-if (verbose_low())
+if (verbose_low()) {
 gclog_or_tty->print_cr("[%d] somebody else moved the finger, "
 "global finger = "PTR_FORMAT", "
 "our finger = "PTR_FORMAT,
 task_num, _finger, finger);
+}
 // read it again
 finger = _finger;
 }
 }
 }
 return false;
 }
 void ConcurrentMark::oops_do(OopClosure* cl) {
-if (_markStack.size() > 0 && verbose_low())
+if (_markStack.size() > 0 && verbose_low()) {
 gclog_or_tty->print_cr("[global] scanning the global marking stack, "
 "size = %d", _markStack.size());
+}
 // we first iterate over the contents of the mark stack...
 _markStack.oops_do(cl);
 for (int i = 0; i < (int)_max_task_num; ++i) {
 OopTaskQueue* queue = _task_queues->queue((int)i);
-if (queue->size() > 0 && verbose_low())
+if (queue->size() > 0 && verbose_low()) {
 gclog_or_tty->print_cr("[global] scanning task queue of task %d, "
 "size = %d", i, queue->size());
+}
 // ...then over the contents of the all the task queues.
 queue->oops_do(cl);
 }
 if (_ms_ind == _ms_size) {
 gclog_or_tty->print_cr("Mark stack is full.");
 return false;
 }
 _ms[_ms_ind] = obj;
-if (obj->is_objArray()) _array_ind_stack[_ms_ind] = arr_ind;
+if (obj->is_objArray()) {
+_array_ind_stack[_ms_ind] = arr_ind;
+}
 _ms_ind++;
 return true;
 }
 oop pop() {
-if (_ms_ind == 0) return NULL;
+if (_ms_ind == 0) {
-else {
+return NULL;
+} else {
 _ms_ind--;
 return _ms[_ms_ind];
 }
 }
 // location. There is a tricky situation with the gray objects in
 // region stack that are being coped, however. See the comment in
 // newCSet().
 void ConcurrentMark::newCSet() {
-if (!concurrent_marking_in_progress())
+if (!concurrent_marking_in_progress()) {
 // nothing to do if marking is not in progress
 return;
+}
 // find what the lowest finger is among the global and local fingers
 _min_finger = _finger;
 for (int i = 0; i < (int)_max_task_num; ++i) {
 CMTask* task = _tasks[i];
 HeapWord* task_finger = task->finger();
-if (task_finger != NULL && task_finger < _min_finger)
+if (task_finger != NULL && task_finger < _min_finger) {
 _min_finger = task_finger;
+}
 }
 _should_gray_objects = false;
 // This fixes a very subtle and fustrating bug. It might be the case
 // empty during an evacuation pause. So, we make the fix a bit less
 // conservative and ensure that regions are pushed on the stack,
 // irrespective whether all collection set regions are below the
 // finger, if the region stack is not empty. This is expected to be
 // a rare case, so I don't think it's necessary to be smarted about it.
-if (!region_stack_empty() || has_aborted_regions())
+if (!region_stack_empty() || has_aborted_regions()) {
 _should_gray_objects = true;
+}
 }
 void ConcurrentMark::registerCSetRegion(HeapRegion* hr) {
-if (!concurrent_marking_in_progress())
+if (!concurrent_marking_in_progress()) return;
-return;
 HeapWord* region_end = hr->end();
-if (region_end > _min_finger)
+if (region_end > _min_finger) {
 _should_gray_objects = true;
+}
 }
 // Resets the region fields of active CMTasks whose values point
 // into the collection set.
 void ConcurrentMark::reset_active_task_region_fields_in_cset() {
 // the CMS bit map. Called at the first checkpoint.
 // We take a break if someone is trying to stop the world.
 bool ConcurrentMark::do_yield_check(int worker_i) {
 if (should_yield()) {
-if (worker_i == 0)
+if (worker_i == 0) {
 _g1h->g1_policy()->record_concurrent_pause();
+}
 cmThread()->yield();
-if (worker_i == 0)
+if (worker_i == 0) {
 _g1h->g1_policy()->record_concurrent_pause_end();
+}
 return true;
 } else {
 return false;
 }
 }
 return _card_bm.at(offset >> CardTableModRefBS::card_shift);
 }
 bool ConcurrentMark::containing_cards_are_marked(void* start,
 void* last) {
-return
+return containing_card_is_marked(start) &&
-containing_card_is_marked(start) &&
+containing_card_is_marked(last);
-containing_card_is_marked(last);
 }
 #ifndef PRODUCT
 // for debugging purposes
 void ConcurrentMark::print_finger() {
 assert(hr != NULL,
 "claim_region() should have filtered out continues humongous regions");
 assert(!hr->continuesHumongous(),
 "claim_region() should have filtered out continues humongous regions");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] setting up for region "PTR_FORMAT,
 _task_id, hr);
+}
 _curr_region  = hr;
 _finger       = hr->bottom();
 update_region_limit();
 }
 HeapRegion* hr            = _curr_region;
 HeapWord* bottom          = hr->bottom();
 HeapWord* limit           = hr->next_top_at_mark_start();
 if (limit == bottom) {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] found an empty region "
 "["PTR_FORMAT", "PTR_FORMAT")",
 _task_id, bottom, limit);
+}
 // The region was collected underneath our feet.
 // We set the finger to bottom to ensure that the bitmap
 // iteration that will follow this will not do anything.
 // (this is not a condition that holds when we set the region up,
 // as the region is not supposed to be empty in the first place)
 _region_limit = limit;
 }
 void CMTask::giveup_current_region() {
 assert(_curr_region != NULL, "invariant");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] giving up region "PTR_FORMAT,
 _task_id, _curr_region);
+}
 clear_region_fields();
 }
 void CMTask::clear_region_fields() {
 // Values for these three fields that indicate that we're not
 }
 void CMTask::reset(CMBitMap* nextMarkBitMap) {
 guarantee(nextMarkBitMap != NULL, "invariant");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] resetting", _task_id);
+}
 _nextMarkBitMap                = nextMarkBitMap;
 clear_region_fields();
 assert(_aborted_region.is_empty(), "should have been cleared");
 "shouldn't have been called otherwise");
 regular_clock_call();
 }
 void CMTask::regular_clock_call() {
-if (has_aborted())
+if (has_aborted()) return;
-return;
 // First, we need to recalculate the words scanned and refs reached
 // limits for the next clock call.
 recalculate_limits();
 }
 // If we are not concurrent (i.e. we're doing remark) we don't need
 // to check anything else. The other steps are only needed during
 // the concurrent marking phase.
-if (!concurrent())
+if (!concurrent()) return;
-return;
 // (2) If marking has been aborted for Full GC, then we also abort.
 if (_cm->has_aborted()) {
 set_has_aborted();
 statsOnly( ++_aborted_cm_aborted );
 double curr_time_ms = os::elapsedVTime() * 1000.0;
 // (3) If marking stats are enabled, then we update the step history.
 #if _MARKING_STATS_
-if (_words_scanned >= _words_scanned_limit)
+if (_words_scanned >= _words_scanned_limit) {
 ++_clock_due_to_scanning;
-if (_refs_reached >= _refs_reached_limit)
+}
+if (_refs_reached >= _refs_reached_limit) {
 ++_clock_due_to_marking;
+}
 double last_interval_ms = curr_time_ms - _interval_start_time_ms;
 _interval_start_time_ms = curr_time_ms;
 _all_clock_intervals_ms.add(last_interval_ms);
 if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] regular clock, interval = %1.2lfms, "
 "scanned = %d%s, refs reached = %d%s",
 _task_id, last_interval_ms,
 _words_scanned,
 (_words_scanned >= _words_scanned_limit) ? " (*)" : "",
 _refs_reached,
 (_refs_reached >= _refs_reached_limit) ? " (*)" : "");
 }
 #endif // _MARKING_STATS_
 // (4) We check whether we should yield. If we have to, then we abort.
 if (_cm->should_yield()) {
 // (6) Finally, we check whether there are enough completed STAB
 // buffers available for processing. If there are, we abort.
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] aborting to deal with pending SATB buffers",
 _task_id);
+}
 // we do need to process SATB buffers, we'll abort and restart
 // the marking task to do so
 set_has_aborted();
 statsOnly( ++_aborted_satb );
 return;
 // This is called when we believe that we're going to do an infrequent
 // operation which will increase the per byte scanned cost (i.e. move
 // entries to/from the global stack). It basically tries to decrease the
 // scanning limit so that the clock is called earlier.
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] decreasing limits", _task_id);
+}
 _words_scanned_limit = _real_words_scanned_limit -
 3 * words_scanned_period / 4;
 _refs_reached_limit  = _real_refs_reached_limit -
 3 * refs_reached_period / 4;
 // we popped at least one entry from the local queue
 statsOnly( ++_global_transfers_to; _local_pops += n );
 if (!_cm->mark_stack_push(buffer, n)) {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] aborting due to global stack overflow", _task_id);
+gclog_or_tty->print_cr("[%d] aborting due to global stack overflow",
+_task_id);
+}
 set_has_aborted();
 } else {
 // the transfer was successful
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] pushed %d entries to the global stack",
 _task_id, n);
+}
 statsOnly( int tmp_size = _cm->mark_stack_size();
-if (tmp_size > _global_max_size)
+if (tmp_size > _global_max_size) {
 _global_max_size = tmp_size;
+}
 _global_pushes += n );
 }
 }
 // this operation was quite expensive, so decrease the limits
 "we should not pop more than the given limit");
 if (n > 0) {
 // yes, we did actually pop at least one entry
 statsOnly( ++_global_transfers_from; _global_pops += n );
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] popped %d entries from the global stack",
 _task_id, n);
+}
 for (int i = 0; i < n; ++i) {
 bool success = _task_queue->push(buffer[i]);
 // We only call this when the local queue is empty or under a
 // given target limit. So, we do not expect this push to fail.
 assert(success, "invariant");
 }
 statsOnly( int tmp_size = _task_queue->size();
-if (tmp_size > _local_max_size)
+if (tmp_size > _local_max_size) {
 _local_max_size = tmp_size;
+}
 _local_pushes += n );
 }
 // this operation was quite expensive, so decrease the limits
 decrease_limits();
 }
 void CMTask::drain_local_queue(bool partially) {
-if (has_aborted())
+if (has_aborted()) return;
-return;
 // Decide what the target size is, depending whether we're going to
 // drain it partially (so that other tasks can steal if they run out
 // of things to do) or totally (at the very end).
 size_t target_size;
-if (partially)
+if (partially) {
 target_size = MIN2((size_t)_task_queue->max_elems()/3, GCDrainStackTargetSize);
-else
+} else {
 target_size = 0;
+}
 if (_task_queue->size() > target_size) {
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("[%d] draining local queue, target size = %d",
 _task_id, target_size);
+}
 oop obj;
 bool ret = _task_queue->pop_local(obj);
 while (ret) {
 statsOnly( ++_local_pops );
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
 (void*) obj);
+}
 assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
 assert(!_g1h->is_on_master_free_list(
 _g1h->heap_region_containing((HeapWord*) obj)), "invariant");
 scan_object(obj);
-if (_task_queue->size() <= target_size || has_aborted())
+if (_task_queue->size() <= target_size || has_aborted()) {
 ret = false;
-else
+} else {
 ret = _task_queue->pop_local(obj);
 }
+}
-if (_cm->verbose_high())
+if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("[%d] drained local queue, size = %d",
 _task_id, _task_queue->size());
+}
 }
 }
 void CMTask::drain_global_stack(bool partially) {
-if (has_aborted())
+if (has_aborted()) return;
-return;
 // We have a policy to drain the local queue before we attempt to
 // drain the global stack.
 assert(partially || _task_queue->size() == 0, "invariant");
 // of things to do) or totally (at the very end).  Notice that,
 // because we move entries from the global stack in chunks or
 // because another task might be doing the same, we might in fact
 // drop below the target. But, this is not a problem.
 size_t target_size;
-if (partially)
+if (partially) {
 target_size = _cm->partial_mark_stack_size_target();
-else
+} else {
 target_size = 0;
+}
 if (_cm->mark_stack_size() > target_size) {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] draining global_stack, target size %d",
 _task_id, target_size);
+}
 while (!has_aborted() && _cm->mark_stack_size() > target_size) {
 get_entries_from_global_stack();
 drain_local_queue(partially);
 }
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] drained global stack, size = %d",
 _task_id, _cm->mark_stack_size());
+}
 }
 }
 // SATB Queue has several assumptions on whether to call the par or
 // non-par versions of the methods. this is why some of the code is
 // replicated. We should really get rid of the single-threaded version
 // of the code to simplify things.
 void CMTask::drain_satb_buffers() {
-if (has_aborted())
+if (has_aborted()) return;
-return;
 // We set this so that the regular clock knows that we're in the
 // middle of draining buffers and doesn't set the abort flag when it
 // notices that SATB buffers are available for draining. It'd be
 // very counter productive if it did that. :-)
 _draining_satb_buffers = true;
 CMObjectClosure oc(this);
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
-if (G1CollectedHeap::use_parallel_gc_threads())
+if (G1CollectedHeap::use_parallel_gc_threads()) {
 satb_mq_set.set_par_closure(_task_id, &oc);
-else
+} else {
 satb_mq_set.set_closure(&oc);
+}
 // This keeps claiming and applying the closure to completed buffers
 // until we run out of buffers or we need to abort.
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 while (!has_aborted() &&
 satb_mq_set.par_apply_closure_to_completed_buffer(_task_id)) {
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
+}
 statsOnly( ++_satb_buffers_processed );
 regular_clock_call();
 }
 } else {
 while (!has_aborted() &&
 satb_mq_set.apply_closure_to_completed_buffer()) {
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
+}
 statsOnly( ++_satb_buffers_processed );
 regular_clock_call();
 }
 }
 if (!concurrent() && !has_aborted()) {
 // We should only do this during remark.
-if (G1CollectedHeap::use_parallel_gc_threads())
+if (G1CollectedHeap::use_parallel_gc_threads()) {
 satb_mq_set.par_iterate_closure_all_threads(_task_id);
-else
+} else {
 satb_mq_set.iterate_closure_all_threads();
+}
 }
 _draining_satb_buffers = false;
 assert(has_aborted() ||
 concurrent() ||
 satb_mq_set.completed_buffers_num() == 0, "invariant");
-if (G1CollectedHeap::use_parallel_gc_threads())
+if (G1CollectedHeap::use_parallel_gc_threads()) {
 satb_mq_set.set_par_closure(_task_id, NULL);
-else
+} else {
 satb_mq_set.set_closure(NULL);
+}
 // again, this was a potentially expensive operation, decrease the
 // limits to get the regular clock call early
 decrease_limits();
 }
 void CMTask::drain_region_stack(BitMapClosure* bc) {
-if (has_aborted())
+if (has_aborted()) return;
-return;
 assert(_region_finger == NULL,
 "it should be NULL when we're not scanning a region");
 if (!_cm->region_stack_empty() || !_aborted_region.is_empty()) {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] draining region stack, size = %d",
 _task_id, _cm->region_stack_size());
+}
 MemRegion mr;
 if (!_aborted_region.is_empty()) {
 mr = _aborted_region;
 _aborted_region = MemRegion();
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] scanning aborted region [ " PTR_FORMAT ", " PTR_FORMAT " )",
+gclog_or_tty->print_cr("[%d] scanning aborted region "
-_task_id, mr.start(), mr.end());
+"[ " PTR_FORMAT ", " PTR_FORMAT " )",
+_task_id, mr.start(), mr.end());
+}
 } else {
 mr = _cm->region_stack_pop_lock_free();
 // it returns MemRegion() if the pop fails
 statsOnly(if (mr.start() != NULL) ++_region_stack_pops );
 }
 while (mr.start() != NULL) {
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] we are scanning region "
 "["PTR_FORMAT", "PTR_FORMAT")",
 _task_id, mr.start(), mr.end());
+}
 assert(mr.end() <= _cm->finger(),
 "otherwise the region shouldn't be on the stack");
 assert(!mr.is_empty(), "Only non-empty regions live on the region stack");
 if (_nextMarkBitMap->iterate(bc, mr)) {
 assert(!has_aborted(),
 "cannot abort the task without aborting the bitmap iteration");
 // We finished iterating over the region without aborting.
 regular_clock_call();
-if (has_aborted())
+if (has_aborted()) {
 mr = MemRegion();
-else {
+} else {
 mr = _cm->region_stack_pop_lock_free();
 // it returns MemRegion() if the pop fails
 statsOnly(if (mr.start() != NULL) ++_region_stack_pops );
 }
 } else {
 mr = MemRegion();
 }
 _region_finger = NULL;
 }
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] drained region stack, size = %d",
 _task_id, _cm->region_stack_size());
+}
 }
 }
 void CMTask::print_stats() {
 gclog_or_tty->print_cr("Marking Stats, task = %d, calls = %d",
 _has_timed_out = false;
 _draining_satb_buffers = false;
 ++_calls;
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] >>>>>>>>>> START, call = %d, "
 "target = %1.2lfms >>>>>>>>>>",
 _task_id, _calls, _time_target_ms);
+}
 // Set up the bitmap and oop closures. Anything that uses them is
 // eventually called from this method, so it is OK to allocate these
 // statically.
 CMBitMapClosure bitmap_closure(this, _cm, _nextMarkBitMap);
 // through scanning this region. In this case, _finger points to
 // the address where we last found a marked object. If this is a
 // fresh region, _finger points to start().
 MemRegion mr = MemRegion(_finger, _region_limit);
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] we're scanning part "
 "["PTR_FORMAT", "PTR_FORMAT") "
 "of region "PTR_FORMAT,
 _task_id, _finger, _region_limit, _curr_region);
+}
 // Let's iterate over the bitmap of the part of the
 // region that is left.
 bitmap_closure.set_scanning_heap_region(true);
 if (mr.is_empty() ||
 // given up on the previous one.
 // Separated the asserts so that we know which one fires.
 assert(_curr_region  == NULL, "invariant");
 assert(_finger       == NULL, "invariant");
 assert(_region_limit == NULL, "invariant");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] trying to claim a new region", _task_id);
+}
 HeapRegion* claimed_region = _cm->claim_region(_task_id);
 if (claimed_region != NULL) {
 // Yes, we managed to claim one
 statsOnly( ++_regions_claimed );
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] we successfully claimed "
 "region "PTR_FORMAT,
 _task_id, claimed_region);
+}
 setup_for_region(claimed_region);
 assert(_curr_region == claimed_region, "invariant");
 }
 // It is important to call the regular clock here. It might take
 // check if the region stack is empty because if a thread is aborting
 // it can push a partially done region back.
 assert(_cm->out_of_regions(),
 "at this point we should be out of regions");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] all regions claimed", _task_id);
+}
 // Try to reduce the number of available SATB buffers so that
 // remark has less work to do.
 drain_satb_buffers();
 }
 // check if the region stack is empty because if a thread is aborting
 // it can push a partially done region back.
 assert(_cm->out_of_regions() && _task_queue->size() == 0,
 "only way to reach here");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
+}
 while (!has_aborted()) {
 oop obj;
 statsOnly( ++_steal_attempts );
 if (_cm->try_stealing(_task_id, &_hash_seed, obj)) {
-if (_cm->verbose_medium())
+if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%d] stolen "PTR_FORMAT" successfully",
 _task_id, (void*) obj);
+}
 statsOnly( ++_steals );
 assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
 "any stolen object should be marked");
 // it can push a partially done region back.
 // Separated the asserts so that we know which one fires.
 assert(_cm->out_of_regions(), "only way to reach here");
 assert(_task_queue->size() == 0, "only way to reach here");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] starting termination protocol", _task_id);
+}
 _termination_start_time_ms = os::elapsedVTime() * 1000.0;
 // The CMTask class also extends the TerminatorTerminator class,
 // hence its should_exit_termination() method will also decide
 // whether to exit the termination protocol or not.
 guarantee(_task_queue->size() == 0, "only way to reach here");
 guarantee(!_cm->has_overflown(), "only way to reach here");
 guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
 guarantee(!_cm->region_stack_overflow(), "only way to reach here");
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id);
+}
 } else {
 // Apparently there's more work to do. Let's abort this task. It
 // will restart it and we can hopefully find more things to do.
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] apparently there is more work to do", _task_id);
+gclog_or_tty->print_cr("[%d] apparently there is more work to do",
+_task_id);
+}
 set_has_aborted();
 statsOnly( ++_aborted_termination );
 }
 }
 // marking phase and start iterating over regions. However, in
 // order to do this we have to make sure that all tasks stop
 // what they are doing and re-initialise in a safe manner. We
 // will achieve this with the use of two barrier sync points.
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] detected overflow", _task_id);
+}
 _cm->enter_first_sync_barrier(_task_id);
 // When we exit this sync barrier we know that all tasks have
 // stopped doing marking work. So, it's now safe to
 // re-initialise our data structures. At the end of this method,
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] <<<<<<<<<< ABORTING, target = %1.2lfms, "
 "elapsed = %1.2lfms <<<<<<<<<<",
 _task_id, _time_target_ms, elapsed_time_ms);
-if (_cm->has_aborted())
+if (_cm->has_aborted()) {
 gclog_or_tty->print_cr("[%d] ========== MARKING ABORTED ==========",
 _task_id);
+}
 }
 } else {
-if (_cm->verbose_low())
+if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] <<<<<<<<<< FINISHED, target = %1.2lfms, "
 "elapsed = %1.2lfms <<<<<<<<<<",
 _task_id, _time_target_ms, elapsed_time_ms);
+}
 }
 _claimed = false;
 }

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 3776:23d434c6290d