< prev index next >

src/hotspot/share/memory/iterator.hpp

CLD claiming v2

CLD claiming

109   BasicOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) {}                                                  
110 
111   virtual bool do_metadata() { return false; }                                                                                       
112   virtual void do_klass(Klass* k) { ShouldNotReachHere(); }                                                                          
113   virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); }                                                                
114 };                                                                                                                                   
115 
116 class KlassClosure : public Closure {                                                                                                
117  public:                                                                                                                             
118   virtual void do_klass(Klass* k) = 0;                                                                                               
119 };                                                                                                                                   
120 
121 class CLDClosure : public Closure {                                                                                                  
122  public:                                                                                                                             
123   virtual void do_cld(ClassLoaderData* cld) = 0;                                                                                     
124 };                                                                                                                                   
125 
126 
127 class CLDToOopClosure : public CLDClosure {                                                                                          
128   OopClosure*       _oop_closure;                                                                                                    
129   bool              _must_claim_cld;                                                                                                 
130 
131  public:                                                                                                                             
132   CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :                                                             
                                                                                                                                     
133       _oop_closure(oop_closure),                                                                                                     
134       _must_claim_cld(must_claim_cld) {}                                                                                             
135 
136   void do_cld(ClassLoaderData* cld);                                                                                                 
137 };                                                                                                                                   
138 
139 // The base class for all concurrent marking closures,                                                                               
140 // that participates in class unloading.                                                                                             
141 // It's used to proxy through the metadata to the oops defined in them.                                                              
142 class MetadataVisitingOopIterateClosure: public OopIterateClosure {                                                                  
143  public:                                                                                                                             
144   MetadataVisitingOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) { }                                      
145 
146   virtual bool do_metadata() { return true; }                                                                                        
147   virtual void do_klass(Klass* k);                                                                                                   
148   virtual void do_cld(ClassLoaderData* cld);                                                                                         
149 };                                                                                                                                   
150 
151 // ObjectClosure is used for iterating through an object space                                                                       
152 
153 class ObjectClosure : public Closure {                                                                                               

109   BasicOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) {}
110 
111   virtual bool do_metadata() { return false; }
112   virtual void do_klass(Klass* k) { ShouldNotReachHere(); }
113   virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); }
114 };
115 
116 class KlassClosure : public Closure {
117  public:
118   virtual void do_klass(Klass* k) = 0;
119 };
120 
121 class CLDClosure : public Closure {
122  public:
123   virtual void do_cld(ClassLoaderData* cld) = 0;
124 };
125 
126 
127 class CLDToOopClosure : public CLDClosure {
128   OopClosure*       _oop_closure;
129   int               _cld_claim;
130 
131  public:
132   CLDToOopClosure(OopClosure* oop_closure,
133                   int cld_claim) :
134       _oop_closure(oop_closure),
135       _cld_claim(cld_claim) {}
136 
137   void do_cld(ClassLoaderData* cld);
138 };
139 
140 // The base class for all concurrent marking closures,
141 // that participates in class unloading.
142 // It's used to proxy through the metadata to the oops defined in them.
143 class MetadataVisitingOopIterateClosure: public OopIterateClosure {
144  public:
145   MetadataVisitingOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) { }
146 
147   virtual bool do_metadata() { return true; }
148   virtual void do_klass(Klass* k);
149   virtual void do_cld(ClassLoaderData* cld);
150 };
151 
152 // ObjectClosure is used for iterating through an object space
153 
154 class ObjectClosure : public Closure {
< prev index next >