< prev index next >

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

CLD claiming v2

139 enum G1Mark {                                                                                                                        
140   G1MarkNone,                                                                                                                        
141   G1MarkFromRoot,                                                                                                                    
142   G1MarkPromotedFromRoot                                                                                                             
143 };                                                                                                                                   
144 
145 template <G1Barrier barrier, G1Mark do_mark_object>                                                                                  
146 class G1ParCopyClosure : public G1ParCopyHelper {                                                                                    
147 public:                                                                                                                              
148   G1ParCopyClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :                                                     
149       G1ParCopyHelper(g1h, par_scan_state) { }                                                                                       
150 
151   template <class T> void do_oop_work(T* p);                                                                                         
152   virtual void do_oop(oop* p)       { do_oop_work(p); }                                                                              
153   virtual void do_oop(narrowOop* p) { do_oop_work(p); }                                                                              
154 };                                                                                                                                   
155 
156 class G1CLDScanClosure : public CLDClosure {                                                                                         
157   G1ParCopyHelper* _closure;                                                                                                         
158   bool             _process_only_dirty;                                                                                              
159   int              _claim_value;                                                                                                     
160   int              _count;                                                                                                           
161 public:                                                                                                                              
162   G1CLDScanClosure(G1ParCopyHelper* closure,                                                                                         
163                    bool process_only_dirty, int claim_value)                                                                         
164   : _closure(closure), _process_only_dirty(process_only_dirty), _claim_value(claim_value), _count(0) {}                              
165   void do_cld(ClassLoaderData* cld);                                                                                                 
166 };                                                                                                                                   
167 
168 // Closure for iterating over object fields during concurrent marking                                                                
169 class G1CMOopClosure : public MetadataVisitingOopIterateClosure {                                                                    
170   G1CollectedHeap*   _g1h;                                                                                                           
171   G1CMTask*          _task;                                                                                                          
172 public:                                                                                                                              
173   G1CMOopClosure(G1CollectedHeap* g1h,G1CMTask* task);                                                                               
174   template <class T> void do_oop_work(T* p);                                                                                         
175   virtual void do_oop(      oop* p) { do_oop_work(p); }                                                                              
176   virtual void do_oop(narrowOop* p) { do_oop_work(p); }                                                                              
177 };                                                                                                                                   
178 
179 // Closure to scan the root regions during concurrent marking                                                                        
180 class G1RootRegionScanClosure : public MetadataVisitingOopIterateClosure {                                                           
181 private:                                                                                                                             
182   G1CollectedHeap* _g1h;                                                                                                             
183   G1ConcurrentMark* _cm;                                                                                                             

139 enum G1Mark {
140   G1MarkNone,
141   G1MarkFromRoot,
142   G1MarkPromotedFromRoot
143 };
144 
145 template <G1Barrier barrier, G1Mark do_mark_object>
146 class G1ParCopyClosure : public G1ParCopyHelper {
147 public:
148   G1ParCopyClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :
149       G1ParCopyHelper(g1h, par_scan_state) { }
150 
151   template <class T> void do_oop_work(T* p);
152   virtual void do_oop(oop* p)       { do_oop_work(p); }
153   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
154 };
155 
156 class G1CLDScanClosure : public CLDClosure {
157   G1ParCopyHelper* _closure;
158   bool             _process_only_dirty;
159   int              _claim;
160   int              _count;
161 public:
162   G1CLDScanClosure(G1ParCopyHelper* closure,
163                    bool process_only_dirty, int claim_value)
164   : _closure(closure), _process_only_dirty(process_only_dirty), _claim(claim_value), _count(0) {}
165   void do_cld(ClassLoaderData* cld);
166 };
167 
168 // Closure for iterating over object fields during concurrent marking
169 class G1CMOopClosure : public MetadataVisitingOopIterateClosure {
170   G1CollectedHeap*   _g1h;
171   G1CMTask*          _task;
172 public:
173   G1CMOopClosure(G1CollectedHeap* g1h,G1CMTask* task);
174   template <class T> void do_oop_work(T* p);
175   virtual void do_oop(      oop* p) { do_oop_work(p); }
176   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
177 };
178 
179 // Closure to scan the root regions during concurrent marking
180 class G1RootRegionScanClosure : public MetadataVisitingOopIterateClosure {
181 private:
182   G1CollectedHeap* _g1h;
183   G1ConcurrentMark* _cm;
< prev index next >