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

rev 12906 : [mq]: gc_interface

*** 533,546 ****
  
  
  #ifndef PRODUCT
  class G1VerifyCardTableCleanup: public HeapRegionClosure {
    G1HeapVerifier* _verifier;
!   G1SATBCardTableModRefBS* _ct_bs;
  public:
!   G1VerifyCardTableCleanup(G1HeapVerifier* verifier, G1SATBCardTableModRefBS* ct_bs)
!     : _verifier(verifier), _ct_bs(ct_bs) { }
    virtual bool doHeapRegion(HeapRegion* r) {
      if (r->is_survivor()) {
        _verifier->verify_dirty_region(r);
      } else {
        _verifier->verify_not_dirty_region(r);
--- 533,546 ----
  
  
  #ifndef PRODUCT
  class G1VerifyCardTableCleanup: public HeapRegionClosure {
    G1HeapVerifier* _verifier;
!   G1CardTable* _ct;
  public:
!   G1VerifyCardTableCleanup(G1HeapVerifier* verifier, G1CardTable* ct)
!     : _verifier(verifier), _ct(ct) { }
    virtual bool doHeapRegion(HeapRegion* r) {
      if (r->is_survivor()) {
        _verifier->verify_dirty_region(r);
      } else {
        _verifier->verify_not_dirty_region(r);
*** 549,584 ****
    }
  };
  
  void G1HeapVerifier::verify_card_table_cleanup() {
    if (G1VerifyCTCleanup || VerifyAfterGC) {
!     G1VerifyCardTableCleanup cleanup_verifier(this, _g1h->g1_barrier_set());
      _g1h->heap_region_iterate(&cleanup_verifier);
    }
  }
  
  void G1HeapVerifier::verify_not_dirty_region(HeapRegion* hr) {
    // All of the region should be clean.
!   G1SATBCardTableModRefBS* ct_bs = _g1h->g1_barrier_set();
    MemRegion mr(hr->bottom(), hr->end());
!   ct_bs->verify_not_dirty_region(mr);
  }
  
  void G1HeapVerifier::verify_dirty_region(HeapRegion* hr) {
    // We cannot guarantee that [bottom(),end()] is dirty.  Threads
    // dirty allocated blocks as they allocate them. The thread that
    // retires each region and replaces it with a new one will do a
    // maximal allocation to fill in [pre_dummy_top(),end()] but will
    // not dirty that area (one less thing to have to do while holding
    // a lock). So we can only verify that [bottom(),pre_dummy_top()]
    // is dirty.
!   G1SATBCardTableModRefBS* ct_bs = _g1h->g1_barrier_set();
    MemRegion mr(hr->bottom(), hr->pre_dummy_top());
    if (hr->is_young()) {
!     ct_bs->verify_g1_young_region(mr);
    } else {
!     ct_bs->verify_dirty_region(mr);
    }
  }
  
  class G1VerifyDirtyYoungListClosure : public HeapRegionClosure {
  private:
--- 549,584 ----
    }
  };
  
  void G1HeapVerifier::verify_card_table_cleanup() {
    if (G1VerifyCTCleanup || VerifyAfterGC) {
!     G1VerifyCardTableCleanup cleanup_verifier(this, _g1h->g1_card_table());
      _g1h->heap_region_iterate(&cleanup_verifier);
    }
  }
  
  void G1HeapVerifier::verify_not_dirty_region(HeapRegion* hr) {
    // All of the region should be clean.
!   G1CardTable* ct = _g1h->g1_card_table();
    MemRegion mr(hr->bottom(), hr->end());
!   ct->verify_not_dirty_region(mr);
  }
  
  void G1HeapVerifier::verify_dirty_region(HeapRegion* hr) {
    // We cannot guarantee that [bottom(),end()] is dirty.  Threads
    // dirty allocated blocks as they allocate them. The thread that
    // retires each region and replaces it with a new one will do a
    // maximal allocation to fill in [pre_dummy_top(),end()] but will
    // not dirty that area (one less thing to have to do while holding
    // a lock). So we can only verify that [bottom(),pre_dummy_top()]
    // is dirty.
!   G1CardTable* ct = _g1h->g1_card_table();
    MemRegion mr(hr->bottom(), hr->pre_dummy_top());
    if (hr->is_young()) {
!     ct->verify_g1_young_region(mr);
    } else {
!     ct->verify_dirty_region(mr);
    }
  }
  
  class G1VerifyDirtyYoungListClosure : public HeapRegionClosure {
  private: