543 guarantee(max != NULL, "Since _n_fine_entries > 0");
544 guarantee(max_prev != NULL, "Since max != NULL.");
545
546 // Set the corresponding coarse bit.
547 size_t max_hrm_index = (size_t) max->hr()->hrm_index();
548 if (!_coarse_map.at(max_hrm_index)) {
549 _coarse_map.at_put(max_hrm_index, true);
550 _n_coarse_entries++;
551 }
552
553 // Unsplice.
554 *max_prev = max->collision_list_next();
555 Atomic::inc(&_n_coarsenings);
556 _n_fine_entries--;
557 return max;
558 }
559
560 void OtherRegionsTable::scrub(CardTableModRefBS* ctbs,
561 BitMap* region_bm, BitMap* card_bm) {
562 // First eliminated garbage regions from the coarse map.
563 if (G1RSScrubVerbose) {
564 gclog_or_tty->print_cr("Scrubbing region %u:", _hr->hrm_index());
565 }
566
567 assert(_coarse_map.size() == region_bm->size(), "Precondition");
568 if (G1RSScrubVerbose) {
569 gclog_or_tty->print(" Coarse map: before = " SIZE_FORMAT "...",
570 _n_coarse_entries);
571 }
572 _coarse_map.set_intersection(*region_bm);
573 _n_coarse_entries = _coarse_map.count_one_bits();
574 if (G1RSScrubVerbose) {
575 gclog_or_tty->print_cr(" after = " SIZE_FORMAT ".", _n_coarse_entries);
576 }
577
578 // Now do the fine-grained maps.
579 for (size_t i = 0; i < _max_fine_entries; i++) {
580 PerRegionTable* cur = _fine_grain_regions[i];
581 PerRegionTable** prev = &_fine_grain_regions[i];
582 while (cur != NULL) {
583 PerRegionTable* nxt = cur->collision_list_next();
584 // If the entire region is dead, eliminate.
585 if (G1RSScrubVerbose) {
586 gclog_or_tty->print_cr(" For other region %u:",
587 cur->hr()->hrm_index());
588 }
589 if (!region_bm->at((size_t) cur->hr()->hrm_index())) {
590 *prev = nxt;
591 cur->set_collision_list_next(NULL);
592 _n_fine_entries--;
593 if (G1RSScrubVerbose) {
594 gclog_or_tty->print_cr(" deleted via region map.");
595 }
596 unlink_from_all(cur);
597 PerRegionTable::free(cur);
598 } else {
599 // Do fine-grain elimination.
600 if (G1RSScrubVerbose) {
601 gclog_or_tty->print(" occ: before = %4d.", cur->occupied());
602 }
603 cur->scrub(ctbs, card_bm);
604 if (G1RSScrubVerbose) {
605 gclog_or_tty->print_cr(" after = %4d.", cur->occupied());
606 }
607 // Did that empty the table completely?
608 if (cur->occupied() == 0) {
609 *prev = nxt;
610 cur->set_collision_list_next(NULL);
611 _n_fine_entries--;
612 unlink_from_all(cur);
613 PerRegionTable::free(cur);
614 } else {
615 prev = cur->collision_list_next_addr();
616 }
617 }
618 cur = nxt;
619 }
620 }
621 // Since we may have deleted a from_card_cache entry from the RS, clear
622 // the FCC.
623 clear_fcc();
624 }
625
626 bool OtherRegionsTable::occupancy_less_or_equal_than(size_t limit) const {
782 if (_iter_state != Unclaimed) return false;
783 jint res = Atomic::cmpxchg(Claimed, (jint*)(&_iter_state), Unclaimed);
784 return (res == Unclaimed);
785 }
786
787 void HeapRegionRemSet::set_iter_complete() {
788 _iter_state = Complete;
789 }
790
791 bool HeapRegionRemSet::iter_is_complete() {
792 return _iter_state == Complete;
793 }
794
795 #ifndef PRODUCT
796 void HeapRegionRemSet::print() {
797 HeapRegionRemSetIterator iter(this);
798 size_t card_index;
799 while (iter.has_next(card_index)) {
800 HeapWord* card_start =
801 G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
802 gclog_or_tty->print_cr(" Card " PTR_FORMAT, p2i(card_start));
803 }
804 if (iter.n_yielded() != occupied()) {
805 gclog_or_tty->print_cr("Yielded disagrees with occupied:");
806 gclog_or_tty->print_cr(" " SIZE_FORMAT_W(6) " yielded (" SIZE_FORMAT_W(6)
807 " coarse, " SIZE_FORMAT_W(6) " fine).",
808 iter.n_yielded(),
809 iter.n_yielded_coarse(), iter.n_yielded_fine());
810 gclog_or_tty->print_cr(" " SIZE_FORMAT_W(6) " occ (" SIZE_FORMAT_W(6)
811 " coarse, " SIZE_FORMAT_W(6) " fine).",
812 occupied(), occ_coarse(), occ_fine());
813 }
814 guarantee(iter.n_yielded() == occupied(),
815 "We should have yielded all the represented cards.");
816 }
817 #endif
818
819 void HeapRegionRemSet::cleanup() {
820 SparsePRT::cleanup_all();
821 }
822
823 void HeapRegionRemSet::clear() {
824 MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag);
825 clear_locked();
826 }
827
828 void HeapRegionRemSet::clear_locked() {
829 _code_roots.clear();
830 _other_regions.clear();
1072
1073 hrrs->add_reference((OopOrNarrowOopStar)hr2_start);
1074 hrrs->add_reference((OopOrNarrowOopStar)hr2_mid);
1075 hrrs->add_reference((OopOrNarrowOopStar)hr2_last);
1076
1077 hrrs->add_reference((OopOrNarrowOopStar)hr3_start);
1078 hrrs->add_reference((OopOrNarrowOopStar)hr3_mid);
1079 hrrs->add_reference((OopOrNarrowOopStar)hr3_last);
1080
1081 // Now cause a coarsening.
1082 hrrs->add_reference((OopOrNarrowOopStar)hr4->bottom());
1083 hrrs->add_reference((OopOrNarrowOopStar)hr5->bottom());
1084
1085 // Now, does iteration yield these three?
1086 HeapRegionRemSetIterator iter(hrrs);
1087 size_t sum = 0;
1088 size_t card_index;
1089 while (iter.has_next(card_index)) {
1090 HeapWord* card_start =
1091 G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
1092 gclog_or_tty->print_cr(" Card " PTR_FORMAT ".", p2i(card_start));
1093 sum++;
1094 }
1095 guarantee(sum == 11 - 3 + 2048, "Failure");
1096 guarantee(sum == hrrs->occupied(), "Failure");
1097 }
1098 #endif
|
543 guarantee(max != NULL, "Since _n_fine_entries > 0");
544 guarantee(max_prev != NULL, "Since max != NULL.");
545
546 // Set the corresponding coarse bit.
547 size_t max_hrm_index = (size_t) max->hr()->hrm_index();
548 if (!_coarse_map.at(max_hrm_index)) {
549 _coarse_map.at_put(max_hrm_index, true);
550 _n_coarse_entries++;
551 }
552
553 // Unsplice.
554 *max_prev = max->collision_list_next();
555 Atomic::inc(&_n_coarsenings);
556 _n_fine_entries--;
557 return max;
558 }
559
560 void OtherRegionsTable::scrub(CardTableModRefBS* ctbs,
561 BitMap* region_bm, BitMap* card_bm) {
562 // First eliminated garbage regions from the coarse map.
563 log_develop(gc, remset, scrub)("Scrubbing region %u:", _hr->hrm_index());
564
565 assert(_coarse_map.size() == region_bm->size(), "Precondition");
566 log_develop(gc, remset, scrub)(" Coarse map: before = " SIZE_FORMAT "...", _n_coarse_entries);
567 _coarse_map.set_intersection(*region_bm);
568 _n_coarse_entries = _coarse_map.count_one_bits();
569 log_develop(gc, remset, scrub)(" after = " SIZE_FORMAT ".", _n_coarse_entries);
570
571 // Now do the fine-grained maps.
572 for (size_t i = 0; i < _max_fine_entries; i++) {
573 PerRegionTable* cur = _fine_grain_regions[i];
574 PerRegionTable** prev = &_fine_grain_regions[i];
575 while (cur != NULL) {
576 PerRegionTable* nxt = cur->collision_list_next();
577 // If the entire region is dead, eliminate.
578 log_develop(gc, remset, scrub)(" For other region %u:", cur->hr()->hrm_index());
579 if (!region_bm->at((size_t) cur->hr()->hrm_index())) {
580 *prev = nxt;
581 cur->set_collision_list_next(NULL);
582 _n_fine_entries--;
583 log_develop(gc, remset, scrub)(" deleted via region map.");
584 unlink_from_all(cur);
585 PerRegionTable::free(cur);
586 } else {
587 // Do fine-grain elimination.
588 log_develop(gc, remset, scrub)(" occ: before = %4d.", cur->occupied());
589 cur->scrub(ctbs, card_bm);
590 log_develop(gc, remset, scrub)(" after = %4d.", cur->occupied());
591 // Did that empty the table completely?
592 if (cur->occupied() == 0) {
593 *prev = nxt;
594 cur->set_collision_list_next(NULL);
595 _n_fine_entries--;
596 unlink_from_all(cur);
597 PerRegionTable::free(cur);
598 } else {
599 prev = cur->collision_list_next_addr();
600 }
601 }
602 cur = nxt;
603 }
604 }
605 // Since we may have deleted a from_card_cache entry from the RS, clear
606 // the FCC.
607 clear_fcc();
608 }
609
610 bool OtherRegionsTable::occupancy_less_or_equal_than(size_t limit) const {
766 if (_iter_state != Unclaimed) return false;
767 jint res = Atomic::cmpxchg(Claimed, (jint*)(&_iter_state), Unclaimed);
768 return (res == Unclaimed);
769 }
770
771 void HeapRegionRemSet::set_iter_complete() {
772 _iter_state = Complete;
773 }
774
775 bool HeapRegionRemSet::iter_is_complete() {
776 return _iter_state == Complete;
777 }
778
779 #ifndef PRODUCT
780 void HeapRegionRemSet::print() {
781 HeapRegionRemSetIterator iter(this);
782 size_t card_index;
783 while (iter.has_next(card_index)) {
784 HeapWord* card_start =
785 G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
786 tty->print_cr(" Card " PTR_FORMAT, p2i(card_start));
787 }
788 if (iter.n_yielded() != occupied()) {
789 tty->print_cr("Yielded disagrees with occupied:");
790 tty->print_cr(" " SIZE_FORMAT_W(6) " yielded (" SIZE_FORMAT_W(6)
791 " coarse, " SIZE_FORMAT_W(6) " fine).",
792 iter.n_yielded(),
793 iter.n_yielded_coarse(), iter.n_yielded_fine());
794 tty->print_cr(" " SIZE_FORMAT_W(6) " occ (" SIZE_FORMAT_W(6)
795 " coarse, " SIZE_FORMAT_W(6) " fine).",
796 occupied(), occ_coarse(), occ_fine());
797 }
798 guarantee(iter.n_yielded() == occupied(),
799 "We should have yielded all the represented cards.");
800 }
801 #endif
802
803 void HeapRegionRemSet::cleanup() {
804 SparsePRT::cleanup_all();
805 }
806
807 void HeapRegionRemSet::clear() {
808 MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag);
809 clear_locked();
810 }
811
812 void HeapRegionRemSet::clear_locked() {
813 _code_roots.clear();
814 _other_regions.clear();
1056
1057 hrrs->add_reference((OopOrNarrowOopStar)hr2_start);
1058 hrrs->add_reference((OopOrNarrowOopStar)hr2_mid);
1059 hrrs->add_reference((OopOrNarrowOopStar)hr2_last);
1060
1061 hrrs->add_reference((OopOrNarrowOopStar)hr3_start);
1062 hrrs->add_reference((OopOrNarrowOopStar)hr3_mid);
1063 hrrs->add_reference((OopOrNarrowOopStar)hr3_last);
1064
1065 // Now cause a coarsening.
1066 hrrs->add_reference((OopOrNarrowOopStar)hr4->bottom());
1067 hrrs->add_reference((OopOrNarrowOopStar)hr5->bottom());
1068
1069 // Now, does iteration yield these three?
1070 HeapRegionRemSetIterator iter(hrrs);
1071 size_t sum = 0;
1072 size_t card_index;
1073 while (iter.has_next(card_index)) {
1074 HeapWord* card_start =
1075 G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
1076 tty->print_cr(" Card " PTR_FORMAT ".", p2i(card_start));
1077 sum++;
1078 }
1079 guarantee(sum == 11 - 3 + 2048, "Failure");
1080 guarantee(sum == hrrs->occupied(), "Failure");
1081 }
1082 #endif
|