src/hotspot/share/gc/parallel/psScavenge.inline.hpp

*** 83,101 ****
  };
  
  typedef PSRootsClosure</*promote_immediately=*/false> PSScavengeRootsClosure;
  typedef PSRootsClosure</*promote_immediately=*/true> PSPromoteRootsClosure;
  
! // Scavenges a single oop in a Klass.
! class PSScavengeFromKlassClosure: public OopClosure {
   private:
    PSPromotionManager* _pm;
!   // Used to redirty a scanned klass if it has oops
    // pointing to the young generation after being scanned.
!   Klass*             _scanned_klass;
   public:
!   PSScavengeFromKlassClosure(PSPromotionManager* pm) : _pm(pm), _scanned_klass(NULL) { }
    void do_oop(narrowOop* p) { ShouldNotReachHere(); }
    void do_oop(oop* p)       {
      ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
      assert(!psh->is_in_reserved(p), "GC barrier needed");
      if (PSScavenge::should_scavenge(p)) {
--- 83,101 ----
  };
  
  typedef PSRootsClosure</*promote_immediately=*/false> PSScavengeRootsClosure;
  typedef PSRootsClosure</*promote_immediately=*/true> PSPromoteRootsClosure;
  
! // Scavenges a single oop in a ClassLoaderData.
! class PSScavengeFromCLDClosure: public OopClosure {
   private:
    PSPromotionManager* _pm;
!   // Used to redirty a scanned cld if it has oops
    // pointing to the young generation after being scanned.
!   ClassLoaderData*             _scanned_cld;
   public:
!   PSScavengeFromCLDClosure(PSPromotionManager* pm) : _pm(pm), _scanned_cld(NULL) { }
    void do_oop(narrowOop* p) { ShouldNotReachHere(); }
    void do_oop(oop* p)       {
      ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
      assert(!psh->is_in_reserved(p), "GC barrier needed");
      if (PSScavenge::should_scavenge(p)) {
*** 109,158 ****
          new_obj = _pm->copy_to_survivor_space</*promote_immediately=*/false>(o);
        }
        oopDesc::encode_store_heap_oop_not_null(p, new_obj);
  
        if (PSScavenge::is_obj_in_young(new_obj)) {
!         do_klass_barrier();
        }
      }
    }
  
!   void set_scanned_klass(Klass* klass) {
!     assert(_scanned_klass == NULL || klass == NULL, "Should always only handling one klass at a time");
!     _scanned_klass = klass;
    }
  
   private:
!   void do_klass_barrier() {
!     assert(_scanned_klass != NULL, "Should not be called without having a scanned klass");
!     _scanned_klass->record_modified_oops();
    }
- 
  };
  
! // Scavenges the oop in a Klass.
! class PSScavengeKlassClosure: public KlassClosure {
   private:
!   PSScavengeFromKlassClosure _oop_closure;
   protected:
   public:
!   PSScavengeKlassClosure(PSPromotionManager* pm) : _oop_closure(pm) { }
!   void do_klass(Klass* klass) {
!     // If the klass has not been dirtied we know that there's
      // no references into  the young gen and we can skip it.
  
!     if (klass->has_modified_oops()) {
!       // Clean the klass since we're going to scavenge all the metadata.
!       klass->clear_modified_oops();
! 
!       // Setup the promotion manager to redirty this klass
        // if references are left in the young gen.
!       _oop_closure.set_scanned_klass(klass);
  
!       klass->oops_do(&_oop_closure);
  
!       _oop_closure.set_scanned_klass(NULL);
      }
    }
  };
  
  #endif // SHARE_VM_GC_PARALLEL_PSSCAVENGE_INLINE_HPP
--- 109,156 ----
          new_obj = _pm->copy_to_survivor_space</*promote_immediately=*/false>(o);
        }
        oopDesc::encode_store_heap_oop_not_null(p, new_obj);
  
        if (PSScavenge::is_obj_in_young(new_obj)) {
!         do_cld_barrier();
        }
      }
    }
  
!   void set_scanned_cld(ClassLoaderData* cld) {
!     assert(_scanned_cld == NULL || cld == NULL, "Should always only handling one cld at a time");
!     _scanned_cld = cld;
    }
  
   private:
!   void do_cld_barrier() {
!     assert(_scanned_cld != NULL, "Should not be called without having a scanned cld");
!     _scanned_cld->record_modified_oops();
    }
  };
  
! // Scavenges the oop in a ClassLoaderData.
! class PSScavengeCLDClosure: public CLDClosure {
   private:
!   PSScavengeFromCLDClosure _oop_closure;
   protected:
   public:
!   PSScavengeCLDClosure(PSPromotionManager* pm) : _oop_closure(pm) { }
!   void do_cld(ClassLoaderData* cld) {
!     // If the cld has not been dirtied we know that there's
      // no references into  the young gen and we can skip it.
  
!     if (cld->has_modified_oops()) {
!       // Setup the promotion manager to redirty this cld
        // if references are left in the young gen.
!       _oop_closure.set_scanned_cld(cld);
  
!       // Clean the cld since we're going to scavenge all the metadata.
!       cld->oops_do(&_oop_closure, false, /*clear_modified_oops*/true);
  
!       _oop_closure.set_scanned_cld(NULL);
      }
    }
  };
  
+ 
  #endif // SHARE_VM_GC_PARALLEL_PSSCAVENGE_INLINE_HPP