< prev index next >

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

CLD claiming

152 };                                                                                                                                   
153 
154 class YoungRefCounterClosure : public OopClosure {                                                                                   
155   G1CollectedHeap* _g1h;                                                                                                             
156   int              _count;                                                                                                           
157  public:                                                                                                                             
158   YoungRefCounterClosure(G1CollectedHeap* g1h) : _g1h(g1h), _count(0) {}                                                             
159   void do_oop(oop* p)       { if (_g1h->is_in_young(*p)) { _count++; } }                                                             
160   void do_oop(narrowOop* p) { ShouldNotReachHere(); }                                                                                
161 
162   int count() { return _count; }                                                                                                     
163   void reset_count() { _count = 0; };                                                                                                
164 };                                                                                                                                   
165 
166 class VerifyCLDClosure: public CLDClosure {                                                                                          
167   YoungRefCounterClosure _young_ref_counter_closure;                                                                                 
168   OopClosure *_oop_closure;                                                                                                          
169  public:                                                                                                                             
170   VerifyCLDClosure(G1CollectedHeap* g1h, OopClosure* cl) : _young_ref_counter_closure(g1h), _oop_closure(cl) {}                      
171   void do_cld(ClassLoaderData* cld) {                                                                                                
172     cld->oops_do(_oop_closure, false);                                                                                               
173 
174     _young_ref_counter_closure.reset_count();                                                                                        
175     cld->oops_do(&_young_ref_counter_closure, false);                                                                                
176     if (_young_ref_counter_closure.count() > 0) {                                                                                    
177       guarantee(cld->has_modified_oops(), "CLD " PTR_FORMAT ", has young %d refs but is not dirty.", p2i(cld), _young_ref_counter_clo
178     }                                                                                                                                
179   }                                                                                                                                  
180 };                                                                                                                                   
181 
182 class VerifyLivenessOopClosure: public BasicOopIterateClosure {                                                                      
183   G1CollectedHeap* _g1h;                                                                                                             
184   VerifyOption _vo;                                                                                                                  
185 public:                                                                                                                              
186   VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo):                                                                   
187     _g1h(g1h), _vo(vo)                                                                                                               
188   { }                                                                                                                                
189   void do_oop(narrowOop *p) { do_oop_work(p); }                                                                                      
190   void do_oop(      oop *p) { do_oop_work(p); }                                                                                      
191 
192   template <class T> void do_oop_work(T *p) {                                                                                        
193     oop obj = RawAccess<>::oop_load(p);                                                                                              
194     guarantee(obj == NULL || !_g1h->is_obj_dead_cond(obj, _vo),                                                                      

152 };
153 
154 class YoungRefCounterClosure : public OopClosure {
155   G1CollectedHeap* _g1h;
156   int              _count;
157  public:
158   YoungRefCounterClosure(G1CollectedHeap* g1h) : _g1h(g1h), _count(0) {}
159   void do_oop(oop* p)       { if (_g1h->is_in_young(*p)) { _count++; } }
160   void do_oop(narrowOop* p) { ShouldNotReachHere(); }
161 
162   int count() { return _count; }
163   void reset_count() { _count = 0; };
164 };
165 
166 class VerifyCLDClosure: public CLDClosure {
167   YoungRefCounterClosure _young_ref_counter_closure;
168   OopClosure *_oop_closure;
169  public:
170   VerifyCLDClosure(G1CollectedHeap* g1h, OopClosure* cl) : _young_ref_counter_closure(g1h), _oop_closure(cl) {}
171   void do_cld(ClassLoaderData* cld) {
172     cld->oops_do(_oop_closure, ClassLoaderData::_claim_value_none);
173 
174     _young_ref_counter_closure.reset_count();
175     cld->oops_do(&_young_ref_counter_closure, ClassLoaderData::_claim_value_none);
176     if (_young_ref_counter_closure.count() > 0) {
177       guarantee(cld->has_modified_oops(), "CLD " PTR_FORMAT ", has young %d refs but is not dirty.", p2i(cld), _young_ref_counter_clo
178     }
179   }
180 };
181 
182 class VerifyLivenessOopClosure: public BasicOopIterateClosure {
183   G1CollectedHeap* _g1h;
184   VerifyOption _vo;
185 public:
186   VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo):
187     _g1h(g1h), _vo(vo)
188   { }
189   void do_oop(narrowOop *p) { do_oop_work(p); }
190   void do_oop(      oop *p) { do_oop_work(p); }
191 
192   template <class T> void do_oop_work(T *p) {
193     oop obj = RawAccess<>::oop_load(p);
194     guarantee(obj == NULL || !_g1h->is_obj_dead_cond(obj, _vo),
< prev index next >