588 if (cb_cl.failures()) {
589 *failures = true;
590 }
591 }
592
593 void HeapRegion::print() const { print_on(gclog_or_tty); }
594 void HeapRegion::print_on(outputStream* st) const {
595 st->print("AC%4u", allocation_context());
596
597 st->print(" %2s", get_short_type_str());
598 if (in_collection_set())
599 st->print(" CS");
600 else
601 st->print(" ");
602 st->print(" TS %5d", _gc_time_stamp);
603 st->print(" PTAMS " PTR_FORMAT " NTAMS " PTR_FORMAT,
604 p2i(prev_top_at_mark_start()), p2i(next_top_at_mark_start()));
605 G1OffsetTableContigSpace::print_on(st);
606 }
607
608 class VerifyLiveClosure: public OopClosure {
609 private:
610 G1CollectedHeap* _g1h;
611 CardTableModRefBS* _bs;
612 oop _containing_obj;
613 bool _failures;
614 int _n_failures;
615 VerifyOption _vo;
616 public:
617 // _vo == UsePrevMarking -> use "prev" marking information,
618 // _vo == UseNextMarking -> use "next" marking information,
619 // _vo == UseMarkWord -> use mark word from object header.
620 VerifyLiveClosure(G1CollectedHeap* g1h, VerifyOption vo) :
621 _g1h(g1h), _bs(barrier_set_cast<CardTableModRefBS>(g1h->barrier_set())),
622 _containing_obj(NULL), _failures(false), _n_failures(0), _vo(vo)
623 { }
624
625 void set_containing_obj(oop obj) {
626 _containing_obj = obj;
627 }
628
629 bool failures() { return _failures; }
630 int n_failures() { return _n_failures; }
631
632 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
633 virtual void do_oop( oop* p) { do_oop_work(p); }
634
635 void print_object(outputStream* out, oop obj) {
636 #ifdef PRODUCT
637 Klass* k = obj->klass();
638 const char* class_name = k->external_name();
639 out->print_cr("class name %s", class_name);
640 #else // PRODUCT
641 obj->print_on(out);
642 #endif // PRODUCT
643 }
644
645 template <class T>
646 void do_oop_work(T* p) {
647 assert(_containing_obj != NULL, "Precondition");
648 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo),
649 "Precondition");
650 T heap_oop = oopDesc::load_heap_oop(p);
651 if (!oopDesc::is_null(heap_oop)) {
652 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
653 bool failed = false;
654 if (!_g1h->is_in_closed_subset(obj) || _g1h->is_obj_dead_cond(obj, _vo)) {
655 MutexLockerEx x(ParGCRareEvent_lock,
656 Mutex::_no_safepoint_check_flag);
657
658 if (!_failures) {
659 gclog_or_tty->cr();
660 gclog_or_tty->print_cr("----------");
661 }
662 if (!_g1h->is_in_closed_subset(obj)) {
663 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
664 gclog_or_tty->print_cr("Field " PTR_FORMAT
665 " of live obj " PTR_FORMAT " in region "
666 "[" PTR_FORMAT ", " PTR_FORMAT ")",
667 p2i(p), p2i(_containing_obj),
668 p2i(from->bottom()), p2i(from->end()));
669 print_object(gclog_or_tty, _containing_obj);
670 gclog_or_tty->print_cr("points to obj " PTR_FORMAT " not in the heap",
671 p2i(obj));
672 } else {
673 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
674 HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj);
675 gclog_or_tty->print_cr("Field " PTR_FORMAT
676 " of live obj " PTR_FORMAT " in region "
677 "[" PTR_FORMAT ", " PTR_FORMAT ")",
678 p2i(p), p2i(_containing_obj),
679 p2i(from->bottom()), p2i(from->end()));
680 print_object(gclog_or_tty, _containing_obj);
681 gclog_or_tty->print_cr("points to dead obj " PTR_FORMAT " in region "
682 "[" PTR_FORMAT ", " PTR_FORMAT ")",
683 p2i(obj), p2i(to->bottom()), p2i(to->end()));
684 print_object(gclog_or_tty, obj);
685 }
686 gclog_or_tty->print_cr("----------");
687 gclog_or_tty->flush();
688 _failures = true;
689 failed = true;
690 _n_failures++;
691 }
692
693 if (!_g1h->collector_state()->full_collection() || G1VerifyRSetsDuringFullGC) {
694 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
695 HeapRegion* to = _g1h->heap_region_containing(obj);
696 if (from != NULL && to != NULL &&
697 from != to &&
698 !to->is_pinned()) {
699 jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
700 jbyte cv_field = *_bs->byte_for_const(p);
701 const jbyte dirty = CardTableModRefBS::dirty_card_val();
702
703 bool is_bad = !(from->is_young()
704 || to->rem_set()->contains_reference(p)
705 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
706 (_containing_obj->is_objArray() ?
707 cv_field == dirty
708 : cv_obj == dirty || cv_field == dirty));
709 if (is_bad) {
710 MutexLockerEx x(ParGCRareEvent_lock,
711 Mutex::_no_safepoint_check_flag);
712
713 if (!_failures) {
714 gclog_or_tty->cr();
719 "of obj " PTR_FORMAT ", "
720 "in region " HR_FORMAT,
721 p2i(p), p2i(_containing_obj),
722 HR_FORMAT_PARAMS(from));
723 _containing_obj->print_on(gclog_or_tty);
724 gclog_or_tty->print_cr("points to obj " PTR_FORMAT " "
725 "in region " HR_FORMAT,
726 p2i(obj),
727 HR_FORMAT_PARAMS(to));
728 obj->print_on(gclog_or_tty);
729 gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",
730 cv_obj, cv_field);
731 gclog_or_tty->print_cr("----------");
732 gclog_or_tty->flush();
733 _failures = true;
734 if (!failed) _n_failures++;
735 }
736 }
737 }
738 }
739 }
740 };
741
742 // This really ought to be commoned up into OffsetTableContigSpace somehow.
743 // We would need a mechanism to make that code skip dead objects.
744
745 void HeapRegion::verify(VerifyOption vo,
746 bool* failures) const {
747 G1CollectedHeap* g1 = G1CollectedHeap::heap();
748 *failures = false;
749 HeapWord* p = bottom();
750 HeapWord* prev_p = NULL;
751 VerifyLiveClosure vl_cl(g1, vo);
752 bool is_region_humongous = is_humongous();
753 size_t object_num = 0;
754 while (p < top()) {
755 oop obj = oop(p);
756 size_t obj_size = block_size(p);
757 object_num += 1;
758
759 if (!g1->is_obj_dead_cond(obj, this, vo)) {
760 if (obj->is_oop()) {
761 Klass* klass = obj->klass();
857 // Look up end - 1
858 HeapWord* addr_4 = the_end - 1;
859 HeapWord* b_start_4 = _offsets.block_start_const(addr_4);
860 if (b_start_4 != p) {
861 gclog_or_tty->print_cr("BOT look up for end - 1: " PTR_FORMAT " "
862 " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
863 p2i(addr_4), p2i(b_start_4), p2i(p));
864 *failures = true;
865 return;
866 }
867 }
868
869 verify_strong_code_roots(vo, failures);
870 }
871
872 void HeapRegion::verify() const {
873 bool dummy = false;
874 verify(VerifyOption_G1UsePrevMarking, /* failures */ &dummy);
875 }
876
877 void HeapRegion::prepare_for_compaction(CompactPoint* cp) {
878 scan_and_forward(this, cp);
879 }
880
881 // G1OffsetTableContigSpace code; copied from space.cpp. Hope this can go
882 // away eventually.
883
884 void G1OffsetTableContigSpace::clear(bool mangle_space) {
885 set_top(bottom());
886 _scan_top = bottom();
887 CompactibleSpace::clear(mangle_space);
888 reset_bot();
889 }
890
891 void G1OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) {
892 Space::set_bottom(new_bottom);
893 _offsets.set_bottom(new_bottom);
894 }
895
896 void G1OffsetTableContigSpace::set_end(HeapWord* new_end) {
|
588 if (cb_cl.failures()) {
589 *failures = true;
590 }
591 }
592
593 void HeapRegion::print() const { print_on(gclog_or_tty); }
594 void HeapRegion::print_on(outputStream* st) const {
595 st->print("AC%4u", allocation_context());
596
597 st->print(" %2s", get_short_type_str());
598 if (in_collection_set())
599 st->print(" CS");
600 else
601 st->print(" ");
602 st->print(" TS %5d", _gc_time_stamp);
603 st->print(" PTAMS " PTR_FORMAT " NTAMS " PTR_FORMAT,
604 p2i(prev_top_at_mark_start()), p2i(next_top_at_mark_start()));
605 G1OffsetTableContigSpace::print_on(st);
606 }
607
608 class HeapRegionVerifyClosure : public OopClosure {
609 protected:
610 G1CollectedHeap* _g1h;
611 CardTableModRefBS* _bs;
612 oop _containing_obj;
613 bool _failures;
614 int _n_failures;
615 VerifyOption _vo;
616 public:
617 // _vo == UsePrevMarking -> use "prev" marking information,
618 // _vo == UseNextMarking -> use "next" marking information,
619 // _vo == UseMarkWord -> use mark word from object header.
620 HeapRegionVerifyClosure(G1CollectedHeap* g1h, VerifyOption vo) :
621 _g1h(g1h), _bs(barrier_set_cast<CardTableModRefBS>(g1h->barrier_set())),
622 _containing_obj(NULL), _failures(false), _n_failures(0), _vo(vo)
623 { }
624
625 void set_containing_obj(oop obj) {
626 _containing_obj = obj;
627 }
628
629 bool failures() { return _failures; }
630 int n_failures() { return _n_failures; }
631
632 void print_object(outputStream* out, oop obj) {
633 #ifdef PRODUCT
634 Klass* k = obj->klass();
635 const char* class_name = k->external_name();
636 out->print_cr("class name %s", class_name);
637 #else // PRODUCT
638 obj->print_on(out);
639 #endif // PRODUCT
640 }
641
642 template <class T>
643 void verifyRemSets(T* p) {
644 T heap_oop = oopDesc::load_heap_oop(p);
645 if (!oopDesc::is_null(heap_oop)) {
646 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
647 bool failed = false;
648
649 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
650 HeapRegion* to = _g1h->heap_region_containing(obj);
651 if (from != NULL && to != NULL &&
652 from != to &&
653 !to->is_pinned()) {
654 jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
655 jbyte cv_field = *_bs->byte_for_const(p);
656 const jbyte dirty = CardTableModRefBS::dirty_card_val();
657
658 bool is_bad = !(from->is_young()
659 || to->rem_set()->contains_reference(p)
660 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
661 (_containing_obj->is_objArray() ?
662 cv_field == dirty
663 : cv_obj == dirty || cv_field == dirty));
664 if (is_bad) {
665 MutexLockerEx x(ParGCRareEvent_lock,
666 Mutex::_no_safepoint_check_flag);
667
668 if (!_failures) {
669 gclog_or_tty->cr();
674 "of obj " PTR_FORMAT ", "
675 "in region " HR_FORMAT,
676 p2i(p), p2i(_containing_obj),
677 HR_FORMAT_PARAMS(from));
678 _containing_obj->print_on(gclog_or_tty);
679 gclog_or_tty->print_cr("points to obj " PTR_FORMAT " "
680 "in region " HR_FORMAT,
681 p2i(obj),
682 HR_FORMAT_PARAMS(to));
683 obj->print_on(gclog_or_tty);
684 gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",
685 cv_obj, cv_field);
686 gclog_or_tty->print_cr("----------");
687 gclog_or_tty->flush();
688 _failures = true;
689 if (!failed) _n_failures++;
690 }
691 }
692 }
693 }
694 };
695
696 class VerifyRSetClosure : public HeapRegionVerifyClosure {
697
698 public:
699 VerifyRSetClosure(G1CollectedHeap* g1h, VerifyOption vo) : HeapRegionVerifyClosure(g1h, vo) { }
700
701 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
702 virtual void do_oop(oop* p) { do_oop_work(p); }
703
704 template <class T>
705 void do_oop_work(T* p) {
706 assert(_containing_obj != NULL, "Precondition");
707 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo),
708 "Precondition");
709
710 verifyRemSets(p);
711 }
712 };
713
714 class VerifyLiveClosure : public HeapRegionVerifyClosure {
715 public:
716 VerifyLiveClosure(G1CollectedHeap* g1h, VerifyOption vo) : HeapRegionVerifyClosure(g1h, vo) { }
717
718 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
719 virtual void do_oop( oop* p) { do_oop_work(p); }
720
721 template <class T>
722 void do_oop_work(T* p) {
723 assert(_containing_obj != NULL, "Precondition");
724 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo),
725 "Precondition");
726 T heap_oop = oopDesc::load_heap_oop(p);
727 if (!oopDesc::is_null(heap_oop)) {
728 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
729 bool failed = false;
730 if (!_g1h->is_in_closed_subset(obj) || _g1h->is_obj_dead_cond(obj, _vo)) {
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 if (!_g1h->is_in_closed_subset(obj)) {
739 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
740 gclog_or_tty->print_cr("Field " PTR_FORMAT
741 " of live obj " PTR_FORMAT " in region "
742 "[" PTR_FORMAT ", " PTR_FORMAT ")",
743 p2i(p), p2i(_containing_obj),
744 p2i(from->bottom()), p2i(from->end()));
745 print_object(gclog_or_tty, _containing_obj);
746 gclog_or_tty->print_cr("points to obj " PTR_FORMAT " not in the heap",
747 p2i(obj));
748 } else {
749 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
750 HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj);
751 gclog_or_tty->print_cr("Field " PTR_FORMAT
752 " of live obj " PTR_FORMAT " in region "
753 "[" PTR_FORMAT ", " PTR_FORMAT ")",
754 p2i(p), p2i(_containing_obj),
755 p2i(from->bottom()), p2i(from->end()));
756 print_object(gclog_or_tty, _containing_obj);
757 gclog_or_tty->print_cr("points to dead obj " PTR_FORMAT " in region "
758 "[" PTR_FORMAT ", " PTR_FORMAT ")",
759 p2i(obj), p2i(to->bottom()), p2i(to->end()));
760 print_object(gclog_or_tty, obj);
761 }
762 gclog_or_tty->print_cr("----------");
763 gclog_or_tty->flush();
764 _failures = true;
765 failed = true;
766 _n_failures++;
767 }
768
769 if (!_g1h->collector_state()->full_collection() || G1VerifyRSetsDuringFullGC) {
770 verifyRemSets(p);
771 }
772 }
773 }
774 };
775
776 // This really ought to be commoned up into OffsetTableContigSpace somehow.
777 // We would need a mechanism to make that code skip dead objects.
778
779 void HeapRegion::verify(VerifyOption vo,
780 bool* failures) const {
781 G1CollectedHeap* g1 = G1CollectedHeap::heap();
782 *failures = false;
783 HeapWord* p = bottom();
784 HeapWord* prev_p = NULL;
785 VerifyLiveClosure vl_cl(g1, vo);
786 bool is_region_humongous = is_humongous();
787 size_t object_num = 0;
788 while (p < top()) {
789 oop obj = oop(p);
790 size_t obj_size = block_size(p);
791 object_num += 1;
792
793 if (!g1->is_obj_dead_cond(obj, this, vo)) {
794 if (obj->is_oop()) {
795 Klass* klass = obj->klass();
891 // Look up end - 1
892 HeapWord* addr_4 = the_end - 1;
893 HeapWord* b_start_4 = _offsets.block_start_const(addr_4);
894 if (b_start_4 != p) {
895 gclog_or_tty->print_cr("BOT look up for end - 1: " PTR_FORMAT " "
896 " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
897 p2i(addr_4), p2i(b_start_4), p2i(p));
898 *failures = true;
899 return;
900 }
901 }
902
903 verify_strong_code_roots(vo, failures);
904 }
905
906 void HeapRegion::verify() const {
907 bool dummy = false;
908 verify(VerifyOption_G1UsePrevMarking, /* failures */ &dummy);
909 }
910
911 void HeapRegion::verifyRSet(VerifyOption vo,
912 bool* failures) const {
913 G1CollectedHeap* g1 = G1CollectedHeap::heap();
914 *failures = false;
915 HeapWord* p = bottom();
916 HeapWord* prev_p = NULL;
917 VerifyRSetClosure v_rset_cl(g1, vo);
918 bool is_region_humongous = is_humongous();
919 while (p < top()) {
920 oop obj = oop(p);
921 size_t obj_size = block_size(p);
922
923 if (!g1->is_obj_dead_cond(obj, this, vo)) {
924 if (obj->is_oop()) {
925 v_rset_cl.set_containing_obj(obj);
926 obj->oop_iterate_no_header(&v_rset_cl);
927 if (v_rset_cl.failures()) {
928 *failures = true;
929 }
930 if (G1MaxVerifyFailures >= 0 &&
931 v_rset_cl.n_failures() >= G1MaxVerifyFailures) {
932 return;
933 }
934 }
935 else {
936 gclog_or_tty->print_cr(PTR_FORMAT " not an oop", p2i(obj));
937 *failures = true;
938 return;
939 }
940 }
941 prev_p = p;
942 p += obj_size;
943 }
944 }
945
946 void HeapRegion::prepare_for_compaction(CompactPoint* cp) {
947 scan_and_forward(this, cp);
948 }
949
950 // G1OffsetTableContigSpace code; copied from space.cpp. Hope this can go
951 // away eventually.
952
953 void G1OffsetTableContigSpace::clear(bool mangle_space) {
954 set_top(bottom());
955 _scan_top = bottom();
956 CompactibleSpace::clear(mangle_space);
957 reset_bot();
958 }
959
960 void G1OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) {
961 Space::set_bottom(new_bottom);
962 _offsets.set_bottom(new_bottom);
963 }
964
965 void G1OffsetTableContigSpace::set_end(HeapWord* new_end) {
|