86 // non-memRegion version of oop_iterate below.
87 cur_oop->oop_iterate(_rs_scan);
88 }
89 cur = next_obj;
90 cur_oop = oop(cur);
91 oop_size = _hr->block_size(cur);
92 next_obj = cur + oop_size;
93 }
94
95 // Last object. Need to do dead-obj filtering here too.
96 if (!g1h->is_obj_dead(oop(cur), _hr)) {
97 oop(cur)->oop_iterate(_rs_scan, mr);
98 }
99 }
100 }
101
102 size_t HeapRegion::max_region_size() {
103 return HeapRegionBounds::max_size();
104 }
105
106 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
107 size_t region_size = G1HeapRegionSize;
108 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
109 size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
110 region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
111 HeapRegionBounds::min_size());
112 }
113
114 int region_size_log = log2_long((jlong) region_size);
115 // Recalculate the region size to make sure it's a power of
116 // 2. This means that region_size is the largest power of 2 that's
117 // <= what we've calculated so far.
118 region_size = ((size_t)1 << region_size_log);
119
120 // Now make sure that we don't go over or under our limits.
121 if (region_size < HeapRegionBounds::min_size()) {
122 region_size = HeapRegionBounds::min_size();
123 } else if (region_size > HeapRegionBounds::max_size()) {
124 region_size = HeapRegionBounds::max_size();
125 }
699 p2i(p), p2i(_containing_obj),
700 p2i(from->bottom()), p2i(from->end()));
701 print_object(gclog_or_tty, _containing_obj);
702 gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region "
703 "["PTR_FORMAT", "PTR_FORMAT")",
704 p2i(obj), p2i(to->bottom()), p2i(to->end()));
705 print_object(gclog_or_tty, obj);
706 }
707 gclog_or_tty->print_cr("----------");
708 gclog_or_tty->flush();
709 _failures = true;
710 failed = true;
711 _n_failures++;
712 }
713
714 if (!_g1h->full_collection() || G1VerifyRSetsDuringFullGC) {
715 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
716 HeapRegion* to = _g1h->heap_region_containing(obj);
717 if (from != NULL && to != NULL &&
718 from != to &&
719 !to->is_humongous()) {
720 jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
721 jbyte cv_field = *_bs->byte_for_const(p);
722 const jbyte dirty = CardTableModRefBS::dirty_card_val();
723
724 bool is_bad = !(from->is_young()
725 || to->rem_set()->contains_reference(p)
726 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
727 (_containing_obj->is_objArray() ?
728 cv_field == dirty
729 : cv_obj == dirty || cv_field == dirty));
730 if (is_bad) {
731 MutexLockerEx x(ParGCRareEvent_lock,
732 Mutex::_no_safepoint_check_flag);
733
734 if (!_failures) {
735 gclog_or_tty->cr();
736 gclog_or_tty->print_cr("----------");
737 }
738 gclog_or_tty->print_cr("Missing rem set entry:");
739 gclog_or_tty->print_cr("Field "PTR_FORMAT" "
|
86 // non-memRegion version of oop_iterate below.
87 cur_oop->oop_iterate(_rs_scan);
88 }
89 cur = next_obj;
90 cur_oop = oop(cur);
91 oop_size = _hr->block_size(cur);
92 next_obj = cur + oop_size;
93 }
94
95 // Last object. Need to do dead-obj filtering here too.
96 if (!g1h->is_obj_dead(oop(cur), _hr)) {
97 oop(cur)->oop_iterate(_rs_scan, mr);
98 }
99 }
100 }
101
102 size_t HeapRegion::max_region_size() {
103 return HeapRegionBounds::max_size();
104 }
105
106 size_t HeapRegion::min_region_size_in_words() {
107 return HeapRegionBounds::min_size() >> LogHeapWordSize;
108 }
109
110 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
111 size_t region_size = G1HeapRegionSize;
112 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
113 size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
114 region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
115 HeapRegionBounds::min_size());
116 }
117
118 int region_size_log = log2_long((jlong) region_size);
119 // Recalculate the region size to make sure it's a power of
120 // 2. This means that region_size is the largest power of 2 that's
121 // <= what we've calculated so far.
122 region_size = ((size_t)1 << region_size_log);
123
124 // Now make sure that we don't go over or under our limits.
125 if (region_size < HeapRegionBounds::min_size()) {
126 region_size = HeapRegionBounds::min_size();
127 } else if (region_size > HeapRegionBounds::max_size()) {
128 region_size = HeapRegionBounds::max_size();
129 }
703 p2i(p), p2i(_containing_obj),
704 p2i(from->bottom()), p2i(from->end()));
705 print_object(gclog_or_tty, _containing_obj);
706 gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region "
707 "["PTR_FORMAT", "PTR_FORMAT")",
708 p2i(obj), p2i(to->bottom()), p2i(to->end()));
709 print_object(gclog_or_tty, obj);
710 }
711 gclog_or_tty->print_cr("----------");
712 gclog_or_tty->flush();
713 _failures = true;
714 failed = true;
715 _n_failures++;
716 }
717
718 if (!_g1h->full_collection() || G1VerifyRSetsDuringFullGC) {
719 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
720 HeapRegion* to = _g1h->heap_region_containing(obj);
721 if (from != NULL && to != NULL &&
722 from != to &&
723 !to->is_pinned()) {
724 jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
725 jbyte cv_field = *_bs->byte_for_const(p);
726 const jbyte dirty = CardTableModRefBS::dirty_card_val();
727
728 bool is_bad = !(from->is_young()
729 || to->rem_set()->contains_reference(p)
730 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
731 (_containing_obj->is_objArray() ?
732 cv_field == dirty
733 : cv_obj == dirty || cv_field == dirty));
734 if (is_bad) {
735 MutexLockerEx x(ParGCRareEvent_lock,
736 Mutex::_no_safepoint_check_flag);
737
738 if (!_failures) {
739 gclog_or_tty->cr();
740 gclog_or_tty->print_cr("----------");
741 }
742 gclog_or_tty->print_cr("Missing rem set entry:");
743 gclog_or_tty->print_cr("Field "PTR_FORMAT" "
|