< prev index next >

src/hotspot/share/gc/g1/g1OopClosures.hpp

Print this page
rev 56301 : imported patch 8159984-slow


 158 enum G1Mark {
 159   G1MarkNone,
 160   G1MarkFromRoot,
 161   G1MarkPromotedFromRoot
 162 };
 163 
 164 template <G1Barrier barrier, G1Mark do_mark_object>
 165 class G1ParCopyClosure : public G1ParCopyHelper {
 166 public:
 167   G1ParCopyClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :
 168       G1ParCopyHelper(g1h, par_scan_state) { }
 169 
 170   template <class T> void do_oop_work(T* p);
 171   virtual void do_oop(oop* p)       { do_oop_work(p); }
 172   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 173 };
 174 
 175 class G1CLDScanClosure : public CLDClosure {
 176   G1ParCopyHelper* _closure;
 177   bool             _process_only_dirty;
 178   int              _claim;
 179   int              _count;
 180 public:
 181   G1CLDScanClosure(G1ParCopyHelper* closure,
 182                    bool process_only_dirty, int claim_value)
 183   : _closure(closure), _process_only_dirty(process_only_dirty), _claim(claim_value), _count(0) {}
 184   void do_cld(ClassLoaderData* cld);
 185 };
 186 
 187 // Closure for iterating over object fields during concurrent marking
 188 class G1CMOopClosure : public MetadataVisitingOopIterateClosure {
 189   G1CollectedHeap*   _g1h;
 190   G1CMTask*          _task;
 191 public:
 192   G1CMOopClosure(G1CollectedHeap* g1h,G1CMTask* task);
 193   template <class T> void do_oop_work(T* p);
 194   virtual void do_oop(      oop* p) { do_oop_work(p); }
 195   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 196 };
 197 
 198 // Closure to scan the root regions during concurrent marking
 199 class G1RootRegionScanClosure : public MetadataVisitingOopIterateClosure {
 200 private:
 201   G1CollectedHeap* _g1h;
 202   G1ConcurrentMark* _cm;
 203   uint _worker_id;




 158 enum G1Mark {
 159   G1MarkNone,
 160   G1MarkFromRoot,
 161   G1MarkPromotedFromRoot
 162 };
 163 
 164 template <G1Barrier barrier, G1Mark do_mark_object>
 165 class G1ParCopyClosure : public G1ParCopyHelper {
 166 public:
 167   G1ParCopyClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :
 168       G1ParCopyHelper(g1h, par_scan_state) { }
 169 
 170   template <class T> void do_oop_work(T* p);
 171   virtual void do_oop(oop* p)       { do_oop_work(p); }
 172   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 173 };
 174 
 175 class G1CLDScanClosure : public CLDClosure {
 176   G1ParCopyHelper* _closure;
 177   bool             _process_only_dirty;

 178   int              _count;
 179 public:
 180   G1CLDScanClosure(G1ParCopyHelper* closure, bool process_only_dirty)
 181   : _closure(closure), _process_only_dirty(process_only_dirty), _count(0) {}

 182   void do_cld(ClassLoaderData* cld);
 183 };
 184 
 185 // Closure for iterating over object fields during concurrent marking
 186 class G1CMOopClosure : public MetadataVisitingOopIterateClosure {
 187   G1CollectedHeap*   _g1h;
 188   G1CMTask*          _task;
 189 public:
 190   G1CMOopClosure(G1CollectedHeap* g1h,G1CMTask* task);
 191   template <class T> void do_oop_work(T* p);
 192   virtual void do_oop(      oop* p) { do_oop_work(p); }
 193   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 194 };
 195 
 196 // Closure to scan the root regions during concurrent marking
 197 class G1RootRegionScanClosure : public MetadataVisitingOopIterateClosure {
 198 private:
 199   G1CollectedHeap* _g1h;
 200   G1ConcurrentMark* _cm;
 201   uint _worker_id;


< prev index next >