< prev index next >

src/hotspot/share/classfile/classLoaderData.cpp

concurrent root iterator v3

1099     ResourceMark rm;                                                                                                                 
1100     LogStream ls(lt);                                                                                                                
1101     ls.print("create ");                                                                                                             
1102     cld->print_value_on(&ls);                                                                                                        
1103     ls.cr();                                                                                                                         
1104   }                                                                                                                                  
1105   return cld;                                                                                                                        
1106 }                                                                                                                                    
1107 
1108 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_unsafe_anonymous) {                                                
1109   ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);                                                          
1110   // Initialize _name and _name_and_id after the loader data is added to the                                                         
1111   // CLDG because adding the Symbol for _name and _name_and_id might safepoint.                                                      
1112   if (loader.not_null()) {                                                                                                           
1113     loader_data->initialize_name(loader);                                                                                            
1114   }                                                                                                                                  
1115   return loader_data;                                                                                                                
1116 }                                                                                                                                    
1117 
1118 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {                                                                                  
1119   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);                                                                             
1120   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {                                                               
1121     cl->do_cld(cld);                                                                                                                 
1122   }                                                                                                                                  
1123 }                                                                                                                                    
1124 
1125 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {                                                                        
1126   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);                                                                             
1127   // Only walk the head until any clds not purged from prior unloading                                                               
1128   // (CMS doesn't purge right away).                                                                                                 
1129   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {                                              
1130     assert(cld->is_unloading(), "invariant");                                                                                        
1131     cl->do_cld(cld);                                                                                                                 
1132   }                                                                                                                                  
1133 }                                                                                                                                    
1134 
1135 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {                                                      
1136   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);                                                                             
1137   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {                                                               
1138     CLDClosure* closure = cld->keep_alive() ? strong : weak;                                                                         
1139     if (closure != NULL) {                                                                                                           
1140       closure->do_cld(cld);                                                                                                          
1141     }                                                                                                                                
1142   }                                                                                                                                  
1143 }                                                                                                                                    
1144 
1145 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {                                                                    
1146   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);                                                                             
1147   if (ClassUnloading) {                                                                                                              
1148     roots_cld_do(cl, NULL);                                                                                                          
1149   } else {                                                                                                                           
1150     cld_do(cl);                                                                                                                      
1151   }                                                                                                                                  
1152 }                                                                                                                                    
1153 
1154 // Closure for locking and iterating through classes.                                                                                
1155 LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {                                                               
1156   ClassLoaderDataGraph_lock->lock();                                                                                                 
1157 }                                                                                                                                    
1158 
1159 LockedClassesDo::LockedClassesDo() : _function(NULL) {                                                                               
1160   // callers provide their own do_klass                                                                                              
1161   ClassLoaderDataGraph_lock->lock();                                                                                                 
1162 }                                                                                                                                    
1163 
1164 LockedClassesDo::~LockedClassesDo() { ClassLoaderDataGraph_lock->unlock(); }                                                         
1165 

1099     ResourceMark rm;
1100     LogStream ls(lt);
1101     ls.print("create ");
1102     cld->print_value_on(&ls);
1103     ls.cr();
1104   }
1105   return cld;
1106 }
1107 
1108 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_unsafe_anonymous) {
1109   ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
1110   // Initialize _name and _name_and_id after the loader data is added to the
1111   // CLDG because adding the Symbol for _name and _name_and_id might safepoint.
1112   if (loader.not_null()) {
1113     loader_data->initialize_name(loader);
1114   }
1115   return loader_data;
1116 }
1117 
1118 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
1119   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
1120   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
1121     cl->do_cld(cld);
1122   }
1123 }
1124 
1125 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
1126   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
1127   // Only walk the head until any clds not purged from prior unloading
1128   // (CMS doesn't purge right away).
1129   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
1130     assert(cld->is_unloading(), "invariant");
1131     cl->do_cld(cld);
1132   }
1133 }
1134 
1135 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
1136   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
1137   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
1138     CLDClosure* closure = cld->keep_alive() ? strong : weak;
1139     if (closure != NULL) {
1140       closure->do_cld(cld);
1141     }
1142   }
1143 }
1144 
1145 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
1146   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
1147   if (ClassUnloading) {
1148     roots_cld_do(cl, NULL);
1149   } else {
1150     cld_do(cl);
1151   }
1152 }
1153 
1154 // Closure for locking and iterating through classes.
1155 LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
1156   ClassLoaderDataGraph_lock->lock();
1157 }
1158 
1159 LockedClassesDo::LockedClassesDo() : _function(NULL) {
1160   // callers provide their own do_klass
1161   ClassLoaderDataGraph_lock->lock();
1162 }
1163 
1164 LockedClassesDo::~LockedClassesDo() { ClassLoaderDataGraph_lock->unlock(); }
1165 
< prev index next >