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

rev 9081 : imported patch rootclosureset
rev 9083 : imported patch erik-review
rev 9084 : [mq]: stefank-comments
rev 9085 : imported patch stefank-patch2
rev 9086 : imported patch trace-metadata
rev 9087 : imported patch parpush

*** 52,67 ****
      _buffered_oops(&_oops) {}
  };
  
  class G1EvacuationClosures : public G1EvacuationRootClosures {
    G1SharedClosures<G1MarkNone> _closures;
  
  public:
    G1EvacuationClosures(G1CollectedHeap* g1h,
                         G1ParScanThreadState* pss,
                         bool gcs_are_young) :
!       _closures(g1h, pss, gcs_are_young, /* must_claim_cld */ false) {}
  
    OopClosure* weak_oops()   { return &_closures._buffered_oops; }
    OopClosure* strong_oops() { return &_closures._buffered_oops; }
  
    CLDClosure* weak_clds()             { return &_closures._clds; }
--- 52,69 ----
      _buffered_oops(&_oops) {}
  };
  
  class G1EvacuationClosures : public G1EvacuationRootClosures {
    G1SharedClosures<G1MarkNone> _closures;
+   G1ParPushHeapRSClosure       _inter_region_oops;
  
  public:
    G1EvacuationClosures(G1CollectedHeap* g1h,
                         G1ParScanThreadState* pss,
                         bool gcs_are_young) :
!       _closures(g1h, pss, gcs_are_young, /* must_claim_cld */ false),
!       _inter_region_oops(g1h, pss) {}
  
    OopClosure* weak_oops()   { return &_closures._buffered_oops; }
    OopClosure* strong_oops() { return &_closures._buffered_oops; }
  
    CLDClosure* weak_clds()             { return &_closures._clds; }
*** 76,94 ****
--- 78,99 ----
    double closure_app_seconds() { return _closures._buffered_oops.closure_app_seconds(); }
  
    OopClosure* raw_strong_oops() { return &_closures._oops; }
  
    bool trace_metadata()         { return false; }
+ 
+   G1ParPushHeapRSClosure* inter_region_oops() { return &_inter_region_oops; }
  };
  
  // Closures used during initial mark.
  // The treatment of "weak" roots is selectable through the template parameter,
  // this is usually used to control unloading of classes and interned strings.
  template <G1Mark MarkWeak>
  class G1InitalMarkClosures : public G1EvacuationRootClosures {
    G1SharedClosures<G1MarkFromRoot> _strong;
    G1SharedClosures<MarkWeak>       _weak;
+   G1ParPushHeapRSClosure           _inter_region_oops;
  
    // Filter method to help with returning the appropriate closures
    // depending on the class template parameter.
    template <G1Mark Mark, typename T>
    T* null_if(T* t) {
*** 100,110 ****
  
  public:
    G1InitalMarkClosures(G1CollectedHeap* g1h,
                         G1ParScanThreadState* pss) :
        _strong(g1h, pss, /* process_only_dirty_klasses */ false, /* must_claim_cld */ true),
!       _weak(g1h, pss,   /* process_only_dirty_klasses */ false, /* must_claim_cld */ true) {}
  
    OopClosure* weak_oops()   { return &_weak._buffered_oops; }
    OopClosure* strong_oops() { return &_strong._buffered_oops; }
  
    // If MarkWeak is G1MarkPromotedFromRoot then the weak CLDs must be processed in a second pass.
--- 105,116 ----
  
  public:
    G1InitalMarkClosures(G1CollectedHeap* g1h,
                         G1ParScanThreadState* pss) :
        _strong(g1h, pss, /* process_only_dirty_klasses */ false, /* must_claim_cld */ true),
!       _weak(g1h, pss,   /* process_only_dirty_klasses */ false, /* must_claim_cld */ true),
!       _inter_region_oops(g1h, pss) {}
  
    OopClosure* weak_oops()   { return &_weak._buffered_oops; }
    OopClosure* strong_oops() { return &_strong._buffered_oops; }
  
    // If MarkWeak is G1MarkPromotedFromRoot then the weak CLDs must be processed in a second pass.
*** 132,141 ****
--- 138,149 ----
    OopClosure* raw_strong_oops() { return &_strong._oops; }
  
    // If we are not marking all weak roots then we are tracing
    // which metadata is alive.
    bool trace_metadata()         { return MarkWeak == G1MarkPromotedFromRoot; }
+ 
+   G1ParPushHeapRSClosure* inter_region_oops() { return &_inter_region_oops; }
  };
  
  G1EvacuationRootClosures* G1EvacuationRootClosures::create_root_closures(G1ParScanThreadState* pss, G1CollectedHeap* g1h) {
    if (g1h->collector_state()->during_initial_mark_pause()) {
      if (ClassUnloadingWithConcurrentMark) {