< prev index next >

src/share/vm/gc/g1/heapRegionRemSet.cpp

Print this page




 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
< prev index next >