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

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 1023:11d4857fe5e1

6888619: G1: too many guarantees in concurrent marking Summary: change more guarantees in concurrent marking into asserts. Reviewed-by: apetrusenko, iveresov

author	tonyp
date	Wed, 07 Oct 2009 10:09:57 -0400
parents	4c3458a31e17
children	dfdaf65c3423

comparison

equal deleted inserted replaced

-:4c3458a31e17
+:11d4857fe5e1
 }
 // Otherwise.
 _index = next_index;
 for (int i = 0; i < n; i++) {
 int ind = start + i;
-guarantee(ind < _capacity, "By overflow test above.");
+assert(ind < _capacity, "By overflow test above.");
 _base[ind] = ptr_arr[i];
 }
 }
 jint next_index = index-1;
 jint res = Atomic::cmpxchg(next_index, &_index, index);
 if (res == index) {
 MemRegion mr = _base[next_index];
 if (mr.start() != NULL) {
-tmp_guarantee_CM( mr.end() != NULL, "invariant" );
+assert(mr.end() != NULL, "invariant");
-tmp_guarantee_CM( mr.word_size() > 0, "invariant" );
+assert(mr.word_size() > 0, "invariant");
 return mr;
 } else {
 // that entry was invalidated... let's skip it
-tmp_guarantee_CM( mr.end() == NULL, "invariant" );
+assert(mr.end() == NULL, "invariant");
 }
 }
 // Otherwise, we need to try again.
 }
 }
 bool result = false;
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 for (int i = 0; i < _oops_do_bound; ++i) {
 MemRegion mr = _base[i];
 if (mr.start() != NULL) {
-tmp_guarantee_CM( mr.end() != NULL, "invariant");
+assert(mr.end() != NULL, "invariant");
-tmp_guarantee_CM( mr.word_size() > 0, "invariant" );
+assert(mr.word_size() > 0, "invariant");
 HeapRegion* hr = g1h->heap_region_containing(mr.start());
-tmp_guarantee_CM( hr != NULL, "invariant" );
+assert(hr != NULL, "invariant");
 if (hr->in_collection_set()) {
 // The region points into the collection set
 _base[i] = MemRegion();
 result = true;
 }
 } else {
 // that entry was invalidated... let's skip it
-tmp_guarantee_CM( mr.end() == NULL, "invariant" );
+assert(mr.end() == NULL, "invariant");
 }
 }
 return result;
 }
 gclog_or_tty->print_cr("CM Sleep Factor          %1.4lf", sleep_factor());
 gclog_or_tty->print_cr("CL Marking Task Overhead %1.4lf", cleanup_task_overhead());
 gclog_or_tty->print_cr("CL Sleep Factor          %1.4lf", cleanup_sleep_factor());
 #endif
-guarantee( parallel_marking_threads() > 0, "peace of mind" );
+guarantee(parallel_marking_threads() > 0, "peace of mind");
 _parallel_workers = new WorkGang("G1 Parallel Marking Threads",
 (int) parallel_marking_threads(), false, true);
 if (_parallel_workers == NULL)
 vm_exit_during_initialization("Failed necessary allocation.");
 }
 // not have this problem.
 if (!concurrent_marking_in_progress() && !force)
 return;
 MemRegion committed = _g1h->g1_committed();
-tmp_guarantee_CM( committed.start() == _heap_start,
+assert(committed.start() == _heap_start, "start shouldn't change");
-"start shouldn't change" );
 HeapWord* new_end = committed.end();
 if (new_end > _heap_end) {
 // The heap has been expanded.
 _heap_end = new_end;
 // inactive.
 MemRegion committed = _g1h->g1_committed();
 _heap_start = committed.start();
 _heap_end   = committed.end();
-guarantee( _heap_start != NULL &&
+// Separated the asserts so that we know which one fires.
-_heap_end != NULL   &&
+assert(_heap_start != NULL, "heap bounds should look ok");
-_heap_start < _heap_end, "heap bounds should look ok" );
+assert(_heap_end != NULL, "heap bounds should look ok");
+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())
 // pause with initial mark piggy-backed
 set_concurrent_marking_in_progress();
 }
 void ConcurrentMark::set_phase(size_t active_tasks, bool concurrent) {
-guarantee( active_tasks <= _max_task_num, "we should not have more" );
+assert(active_tasks <= _max_task_num, "we should not have more");
 _active_tasks = active_tasks;
 // Need to update the three data structures below according to the
 // number of active threads for this phase.
 _terminator   = ParallelTaskTerminator((int) active_tasks, _task_queues);
 set_concurrent_marking_in_progress();
 } else {
 // We currently assume that the concurrent flag has been set to
 // false before we start remark. At this point we should also be
 // in a STW phase.
-guarantee( !concurrent_marking_in_progress(), "invariant" );
+assert(!concurrent_marking_in_progress(), "invariant");
-guarantee( _finger == _heap_end, "only way to get here" );
+assert(_finger == _heap_end, "only way to get here");
 update_g1_committed(true);
 }
 }
 void ConcurrentMark::set_non_marking_state() {
 // We can't really check against _heap_start and _heap_end, since it
 // is possible during an evacuation pause with piggy-backed
 // initial-mark that the committed space is expanded during the
 // pause without CM observing this change. So the assertions below
 // is a bit conservative; but better than nothing.
-tmp_guarantee_CM( _g1h->g1_committed().contains(addr),
+assert(_g1h->g1_committed().contains(addr),
-"address should be within the heap bounds" );
+"address should be within the heap bounds");
 if (!_nextMarkBitMap->isMarked(addr))
 _nextMarkBitMap->parMark(addr);
 }
 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.
-tmp_guarantee_CM( mr.end() <= finger, "invariant" );
+assert(mr.end() <= finger, "invariant");
-tmp_guarantee_CM( mr.start() <= mr.end() &&
+// Separated the asserts so that we know which one fires.
-_heap_start <= mr.start() &&
+assert(mr.start() <= mr.end(),
-mr.end() <= _heap_end,
+"region boundaries should fall within the committed space");
-"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())
 gclog_or_tty->print_cr("[global] region ["PTR_FORMAT", "PTR_FORMAT") "
 "below the finger, pushing it",
 mr.start(), mr.end());
 ConcurrentMark*       _cm;
 ConcurrentMarkThread* _cmt;
 public:
 void work(int worker_i) {
-guarantee( Thread::current()->is_ConcurrentGC_thread(),
+assert(Thread::current()->is_ConcurrentGC_thread(),
-"this should only be done by a conc GC thread" );
+"this should only be done by a conc GC thread");
 double start_vtime = os::elapsedVTime();
 ConcurrentGCThread::stsJoin();
-guarantee( (size_t)worker_i < _cm->active_tasks(), "invariant" );
+assert((size_t) worker_i < _cm->active_tasks(), "invariant");
 CMTask* the_task = _cm->task(worker_i);
 the_task->record_start_time();
 if (!_cm->has_aborted()) {
 do {
 double start_vtime_sec = os::elapsedVTime();
 elapsed_time_sec * 1000.0, elapsed_time2_sec * 1000.0);
 #endif
 } while (!_cm->has_aborted() && the_task->has_aborted());
 }
 the_task->record_end_time();
-guarantee( !the_task->has_aborted() || _cm->has_aborted(), "invariant" );
+guarantee(!the_task->has_aborted() || _cm->has_aborted(), "invariant");
 ConcurrentGCThread::stsLeave();
 double end_vtime = os::elapsedVTime();
 _cm->update_accum_task_vtime(worker_i, end_vtime - start_vtime);
 bool _final;
 void mark_card_num_range(intptr_t start_card_num, intptr_t last_card_num) {
 for (intptr_t i = start_card_num; i <= last_card_num; i++) {
 #if CARD_BM_TEST_MODE
-guarantee(_card_bm->at(i - _bottom_card_num),
+guarantee(_card_bm->at(i - _bottom_card_num), "Should already be set.");
-"Should already be set.");
 #else
 _card_bm->par_at_put(i - _bottom_card_num, 1);
 #endif
 }
 }
 } else {
 _g1h->heap_region_iterate(&calccl);
 }
 assert(calccl.complete(), "Shouldn't have yielded!");
-guarantee( (size_t)i < _n_workers, "invariant" );
+assert((size_t) i < _n_workers, "invariant");
 _live_bytes[i] = calccl.tot_live();
 _used_bytes[i] = calccl.tot_used();
 }
 size_t live_bytes()  {
 size_t live_bytes = 0;
 while (hd != NULL) {
 // Now finish up the other stuff.
 hd->rem_set()->clear();
 HeapRegion* next_hd = hd->next_from_unclean_list();
 (void)list->pop();
-guarantee(list->hd() == next_hd, "how not?");
+assert(list->hd() == next_hd, "how not?");
 _g1h->put_region_on_unclean_list(hd);
 if (!hd->isHumongous()) {
 // Add this to the _free_regions count by 1.
 _g1h->finish_free_region_work(0, 0, 1, NULL);
 }
 hd = list->hd();
-guarantee(hd == next_hd, "how not?");
+assert(hd == next_hd, "how not?");
 }
 }
 }
 // immediately.
 int n_workers = g1h->workers()->total_workers();
 g1h->set_par_threads(n_workers);
 g1h->workers()->run_task(&remarkTask);
 g1h->set_par_threads(0);
-SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
-guarantee( satb_mq_set.completed_buffers_num() == 0, "invariant" );
 } else {
 G1CollectedHeap::StrongRootsScope srs(g1h);
 // this is remark, so we'll use up all available threads
 int active_workers = 1;
 set_phase(active_workers, false);
 CMRemarkTask remarkTask(this);
 // We will start all available threads, even if we decide that the
 // active_workers will be fewer. The extra ones will just bail out
 // immediately.
 remarkTask.work(0);
+}
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
-guarantee( satb_mq_set.completed_buffers_num() == 0, "invariant" );
+guarantee(satb_mq_set.completed_buffers_num() == 0, "invariant");
-}
 print_stats();
 if (!restart_for_overflow())
 set_non_marking_state();
 if (!_g1h->is_in_g1_reserved(obj))
 str = "outside G1 reserved";
 else {
 HeapRegion* hr  = _g1h->heap_region_containing(obj);
-guarantee( hr != NULL, "invariant" );
+guarantee(hr != NULL, "invariant");
 if (hr->obj_allocated_since_prev_marking(obj)) {
 str = "over TAMS";
 if (_bitmap->isMarked((HeapWord*) obj))
 str2 = " AND MARKED";
 } else if (_bitmap->isMarked((HeapWord*) obj))
 HeapWord* objAddr = (HeapWord*) obj;
 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
 if (_g1h->is_in_g1_reserved(objAddr)) {
-tmp_guarantee_CM( obj != NULL, "is_in_g1_reserved should ensure this" );
+assert(obj != NULL, "is_in_g1_reserved should ensure this");
 HeapRegion* hr = _g1h->heap_region_containing(obj);
 if (_g1h->is_obj_ill(obj, hr)) {
 if (verbose_high())
 gclog_or_tty->print_cr("[global] "PTR_FORMAT" is not considered "
 "marked", (void*) obj);
 // 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();
 satb_mq_set.set_closure(NULL);
-guarantee( satb_mq_set.completed_buffers_num() == 0, "invariant" );
+assert(satb_mq_set.completed_buffers_num() == 0, "invariant");
 }
 void ConcurrentMark::markPrev(oop p) {
 // Note we are overriding the read-only view of the prev map here, via
 // the cast.
 HeapWord* finger = _finger;
 // _heap_end will not change underneath our feet; it only changes at
 // yield points.
 while (finger < _heap_end) {
-tmp_guarantee_CM( _g1h->is_in_g1_reserved(finger), "invariant" );
+assert(_g1h->is_in_g1_reserved(finger), "invariant");
 // is the gap between reading the finger and doing the CAS too long?
 HeapRegion* curr_region   = _g1h->heap_region_containing(finger);
 HeapWord*   bottom        = curr_region->bottom();
 if (res == finger) {
 // we succeeded
 // notice that _finger == end cannot be guaranteed here since,
 // someone else might have moved the finger even further
-guarantee( _finger >= end, "the finger should have moved forward" );
+assert(_finger >= end, "the finger should have moved forward");
 if (verbose_low())
 gclog_or_tty->print_cr("[%d] we were successful with region = "
 PTR_FORMAT, task_num, curr_region);
 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 {
-tmp_guarantee_CM( limit == bottom,
+assert(limit == bottom,
-"the region limit should be at bottom" );
+"the region limit should be at bottom");
 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 {
-guarantee( _finger > finger, "the finger should have moved forward" );
+assert(_finger > finger, "the finger should have moved forward");
 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);
 // finally, invalidate any entries that in the region stack that
 // point into the collection set
 if (_regionStack.invalidate_entries_into_cset()) {
 // otherwise, any gray objects copied during the evacuation pause
 // might not be visited.
-guarantee( _should_gray_objects, "invariant" );
+assert(_should_gray_objects, "invariant");
 }
 }
 void ConcurrentMark::clear_marking_state() {
 _markStack.setEmpty();
 _scanning_heap_region = scanning_heap_region;
 }
 bool do_bit(size_t offset) {
 HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset);
-tmp_guarantee_CM( _nextMarkBitMap->isMarked(addr), "invariant" );
+assert(_nextMarkBitMap->isMarked(addr), "invariant");
-tmp_guarantee_CM( addr < _cm->finger(), "invariant" );
+assert( addr < _cm->finger(), "invariant");
 if (_scanning_heap_region) {
 statsOnly( _task->increase_objs_found_on_bitmap() );
-tmp_guarantee_CM( addr >= _task->finger(), "invariant" );
+assert(addr >= _task->finger(), "invariant");
 // We move that task's local finger along.
 _task->move_finger_to(addr);
 } else {
 // We move the task's region finger along.
 _task->move_region_finger_to(addr);
 public:
 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 virtual void do_oop(      oop* p) { do_oop_work(p); }
 template <class T> void do_oop_work(T* p) {
-tmp_guarantee_CM( _g1h->is_in_g1_reserved((HeapWord*) p), "invariant" );
+assert(_g1h->is_in_g1_reserved((HeapWord*) p), "invariant");
-tmp_guarantee_CM( !_g1h->heap_region_containing((HeapWord*) p)->is_on_free_list(), "invariant" );
+assert(!_g1h->heap_region_containing((HeapWord*) p)->is_on_free_list(),
+"invariant");
 oop obj = oopDesc::load_decode_heap_oop(p);
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
 CMTask* task)
 : _g1h(g1h), _cm(cm), _task(task) { }
 };
 void CMTask::setup_for_region(HeapRegion* hr) {
-tmp_guarantee_CM( hr != NULL && !hr->continuesHumongous(),
+// Separated the asserts so that we know which one fires.
-"claim_region() should have filtered out continues humongous regions" );
+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())
 gclog_or_tty->print_cr("[%d] setting up for region "PTR_FORMAT,
 _task_id, hr);
 // 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)
 _finger = bottom;
 } else if (limit >= _region_limit) {
-tmp_guarantee_CM( limit >= _finger, "peace of mind" );
+assert(limit >= _finger, "peace of mind");
 } else {
-tmp_guarantee_CM( limit < _region_limit, "only way to get here" );
+assert(limit < _region_limit, "only way to get here");
 // This can happen under some pretty unusual circumstances.  An
 // evacuation pause empties the region underneath our feet (NTAMS
 // at bottom). We then do some allocation in the region (NTAMS
 // stays at bottom), followed by the region being used as a GC
 // alloc region (NTAMS will move to top() and the objects
 _region_limit = limit;
 }
 void CMTask::giveup_current_region() {
-tmp_guarantee_CM( _curr_region != NULL, "invariant" );
+assert(_curr_region != NULL, "invariant");
 if (_cm->verbose_low())
 gclog_or_tty->print_cr("[%d] giving up region "PTR_FORMAT,
 _task_id, _curr_region);
 clear_region_fields();
 }
 _region_finger = NULL;
 }
 void CMTask::reset(CMBitMap* nextMarkBitMap) {
-guarantee( nextMarkBitMap != NULL, "invariant" );
+guarantee(nextMarkBitMap != NULL, "invariant");
 if (_cm->verbose_low())
 gclog_or_tty->print_cr("[%d] resetting", _task_id);
 _nextMarkBitMap                = nextMarkBitMap;
 ++_refs_reached;
 HeapWord* objAddr = (HeapWord*) obj;
 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
 if (_g1h->is_in_g1_reserved(objAddr)) {
-tmp_guarantee_CM( obj != NULL, "is_in_g1_reserved should ensure this" );
+assert(obj != NULL, "is_in_g1_reserved should ensure this");
 HeapRegion* hr =  _g1h->heap_region_containing(obj);
 if (_g1h->is_obj_ill(obj, hr)) {
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] "PTR_FORMAT" is not considered marked",
 _task_id, (void*) obj);
 }
 }
 void CMTask::push(oop obj) {
 HeapWord* objAddr = (HeapWord*) obj;
-tmp_guarantee_CM( _g1h->is_in_g1_reserved(objAddr), "invariant" );
+assert(_g1h->is_in_g1_reserved(objAddr), "invariant");
-tmp_guarantee_CM( !_g1h->heap_region_containing(objAddr)->is_on_free_list(), "invariant" );
+assert(!_g1h->heap_region_containing(objAddr)->is_on_free_list(),
-tmp_guarantee_CM( !_g1h->is_obj_ill(obj), "invariant" );
+"invariant");
-tmp_guarantee_CM( _nextMarkBitMap->isMarked(objAddr), "invariant" );
+assert(!_g1h->is_obj_ill(obj), "invariant");
+assert(_nextMarkBitMap->isMarked(objAddr), "invariant");
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] pushing "PTR_FORMAT, _task_id, (void*) obj);
 if (!_task_queue->push(obj)) {
 // this should succeed since, even if we overflow the global
 // stack, we should have definitely removed some entries from the
 // local queue. So, there must be space on it.
 bool success = _task_queue->push(obj);
-tmp_guarantee_CM( success, "invariant" );
+assert(success, "invariant");
 }
 statsOnly( int tmp_size = _task_queue->size();
 if (tmp_size > _local_max_size)
 _local_max_size = tmp_size;
 ++_local_pushes );
 }
 void CMTask::reached_limit() {
-tmp_guarantee_CM( _words_scanned >= _words_scanned_limit ||
+assert(_words_scanned >= _words_scanned_limit ||
 _refs_reached >= _refs_reached_limit ,
-"shouldn't have been called otherwise" );
+"shouldn't have been called otherwise");
 regular_clock_call();
 }
 void CMTask::regular_clock_call() {
 if (has_aborted())
 // local array where we'll store the entries that will be popped
 // from the global stack.
 oop buffer[global_stack_transfer_size];
 int n;
 _cm->mark_stack_pop(buffer, global_stack_transfer_size, &n);
-tmp_guarantee_CM( n <= global_stack_transfer_size,
+assert(n <= global_stack_transfer_size,
-"we should not pop more than the given limit" );
+"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())
 _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.
-tmp_guarantee_CM( success, "invariant" );
+assert(success, "invariant");
 }
 statsOnly( int tmp_size = _task_queue->size();
 if (tmp_size > _local_max_size)
 _local_max_size = tmp_size;
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
 (void*) obj);
-tmp_guarantee_CM( _g1h->is_in_g1_reserved((HeapWord*) obj),
+assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
-"invariant" );
+assert(!_g1h->heap_region_containing(obj)->is_on_free_list(),
-tmp_guarantee_CM( !_g1h->heap_region_containing(obj)->is_on_free_list(),
+"invariant");
-"invariant" );
 scan_object(obj);
 if (_task_queue->size() <= target_size || has_aborted())
 ret = false;
 if (has_aborted())
 return;
 // We have a policy to drain the local queue before we attempt to
 // drain the global stack.
-tmp_guarantee_CM( partially || _task_queue->size() == 0, "invariant" );
+assert(partially || _task_queue->size() == 0, "invariant");
 // 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).  Notice that,
 // because we move entries from the global stack in chunks or
 satb_mq_set.iterate_closure_all_threads();
 }
 _draining_satb_buffers = false;
-tmp_guarantee_CM( has_aborted() ||
+assert(has_aborted() ||
 concurrent() ||
-satb_mq_set.completed_buffers_num() == 0, "invariant" );
+satb_mq_set.completed_buffers_num() == 0, "invariant");
 if (ParallelGCThreads > 0)
 satb_mq_set.set_par_closure(_task_id, NULL);
 else
 satb_mq_set.set_closure(NULL);
 void CMTask::drain_region_stack(BitMapClosure* bc) {
 if (has_aborted())
 return;
-tmp_guarantee_CM( _region_finger == NULL,
+assert(_region_finger == NULL,
-"it should be NULL when we're not scanning a region" );
+"it should be NULL when we're not scanning a region");
 if (!_cm->region_stack_empty()) {
 if (_cm->verbose_low())
 gclog_or_tty->print_cr("[%d] draining region stack, size = %d",
 _task_id, _cm->region_stack_size());
 while (mr.start() != NULL) {
 if (_cm->verbose_medium())
 gclog_or_tty->print_cr("[%d] we are scanning region "
 "["PTR_FORMAT", "PTR_FORMAT")",
 _task_id, mr.start(), mr.end());
-tmp_guarantee_CM( mr.end() <= _cm->finger(),
+assert(mr.end() <= _cm->finger(),
-"otherwise the region shouldn't be on the stack" );
+"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)) {
-tmp_guarantee_CM( !has_aborted(),
+assert(!has_aborted(),
-"cannot abort the task without aborting the bitmap iteration" );
+"cannot abort the task without aborting the bitmap iteration");
 // We finished iterating over the region without aborting.
 regular_clock_call();
 if (has_aborted())
 mr = MemRegion();
 mr = _cm->region_stack_pop();
 // it returns MemRegion() if the pop fails
 statsOnly(if (mr.start() != NULL) ++_region_stack_pops );
 }
 } else {
-guarantee( has_aborted(), "currently the only way to do so" );
+assert(has_aborted(), "currently the only way to do so");
 // The only way to abort the bitmap iteration is to return
 // false from the do_bit() method. However, inside the
 // do_bit() method we move the _region_finger to point to the
 // object currently being looked at. So, if we bail out, we
 // have definitely set _region_finger to something non-null.
-guarantee( _region_finger != NULL, "invariant" );
+assert(_region_finger != NULL, "invariant");
 // The iteration was actually aborted. So now _region_finger
 // points to the address of the object we last scanned. If we
 // leave it there, when we restart this task, we will rescan
 // the object. It is easy to avoid this. We move the finger by
 too and not constantly check them throughout the code.
 *****************************************************************************/
 void CMTask::do_marking_step(double time_target_ms) {
-guarantee( time_target_ms >= 1.0, "minimum granularity is 1ms" );
+assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
-guarantee( concurrent() == _cm->concurrent(), "they should be the same" );
+assert(concurrent() == _cm->concurrent(), "they should be the same");
-guarantee( concurrent() || _cm->region_stack_empty(),
+assert(concurrent() || _cm->region_stack_empty(),
-"the region stack should have been cleared before remark" );
+"the region stack should have been cleared before remark");
-guarantee( _region_finger == NULL,
+assert(_region_finger == NULL,
-"this should be non-null only when a region is being scanned" );
+"this should be non-null only when a region is being scanned");
 G1CollectorPolicy* g1_policy = _g1h->g1_policy();
-guarantee( _task_queues != NULL, "invariant" );
+assert(_task_queues != NULL, "invariant");
-guarantee( _task_queue != NULL,  "invariant" );
+assert(_task_queue != NULL, "invariant");
-guarantee( _task_queues->queue(_task_id) == _task_queue, "invariant" );
+assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
-guarantee( !_claimed,
+assert(!_claimed,
-"only one thread should claim this task at any one time" );
+"only one thread should claim this task at any one time");
 // OK, this doesn't safeguard again all possible scenarios, as it is
 // possible for two threads to set the _claimed flag at the same
 // time. But it is only for debugging purposes anyway and it will
 // catch most problems.
 drain_global_stack(true);
 do {
 if (!has_aborted() && _curr_region != NULL) {
 // This means that we're already holding on to a region.
-tmp_guarantee_CM( _finger != NULL,
+assert(_finger != NULL, "if region is not NULL, then the finger "
-"if region is not NULL, then the finger "
+"should not be NULL either");
-"should not be NULL either" );
 // We might have restarted this task after an evacuation pause
 // which might have evacuated the region we're holding on to
 // underneath our feet. Let's read its limit again to make sure
 // that we do not iterate over a region of the heap that
 // We successfully completed iterating over the region. Now,
 // let's give up the region.
 giveup_current_region();
 regular_clock_call();
 } else {
-guarantee( has_aborted(), "currently the only way to do so" );
+assert(has_aborted(), "currently the only way to do so");
 // The only way to abort the bitmap iteration is to return
 // false from the do_bit() method. However, inside the
 // do_bit() method we move the _finger to point to the
 // object currently being looked at. So, if we bail out, we
 // have definitely set _finger to something non-null.
-guarantee( _finger != NULL, "invariant" );
+assert(_finger != NULL, "invariant");
 // Region iteration was actually aborted. So now _finger
 // points to the address of the object we last scanned. If we
 // leave it there, when we restart this task, we will rescan
 // the object. It is easy to avoid this. We move the finger by
 // claiming and why we have to check out_of_regions() to determine
 // whether we're done or not.
 while (!has_aborted() && _curr_region == NULL && !_cm->out_of_regions()) {
 // We are going to try to claim a new region. We should have
 // given up on the previous one.
-tmp_guarantee_CM( _curr_region  == NULL &&
+// Separated the asserts so that we know which one fires.
-_finger       == NULL &&
+assert(_curr_region  == NULL, "invariant");
-_region_limit == NULL, "invariant" );
+assert(_finger       == NULL, "invariant");
+assert(_region_limit == NULL, "invariant");
 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
 gclog_or_tty->print_cr("[%d] we successfully claimed "
 "region "PTR_FORMAT,
 _task_id, claimed_region);
 setup_for_region(claimed_region);
-tmp_guarantee_CM( _curr_region == claimed_region, "invariant" );
+assert(_curr_region == claimed_region, "invariant");
 }
 // It is important to call the regular clock here. It might take
 // a while to claim a region if, for example, we hit a large
 // block of empty regions. So we need to call the regular clock
 // method once round the loop to make sure it's called
 // frequently enough.
 regular_clock_call();
 }
 if (!has_aborted() && _curr_region == NULL) {
-tmp_guarantee_CM( _cm->out_of_regions(),
+assert(_cm->out_of_regions(),
-"at this point we should be out of regions" );
+"at this point we should be out of regions");
 }
 } while ( _curr_region != NULL && !has_aborted());
 if (!has_aborted()) {
 // We cannot check whether the global stack is empty, since other
 // tasks might be pushing objects to it concurrently. We also cannot
 // check if the region stack is empty because if a thread is aborting
 // it can push a partially done region back.
-tmp_guarantee_CM( _cm->out_of_regions(),
+assert(_cm->out_of_regions(),
-"at this point we should be out of regions" );
+"at this point we should be out of regions");
 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
 // We cannot check whether the global stack is empty, since other
 // tasks might be pushing objects to it concurrently. We also cannot
 // check if the region stack is empty because if a thread is aborting
 // it can push a partially done region back.
-guarantee( _cm->out_of_regions() &&
+assert(_cm->out_of_regions() && _task_queue->size() == 0,
-_task_queue->size() == 0, "only way to reach here" );
+"only way to reach here");
 if (_cm->verbose_low())
 gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
 while (!has_aborted()) {
 gclog_or_tty->print_cr("[%d] stolen "PTR_FORMAT" successfully",
 _task_id, (void*) obj);
 statsOnly( ++_steals );
-tmp_guarantee_CM( _nextMarkBitMap->isMarked((HeapWord*) obj),
+assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
-"any stolen object should be marked" );
+"any stolen object should be marked");
 scan_object(obj);
 // And since we're towards the end, let's totally drain the
 // local queue and global stack.
 drain_local_queue(false);
 if (!has_aborted()) {
 // We cannot check whether the global stack is empty, since other
 // tasks might be concurrently pushing objects on it. We also cannot
 // check if the region stack is empty because if a thread is aborting
 // it can push a partially done region back.
-guarantee( _cm->out_of_regions() &&
+// Separated the asserts so that we know which one fires.
-_task_queue->size() == 0, "only way to reach here" );
+assert(_cm->out_of_regions(), "only way to reach here");
+assert(_task_queue->size() == 0, "only way to reach here");
 if (_cm->verbose_low())
 gclog_or_tty->print_cr("[%d] starting termination protocol", _task_id);
 _termination_start_time_ms = os::elapsedVTime() * 1000.0;
 // We're all done.
 if (_task_id == 0) {
 // let's allow task 0 to do this
 if (concurrent()) {
-guarantee( _cm->concurrent_marking_in_progress(), "invariant" );
+assert(_cm->concurrent_marking_in_progress(), "invariant");
 // we need to set this to false before the next
 // safepoint. This way we ensure that the marking phase
 // doesn't observe any more heap expansions.
 _cm->clear_concurrent_marking_in_progress();
 }
 }
 // We can now guarantee that the global stack is empty, since
-// all other tasks have finished.
+// all other tasks have finished. We separated the guarantees so
-guarantee( _cm->out_of_regions() &&
+// that, if a condition is false, we can immediately find out
-_cm->region_stack_empty() &&
+// which one.
-_cm->mark_stack_empty() &&
+guarantee(_cm->out_of_regions(), "only way to reach here");
-_task_queue->size() == 0 &&
+guarantee(_cm->region_stack_empty(), "only way to reach here");
-!_cm->has_overflown() &&
+guarantee(_cm->mark_stack_empty(), "only way to reach here");
-!_cm->mark_stack_overflow() &&
+guarantee(_task_queue->size() == 0, "only way to reach here");
-!_cm->region_stack_overflow(),
+guarantee(!_cm->has_overflown(), "only way to reach here");
-"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())
 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
 _claimed(false),
 _nextMarkBitMap(NULL), _hash_seed(17),
 _task_queue(task_queue),
 _task_queues(task_queues),
 _oop_closure(NULL) {
-guarantee( task_queue != NULL, "invariant" );
+guarantee(task_queue != NULL, "invariant");
-guarantee( task_queues != NULL, "invariant" );
+guarantee(task_queues != NULL, "invariant");
 statsOnly( _clock_due_to_scanning = 0;
 _clock_due_to_marking  = 0 );
 _marking_step_diffs_ms.add(0.5);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 1023:11d4857fe5e1