jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp

equal deleted inserted replaced

-:ae163b62b9ac
+:7d4376f8560e
 }
 class NoteStartOfMarkHRClosure: public HeapRegionClosure {
 public:
 bool doHeapRegion(HeapRegion* r) {
-if (!r->continuesHumongous()) {
+if (!r->is_continues_humongous()) {
 r->note_start_of_marking();
 }
 return false;
 }
 };
 // live object in it and sets its corresponding bit on the region
 // bitmap to 1. If the region is "starts humongous" it will also set
 // to 1 the bits on the region bitmap that correspond to its
 // associated "continues humongous" regions.
 void set_bit_for_region(HeapRegion* hr) {
-assert(!hr->continuesHumongous(), "should have filtered those out");
+assert(!hr->is_continues_humongous(), "should have filtered those out");
 BitMap::idx_t index = (BitMap::idx_t) hr->hrm_index();
-if (!hr->startsHumongous()) {
+if (!hr->is_starts_humongous()) {
 // Normal (non-humongous) case: just set the bit.
 _region_bm->par_at_put(index, true);
 } else {
 // Starts humongous case: calculate how many regions are part of
 // this humongous region and then set the bit range.
 CMCountDataClosureBase(g1h, region_bm, card_bm),
 _bm(bm), _region_marked_bytes(0) { }
 bool doHeapRegion(HeapRegion* hr) {
-if (hr->continuesHumongous()) {
+if (hr->is_continues_humongous()) {
 // 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
 // associated "starts humongous" region to have their bit set to
 // 1 since, due to the region chunking in the parallel region
 _failures(0) { }
 int failures() const { return _failures; }
 bool doHeapRegion(HeapRegion* hr) {
-if (hr->continuesHumongous()) {
+if (hr->is_continues_humongous()) {
 // 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
 // associated "starts humongous" region to have their bit set to
 // 1 since, due to the region chunking in the parallel region
 BitMap* card_bm) :
 CMCountDataClosureBase(g1h, region_bm, card_bm) { }
 bool doHeapRegion(HeapRegion* hr) {
-if (hr->continuesHumongous()) {
+if (hr->is_continues_humongous()) {
 // 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
 // associated "starts humongous" region to have their bit set to
 // 1 since, due to the region chunking in the parallel region
 size_t freed_bytes() { return _freed_bytes; }
 const HeapRegionSetCount& old_regions_removed() { return _old_regions_removed; }
 const HeapRegionSetCount& humongous_regions_removed() { return _humongous_regions_removed; }
 bool doHeapRegion(HeapRegion *hr) {
-if (hr->continuesHumongous()) {
+if (hr->is_continues_humongous()) {
 return false;
 }
 // We use a claim value of zero here because all regions
 // were claimed with value 1 in the FinalCount task.
 _g1->reset_gc_time_stamps(hr);
 _max_live_bytes += hr->max_live_bytes();
 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
 _freed_bytes += hr->used();
 hr->set_containing_set(NULL);
-if (hr->isHumongous()) {
+if (hr->is_humongous()) {
-assert(hr->startsHumongous(), "we should only see starts humongous");
+assert(hr->is_starts_humongous(), "we should only see starts humongous");
 _humongous_regions_removed.increment(1u, hr->capacity());
 _g1->free_humongous_region(hr, _local_cleanup_list, true);
 } else {
 _old_regions_removed.increment(1u, hr->capacity());
 _g1->free_region(hr, _local_cleanup_list, true);
 _g1h(g1h), _cm(g1h->concurrent_mark()),
 _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
 _cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
 bool doHeapRegion(HeapRegion* hr) {
-if (hr->continuesHumongous()) {
+if (hr->is_continues_humongous()) {
 // We will ignore these here and process them when their
 // associated "starts humongous" region is processed.
 // Note that we cannot rely on their associated
 // "starts humongous" region to have their bit set to 1
 // since, due to the region chunking in the parallel region
 }
 void CMTask::setup_for_region(HeapRegion* hr) {
 assert(hr != NULL,
 "claim_region() should have filtered out NULL regions");
-assert(!hr->continuesHumongous(),
+assert(!hr->is_continues_humongous(),
 "claim_region() should have filtered out continues humongous regions");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
 _worker_id, p2i(hr));
 "of region "HR_FORMAT,
 _worker_id, p2i(_finger), p2i(_region_limit),
 HR_FORMAT_PARAMS(_curr_region));
 }
-assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
+assert(!_curr_region->is_humongous() || mr.start() == _curr_region->bottom(),
 "humongous regions should go around loop once only");
 // Some special cases:
 // If the memory region is empty, we can just give up the region.
 // If the current region is humongous then we only need to check
 // that is left.
 // If the iteration is successful, give up the region.
 if (mr.is_empty()) {
 giveup_current_region();
 regular_clock_call();
-} else if (_curr_region->isHumongous() && mr.start() == _curr_region->bottom()) {
+} else if (_curr_region->is_humongous() && mr.start() == _curr_region->bottom()) {
 if (_nextMarkBitMap->isMarked(mr.start())) {
 // The object is marked - apply the closure
 BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start());
 bitmap_closure.do_bit(offset);
 }
 size_t next_live_bytes = r->next_live_bytes();
 double gc_eff          = r->gc_efficiency();
 size_t remset_bytes    = r->rem_set()->mem_size();
 size_t strong_code_roots_bytes = r->rem_set()->strong_code_roots_mem_size();
-if (r->startsHumongous()) {
+if (r->is_starts_humongous()) {
 assert(_hum_used_bytes == 0 && _hum_capacity_bytes == 0 &&
 _hum_prev_live_bytes == 0 && _hum_next_live_bytes == 0,
 "they should have been zeroed after the last time we used them");
 // Set up the _hum_* fields.
 _hum_capacity_bytes  = capacity_bytes;
 _hum_prev_live_bytes = prev_live_bytes;
 _hum_next_live_bytes = next_live_bytes;
 get_hum_bytes(&used_bytes, &capacity_bytes,
 &prev_live_bytes, &next_live_bytes);
 end = bottom + HeapRegion::GrainWords;
-} else if (r->continuesHumongous()) {
+} else if (r->is_continues_humongous()) {
 get_hum_bytes(&used_bytes, &capacity_bytes,
 &prev_live_bytes, &next_live_bytes);
 assert(end == bottom + HeapRegion::GrainWords, "invariant");
 }

changeset 26846	7d4376f8560e
parent 26841	d460d343d888
child 26848	03841b8f3633