< prev index next >

src/hotspot/share/oops/instanceKlass.cpp

Concurrent class unloading

2120 
2121 void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {                                                 
2122   dependencies().remove_dependent_nmethod(nm, delete_immediately);                                                                   
2123 }                                                                                                                                    
2124 
2125 #ifndef PRODUCT                                                                                                                      
2126 void InstanceKlass::print_dependent_nmethods(bool verbose) {                                                                         
2127   dependencies().print_dependent_nmethods(verbose);                                                                                  
2128 }                                                                                                                                    
2129 
2130 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {                                                                              
2131   return dependencies().is_dependent_nmethod(nm);                                                                                    
2132 }                                                                                                                                    
2133 #endif //PRODUCT                                                                                                                     
2134 
2135 void InstanceKlass::clean_weak_instanceklass_links() {                                                                               
2136   clean_implementors_list();                                                                                                         
2137   clean_method_data();                                                                                                               
2138 
2139   // Since GC iterates InstanceKlasses sequentially, it is safe to remove stale entries here.                                        
                                                                                                                                     
2140   DependencyContext dep_context(&_dep_context);                                                                                      
2141   dep_context.expunge_stale_entries();                                                                                               
2142 }                                                                                                                                    
2143 
2144 void InstanceKlass::clean_implementors_list() {                                                                                      
2145   assert(is_loader_alive(), "this klass should be live");                                                                            
2146   if (is_interface()) {                                                                                                              
2147     if (ClassUnloading) {                                                                                                            
2148       Klass* impl = implementor();                                                                                                   
2149       if (impl != NULL) {                                                                                                            
2150         if (!impl->is_loader_alive()) {                                                                                              
2151           // remove this guy                                                                                                         
2152           Klass** klass = adr_implementor();                                                                                         
2153           assert(klass != NULL, "null klass");                                                                                       
2154           if (klass != NULL) {                                                                                                       
2155             *klass = NULL;                                                                                                           
2156           }                                                                                                                          
2157         }                                                                                                                            
2158       }                                                                                                                              

2120 
2121 void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {
2122   dependencies().remove_dependent_nmethod(nm, delete_immediately);
2123 }
2124 
2125 #ifndef PRODUCT
2126 void InstanceKlass::print_dependent_nmethods(bool verbose) {
2127   dependencies().print_dependent_nmethods(verbose);
2128 }
2129 
2130 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
2131   return dependencies().is_dependent_nmethod(nm);
2132 }
2133 #endif //PRODUCT
2134 
2135 void InstanceKlass::clean_weak_instanceklass_links() {
2136   clean_implementors_list();
2137   clean_method_data();
2138 
2139   // Since GC iterates InstanceKlasses sequentially, it is safe to remove stale entries here.
2140   MutexLockerEx m(CodeCache_lock, Mutex::_no_safepoint_check_flag);
2141   DependencyContext dep_context(&_dep_context);
2142   dep_context.expunge_stale_entries();
2143 }
2144 
2145 void InstanceKlass::clean_implementors_list() {
2146   assert(is_loader_alive(), "this klass should be live");
2147   if (is_interface()) {
2148     if (ClassUnloading) {
2149       Klass* impl = implementor();
2150       if (impl != NULL) {
2151         if (!impl->is_loader_alive()) {
2152           // remove this guy
2153           Klass** klass = adr_implementor();
2154           assert(klass != NULL, "null klass");
2155           if (klass != NULL) {
2156             *klass = NULL;
2157           }
2158         }
2159       }
< prev index next >