67   assert(_virtual_space.committed_size() == brs.size(),
70   assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >=
87   assert(nextAddr >= addr, "get_next_one postcondition");
88   assert(nextAddr == limit || isMarked(nextAddr),
102   assert(nextAddr >= addr, "get_next_one postcondition");
103   assert(nextAddr == limit || !isMarked(nextAddr),
109   assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
115   // assert(_bm.map() == _virtual_space.low(), "map inconsistency");
116   assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize,
130   assert(!mr.is_empty(), "unexpected empty region");
131   assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==
141   assert(!mr.is_empty(), "unexpected empty region");
153   assert(start <= end, "Consistency check");
224         assert(ind < _capacity, "By overflow test above.");
247     assert(ind < _capacity, "By overflow test above.");
273   assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after
281     assert(G1CollectedHeap::heap()->is_in_reserved(newOop), "Bad pop");
282     assert(newOop->is_oop(), "Expected an oop");
283     assert(bm == NULL || bm->isMarked((HeapWord*)newOop),
296   assert(_saved_index == -1,
302   // This is intentionally a guarantee, instead of an assert. If we
313   assert(_saved_index == _index,
336   assert(!scan_in_progress(), "pre-condition");
339   assert(_next_survivor == NULL, "pre-condition");
371   assert(res == NULL || res->is_survivor(), "post-condition");
377   assert(scan_in_progress(), "pre-condition");
381     assert(_next_survivor == NULL, "we should have claimed all survivors");
476   assert(cmThread() != NULL, "CM Thread should have been created");
477   assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
480   assert(CGC_lock != NULL, "Where's the CGC_lock?");
481   assert(_markBitMap1.covers(rs), "_markBitMap1 inconsistency");
482   assert(_markBitMap2.covers(rs), "_markBitMap2 inconsistency");
568     assert(ConcGCThreads > 0, "Should have been set");
609   assert(committed.start() == _heap_start, "start shouldn't change");
632   assert(_heap_start != NULL, "heap bounds should look ok");
633   assert(_heap_end != NULL, "heap bounds should look ok");
634   assert(_heap_start < _heap_end, "heap bounds should look ok");
662     assert(has_overflown(), "pre-condition");
673   assert(active_tasks <= _max_task_num, "we should not have more");
697     assert(!concurrent_marking_in_progress(), "invariant");
698     assert(_finger == _heap_end,
753     assert(cmThread()->during_cycle(), "invariant");
754     assert(!g1h->mark_in_progress(), "invariant");
949     assert(Thread::current()->is_ConcurrentGC_thread(),
957     assert(worker_id < _cm->active_tasks(), "invariant");
1034     assert(n_conc_workers > 0, "Always need at least 1");
1045   assert(hr->next_top_at_mark_start() == hr->bottom(), "invariant");
1055     assert(size == obj->size(), "sanity");
1069     assert(Thread::current()->is_ConcurrentGC_thread(),
1087     assert(parallel_marking_threads() <= max_parallel_marking_threads(),
1107   // we might be tempted to assert that:
1108   // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
1119   assert(parallel_marking_threads() <= max_parallel_marking_threads(),
1132     assert(_parallel_workers->active_workers() > 0, "Should have been set");
1142   assert(SafepointSynchronize::is_at_safepoint(),
1212     assert(!restart_for_overflow(), "sanity");
1251     assert(!hr->continuesHumongous(), "should have filtered those out");
1301     assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
1426     assert(res == false, "should be continuing");
1527     assert(VerifyDuringGC, "don't call this otherwise");
1532       assert( _g1h->workers()->active_workers() > 0,
1539     assert(_expected_card_bm->size() == _actual_card_bm->size(), "sanity");
1540     assert(_expected_region_bm->size() == _actual_region_bm->size(), "sanity");
1546     assert(worker_id < _n_workers, "invariant");
1599     assert(hr->bottom() <= ntams && ntams <= hr->end(), "Preconditions.");
1620       assert(end_idx <= _card_bm->size(),
1623       assert(start_idx < _card_bm->size(),
1657       assert( _g1h->workers()->active_workers() > 0,
1666     assert(worker_id < _n_workers, "invariant");
1780     assert(g1_note_end.complete(), "Shouldn't have yielded!");
1811       assert(local_cleanup_list.is_empty(), "post-condition");
1844   assert(SafepointSynchronize::is_at_safepoint(),
1878    assert(g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
1883     assert(g1h->n_par_threads() == n_workers,
1889     assert(g1h->check_heap_region_claim_values(HeapRegion::FinalCountClaimValue),
1916       assert(g1h->check_heap_region_claim_values(HeapRegion::VerifyCountClaimValue),
1949     assert(g1h->check_heap_region_claim_values(HeapRegion::NoteEndClaimValue),
1973       assert(g1h->check_heap_region_claim_values(
2042     assert(hr != NULL, "the list was not empty");
2075   assert(tmp_free_list.is_empty(), "post-condition");
2109     assert(_ref_counter_limit > 0, "sanity");
2110     assert(!_is_serial || _task->task_id() == 0, "only task 0 for serial code");
2176     assert(!_is_serial || _task->task_id() == 0, "only task 0 for serial code");
2246     assert(rp->processing_is_mt(), "shouldn't be here otherwise");
2260   assert(_workers != NULL, "Need parallel worker threads.");
2261   assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
2290   assert(_workers != NULL, "Need parallel worker threads.");
2291   assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
2341     assert(_markStack.isEmpty(), "mark stack should be empty");
2398     assert(_markStack.overflow() || _markStack.isEmpty(),
2407     assert(rp->num_q() == active_workers, "why not");
2412     assert(!rp->discovery_enabled(), "Post condition");
2467       assert(active_workers > 0, "Should have been set earlier");
2494     // cause an assert that the current thread is not a
2704     assert(_g1h->is_in_g1_reserved(finger), "invariant");
2748       assert(_finger >= end, "the finger should have moved forward");
2762         assert(limit == bottom,
2773       assert(_finger > finger, "the finger should have moved forward");
2848   assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
2900     assert(parallel_marking_threads() <= _max_task_num, "sanity");
2950     assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
2956     assert(hr->next_marked_bytes() == 0, "Precondition");
2964     assert(_g1h->is_in_g1_reserved(start) && _ct_bs->is_card_aligned(start), "sanity");
2966     assert(!_g1h->is_in_g1_reserved(end) || _ct_bs->is_card_aligned(end), "sanity");
2983     assert(limit_idx <= end_idx, "or else use atomics");
3002         assert(task_card_bm->at(scan_idx) == true, "should be");
3004         assert(_cm_card_bm->at(scan_idx) == true, "should be");
3066     assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
3072     assert(_g1h->check_heap_region_claim_values(HeapRegion::AggregateCountClaimValue),
3092   assert(_max_task_num != 0, "unitialized");
3098     assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
3099     assert(marked_bytes_array != NULL, "uninitialized");
3229   assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
3258     assert(_nextMarkBitMap->isMarked(addr), "invariant");
3259     assert( addr < _cm->finger(), "invariant");
3262     assert(addr >= _task->finger(), "invariant");
3296   assert(_ref_processor == NULL, "should be initialized to NULL");
3300     assert(_ref_processor != NULL, "should not be NULL");
3306   assert(hr != NULL,
3308   assert(!hr->continuesHumongous(),
3339     assert(limit >= _finger, "peace of mind");
3341     assert(limit < _region_limit, "only way to get here");
3359   assert(_curr_region != NULL, "invariant");
3377     assert(_cm_oop_closure != NULL, "invariant");
3379     assert(_cm_oop_closure == NULL, "invariant");
3433   assert(_words_scanned >= _words_scanned_limit ||
3599   assert(n <= global_stack_transfer_size,
3613       assert(success, "invariant");
3656       assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
3657       assert(!_g1h->is_on_master_free_list(
3681   assert(partially || _task_queue->size() == 0, "invariant");
3768   assert(has_aborted() ||
3941   assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
3942   assert(concurrent() == _cm->concurrent(), "they should be the same");
3945   assert(_task_queues != NULL, "invariant");
3946   assert(_task_queue != NULL, "invariant");
3947   assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
3949   assert(!_claimed,
4017       assert(_finger != NULL, "if region is not NULL, then the finger "
4049         assert(has_aborted(), "currently the only way to do so");
4055         assert(_finger != NULL, "invariant");
4064         assert(_finger < _region_limit, "invariant");
4090       assert(_curr_region  == NULL, "invariant");
4091       assert(_finger       == NULL, "invariant");
4092       assert(_region_limit == NULL, "invariant");
4108         assert(_curr_region == claimed_region, "invariant");
4119       assert(_cm->out_of_regions(),
4127     assert(_cm->out_of_regions(),
4151     assert(_cm->out_of_regions() && _task_queue->size() == 0,
4170         assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
4199     assert(_cm->out_of_regions(), "only way to reach here");
4200     assert(_task_queue->size() == 0, "only way to reach here");
4223           assert(_cm->concurrent_marking_in_progress(), "invariant");
4459   assert(_hum_used_bytes > 0 && _hum_capacity_bytes > 0, "pre-condition");
4484     assert(_hum_used_bytes == 0 && _hum_capacity_bytes == 0 &&
4499     assert(end == bottom + HeapRegion::GrainWords, "invariant");

Indexes created Tue Jul 24 14:28:13 CEST 2018