--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Fri Oct 16 14:08:44 2009 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Mon Oct 19 17:02:19 2009 -0400
@@ -237,7 +237,7 @@
_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];
}
}
@@ -310,12 +310,12 @@
if (res == index) {
MemRegion mr = _base[next_index];
if (mr.start() != NULL) {
- tmp_guarantee_CM( mr.end() != NULL, "invariant" );
- tmp_guarantee_CM( mr.word_size() > 0, "invariant" );
+ assert(mr.end() != NULL, "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.
@@ -328,10 +328,10 @@
for (int i = 0; i < _oops_do_bound; ++i) {
MemRegion mr = _base[i];
if (mr.start() != NULL) {
- tmp_guarantee_CM( mr.end() != NULL, "invariant");
- tmp_guarantee_CM( mr.word_size() > 0, "invariant" );
+ assert(mr.end() != NULL, "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();
@@ -339,7 +339,7 @@
}
} else {
// that entry was invalidated... let's skip it
- tmp_guarantee_CM( mr.end() == NULL, "invariant" );
+ assert(mr.end() == NULL, "invariant");
}
}
return result;
@@ -542,8 +542,8 @@
gclog_or_tty->print_cr("CL Sleep Factor %1.4lf", cleanup_sleep_factor());
#endif
- guarantee( parallel_marking_threads() > 0, "peace of mind" );
- _parallel_workers = new WorkGang("Parallel Marking Threads",
+ 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.");
@@ -569,8 +569,7 @@
return;
MemRegion committed = _g1h->g1_committed();
- tmp_guarantee_CM( committed.start() == _heap_start,
- "start shouldn't change" );
+ assert(committed.start() == _heap_start, "start shouldn't change");
HeapWord* new_end = committed.end();
if (new_end > _heap_end) {
// The heap has been expanded.
@@ -592,9 +591,10 @@
_heap_start = committed.start();
_heap_end = committed.end();
- guarantee( _heap_start != NULL &&
- _heap_end != NULL &&
- _heap_start < _heap_end, "heap bounds should look ok" );
+ // Separated the asserts so that we know which one fires.
+ assert(_heap_start != NULL, "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();
@@ -614,7 +614,7 @@
}
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
@@ -634,8 +634,8 @@
// 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" );
- guarantee( _finger == _heap_end, "only way to get here" );
+ assert(!concurrent_marking_in_progress(), "invariant");
+ assert(_finger == _heap_end, "only way to get here");
update_g1_committed(true);
}
}
@@ -933,8 +933,8 @@
// 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),
- "address should be within the heap bounds" );
+ assert(_g1h->g1_committed().contains(addr),
+ "address should be within the heap bounds");
if (!_nextMarkBitMap->isMarked(addr))
_nextMarkBitMap->parMark(addr);
@@ -960,12 +960,15 @@
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" );
-
- tmp_guarantee_CM( mr.start() <= mr.end() &&
- _heap_start <= mr.start() &&
- mr.end() <= _heap_end,
- "region boundaries should fall within the committed space" );
+ assert(mr.end() <= finger, "invariant");
+
+ // Separated the asserts so that we know which one fires.
+ assert(mr.start() <= mr.end(),
+ "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",
@@ -1014,14 +1017,14 @@
public:
void work(int worker_i) {
- guarantee( Thread::current()->is_ConcurrentGC_thread(),
- "this should only be done by a conc GC thread" );
+ assert(Thread::current()->is_ConcurrentGC_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()) {
@@ -1059,7 +1062,7 @@
} 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();
@@ -1182,8 +1185,7 @@
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),
- "Should already be set.");
+ guarantee(_card_bm->at(i - _bottom_card_num), "Should already be set.");
#else
_card_bm->par_at_put(i - _bottom_card_num, 1);
#endif
@@ -1442,7 +1444,7 @@
}
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();
}
@@ -1774,14 +1776,14 @@
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?");
}
}
}
@@ -1931,9 +1933,6 @@
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
@@ -1945,10 +1944,9 @@
// 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" );
}
+ SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
+ guarantee(satb_mq_set.completed_buffers_num() == 0, "invariant");
print_stats();
@@ -1989,7 +1987,7 @@
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))
@@ -2125,7 +2123,7 @@
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())
@@ -2167,7 +2165,7 @@
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) {
@@ -2200,7 +2198,7 @@
// _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?
@@ -2222,7 +2220,7 @@
// 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 = "
@@ -2234,8 +2232,8 @@
"returning it ", task_num, curr_region);
return curr_region;
} else {
- tmp_guarantee_CM( limit == bottom,
- "the region limit should be at bottom" );
+ assert(limit == 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);
@@ -2244,7 +2242,7 @@
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", "
@@ -2282,7 +2280,7 @@
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");
}
}
@@ -2637,6 +2635,10 @@
cmThread()->vtime_count_accum());
}
+void ConcurrentMark::print_worker_threads_on(outputStream* st) const {
+ _parallel_workers->print_worker_threads_on(st);
+}
+
// Closures
// XXX: there seems to be a lot of code duplication here;
// should refactor and consolidate the shared code.
@@ -2711,12 +2713,12 @@
bool do_bit(size_t offset) {
HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset);
- tmp_guarantee_CM( _nextMarkBitMap->isMarked(addr), "invariant" );
- tmp_guarantee_CM( addr < _cm->finger(), "invariant" );
+ assert(_nextMarkBitMap->isMarked(addr), "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 {
@@ -2761,8 +2763,9 @@
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" );
- tmp_guarantee_CM( !_g1h->heap_region_containing((HeapWord*) p)->is_on_free_list(), "invariant" );
+ assert(_g1h->is_in_g1_reserved((HeapWord*) p), "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())
@@ -2779,8 +2782,11 @@
};
void CMTask::setup_for_region(HeapRegion* hr) {
- tmp_guarantee_CM( hr != NULL && !hr->continuesHumongous(),
- "claim_region() should have filtered out continues humongous regions" );
+ // Separated the asserts so that we know which one fires.
+ 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,
@@ -2808,9 +2814,9 @@
// 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
@@ -2828,7 +2834,7 @@
}
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);
@@ -2846,7 +2852,7 @@
}
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);
@@ -2912,7 +2918,7 @@
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())
@@ -2973,10 +2979,11 @@
void CMTask::push(oop obj) {
HeapWord* objAddr = (HeapWord*) obj;
- tmp_guarantee_CM( _g1h->is_in_g1_reserved(objAddr), "invariant" );
- tmp_guarantee_CM( !_g1h->heap_region_containing(objAddr)->is_on_free_list(), "invariant" );
- tmp_guarantee_CM( !_g1h->is_obj_ill(obj), "invariant" );
- tmp_guarantee_CM( _nextMarkBitMap->isMarked(objAddr), "invariant" );
+ assert(_g1h->is_in_g1_reserved(objAddr), "invariant");
+ assert(!_g1h->heap_region_containing(objAddr)->is_on_free_list(),
+ "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);
@@ -2995,7 +3002,7 @@
// 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();
@@ -3005,9 +3012,9 @@
}
void CMTask::reached_limit() {
- tmp_guarantee_CM( _words_scanned >= _words_scanned_limit ||
- _refs_reached >= _refs_reached_limit ,
- "shouldn't have been called otherwise" );
+ assert(_words_scanned >= _words_scanned_limit ||
+ _refs_reached >= _refs_reached_limit ,
+ "shouldn't have been called otherwise");
regular_clock_call();
}
@@ -3165,8 +3172,8 @@
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,
- "we should not pop more than the given limit" );
+ assert(n <= global_stack_transfer_size,
+ "we should not pop more than the given limit");
if (n > 0) {
// yes, we did actually pop at least one entry
@@ -3178,7 +3185,7 @@
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();
@@ -3218,10 +3225,9 @@
gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
(void*) obj);
- tmp_guarantee_CM( _g1h->is_in_g1_reserved((HeapWord*) obj),
- "invariant" );
- tmp_guarantee_CM( !_g1h->heap_region_containing(obj)->is_on_free_list(),
- "invariant" );
+ assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
+ assert(!_g1h->heap_region_containing(obj)->is_on_free_list(),
+ "invariant");
scan_object(obj);
@@ -3243,7 +3249,7 @@
// 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
@@ -3324,9 +3330,9 @@
_draining_satb_buffers = false;
- tmp_guarantee_CM( has_aborted() ||
- concurrent() ||
- satb_mq_set.completed_buffers_num() == 0, "invariant" );
+ assert(has_aborted() ||
+ concurrent() ||
+ satb_mq_set.completed_buffers_num() == 0, "invariant");
if (ParallelGCThreads > 0)
satb_mq_set.set_par_closure(_task_id, NULL);
@@ -3342,8 +3348,8 @@
if (has_aborted())
return;
- tmp_guarantee_CM( _region_finger == NULL,
- "it should be NULL when we're not scanning a region" );
+ assert(_region_finger == NULL,
+ "it should be NULL when we're not scanning a region");
if (!_cm->region_stack_empty()) {
if (_cm->verbose_low())
@@ -3359,12 +3365,12 @@
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(),
- "otherwise the region shouldn't be on the stack" );
+ 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)) {
- tmp_guarantee_CM( !has_aborted(),
- "cannot abort the task without aborting the bitmap iteration" );
+ assert(!has_aborted(),
+ "cannot abort the task without aborting the bitmap iteration");
// We finished iterating over the region without aborting.
regular_clock_call();
@@ -3376,14 +3382,14 @@
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
@@ -3412,13 +3418,6 @@
_region_finger = NULL;
}
- // We only push regions on the region stack during evacuation
- // pauses. So if we come out the above iteration because we region
- // stack is empty, it will remain empty until the next yield
- // point. So, the guarantee below is safe.
- guarantee( has_aborted() || _cm->region_stack_empty(),
- "only way to exit the loop" );
-
if (_cm->verbose_low())
gclog_or_tty->print_cr("[%d] drained region stack, size = %d",
_task_id, _cm->region_stack_size());
@@ -3576,21 +3575,21 @@
*****************************************************************************/
void CMTask::do_marking_step(double time_target_ms) {
- guarantee( time_target_ms >= 1.0, "minimum granularity is 1ms" );
- guarantee( concurrent() == _cm->concurrent(), "they should be the same" );
-
- guarantee( concurrent() || _cm->region_stack_empty(),
- "the region stack should have been cleared before remark" );
- guarantee( _region_finger == NULL,
- "this should be non-null only when a region is being scanned" );
+ assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
+ assert(concurrent() == _cm->concurrent(), "they should be the same");
+
+ assert(concurrent() || _cm->region_stack_empty(),
+ "the region stack should have been cleared before remark");
+ assert(_region_finger == NULL,
+ "this should be non-null only when a region is being scanned");
G1CollectorPolicy* g1_policy = _g1h->g1_policy();
- guarantee( _task_queues != NULL, "invariant" );
- guarantee( _task_queue != NULL, "invariant" );
- guarantee( _task_queues->queue(_task_id) == _task_queue, "invariant" );
-
- guarantee( !_claimed,
- "only one thread should claim this task at any one time" );
+ assert(_task_queues != NULL, "invariant");
+ assert(_task_queue != NULL, "invariant");
+ assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
+
+ assert(!_claimed,
+ "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
@@ -3661,9 +3660,8 @@
do {
if (!has_aborted() && _curr_region != NULL) {
// This means that we're already holding on to a region.
- tmp_guarantee_CM( _finger != NULL,
- "if region is not NULL, then the finger "
- "should not be NULL either" );
+ assert(_finger != NULL, "if region is not NULL, then the finger "
+ "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
@@ -3695,13 +3693,13 @@
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
@@ -3728,9 +3726,10 @@
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 &&
- _finger == NULL &&
- _region_limit == NULL, "invariant" );
+ // 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())
gclog_or_tty->print_cr("[%d] trying to claim a new region", _task_id);
HeapRegion* claimed_region = _cm->claim_region(_task_id);
@@ -3744,7 +3743,7 @@
_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
@@ -3755,8 +3754,8 @@
}
if (!has_aborted() && _curr_region == NULL) {
- tmp_guarantee_CM( _cm->out_of_regions(),
- "at this point we should be out of regions" );
+ assert(_cm->out_of_regions(),
+ "at this point we should be out of regions");
}
} while ( _curr_region != NULL && !has_aborted());
@@ -3765,8 +3764,8 @@
// 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(),
- "at this point we should be out of regions" );
+ assert(_cm->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);
@@ -3790,8 +3789,8 @@
// 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() &&
- _task_queue->size() == 0, "only way to reach here" );
+ assert(_cm->out_of_regions() && _task_queue->size() == 0,
+ "only way to reach here");
if (_cm->verbose_low())
gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
@@ -3807,8 +3806,8 @@
statsOnly( ++_steals );
- tmp_guarantee_CM( _nextMarkBitMap->isMarked((HeapWord*) obj),
- "any stolen object should be marked" );
+ assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
+ "any stolen object should be marked");
scan_object(obj);
// And since we're towards the end, let's totally drain the
@@ -3828,8 +3827,9 @@
// 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() &&
- _task_queue->size() == 0, "only way to reach here" );
+ // 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())
gclog_or_tty->print_cr("[%d] starting termination protocol", _task_id);
@@ -3849,7 +3849,7 @@
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.
@@ -3858,15 +3858,16 @@
}
// We can now guarantee that the global stack is empty, since
- // all other tasks have finished.
- guarantee( _cm->out_of_regions() &&
- _cm->region_stack_empty() &&
- _cm->mark_stack_empty() &&
- _task_queue->size() == 0 &&
- !_cm->has_overflown() &&
- !_cm->mark_stack_overflow() &&
- !_cm->region_stack_overflow(),
- "only way to reach here" );
+ // all other tasks have finished. We separated the guarantees so
+ // that, if a condition is false, we can immediately find out
+ // which one.
+ guarantee(_cm->out_of_regions(), "only way to reach here");
+ guarantee(_cm->region_stack_empty(), "only way to reach here");
+ guarantee(_cm->mark_stack_empty(), "only way to reach here");
+ 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())
gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id);
@@ -3961,8 +3962,8 @@
_task_queue(task_queue),
_task_queues(task_queues),
_oop_closure(NULL) {
- guarantee( task_queue != NULL, "invariant" );
- guarantee( task_queues != NULL, "invariant" );
+ guarantee(task_queue != NULL, "invariant");
+ guarantee(task_queues != NULL, "invariant");
statsOnly( _clock_due_to_scanning = 0;
_clock_due_to_marking = 0 );