< prev index next >

src/hotspot/share/classfile/classLoaderDataGraph.cpp


570     // dead and should be removed.  A module's life cycle is equivalent                                                              
571     // to its defining class loader's life cycle.  Since a module is                                                                 
572     // considered dead if its class loader is dead, these walks must                                                                 
573     // occur after each class loader's aliveness is determined.                                                                      
574     if (data->packages() != NULL) {                                                                                                  
575       data->packages()->purge_all_package_exports();                                                                                 
576     }                                                                                                                                
577     if (data->modules_defined()) {                                                                                                   
578       data->modules()->purge_all_module_reads();                                                                                     
579     }                                                                                                                                
580     data = data->next();                                                                                                             
581   }                                                                                                                                  
582 }                                                                                                                                    
583 
584 void ClassLoaderDataGraph::purge() {                                                                                                 
585   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);                                                                             
586   ClassLoaderData* list = _unloading;                                                                                                
587   _unloading = NULL;                                                                                                                 
588   ClassLoaderData* next = list;                                                                                                      
589   bool classes_unloaded = false;                                                                                                     
590   DependencyContext::purge_dependency_contexts();                                                                                    
591   while (next != NULL) {                                                                                                             
592     ClassLoaderData* purge_me = next;                                                                                                
593     next = purge_me->next();                                                                                                         
594     delete purge_me;                                                                                                                 
595     classes_unloaded = true;                                                                                                         
596   }                                                                                                                                  
597   if (classes_unloaded) {                                                                                                            
598     Metaspace::purge();                                                                                                              
599     set_metaspace_oom(false);                                                                                                        
600   }                                                                                                                                  
                                                                                                                                     
601 }                                                                                                                                    
602 
603 int ClassLoaderDataGraph::resize_if_needed() {                                                                                       
604   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");                                                          
605   int resized = 0;                                                                                                                   
606   if (Dictionary::does_any_dictionary_needs_resizing()) {                                                                            
607     FOR_ALL_DICTIONARY(cld) {                                                                                                        
608       if (cld->dictionary()->resize_if_needed()) {                                                                                   
609         resized++;                                                                                                                   
610       }                                                                                                                              
611     }                                                                                                                                
612   }                                                                                                                                  
613   return resized;                                                                                                                    
614 }                                                                                                                                    
615 
616 ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic()                                                   
617     : _next_klass(NULL) {                                                                                                            
618   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");                                                          
619   ClassLoaderData* cld = ClassLoaderDataGraph::_head;                                                                                

570     // dead and should be removed.  A module's life cycle is equivalent
571     // to its defining class loader's life cycle.  Since a module is
572     // considered dead if its class loader is dead, these walks must
573     // occur after each class loader's aliveness is determined.
574     if (data->packages() != NULL) {
575       data->packages()->purge_all_package_exports();
576     }
577     if (data->modules_defined()) {
578       data->modules()->purge_all_module_reads();
579     }
580     data = data->next();
581   }
582 }
583 
584 void ClassLoaderDataGraph::purge() {
585   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
586   ClassLoaderData* list = _unloading;
587   _unloading = NULL;
588   ClassLoaderData* next = list;
589   bool classes_unloaded = false;

590   while (next != NULL) {
591     ClassLoaderData* purge_me = next;
592     next = purge_me->next();
593     delete purge_me;
594     classes_unloaded = true;
595   }
596   if (classes_unloaded) {
597     Metaspace::purge();
598     set_metaspace_oom(false);
599   }
600   DependencyContext::purge_dependency_contexts();
601 }
602 
603 int ClassLoaderDataGraph::resize_if_needed() {
604   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
605   int resized = 0;
606   if (Dictionary::does_any_dictionary_needs_resizing()) {
607     FOR_ALL_DICTIONARY(cld) {
608       if (cld->dictionary()->resize_if_needed()) {
609         resized++;
610       }
611     }
612   }
613   return resized;
614 }
615 
616 ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic()
617     : _next_klass(NULL) {
618   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
619   ClassLoaderData* cld = ClassLoaderDataGraph::_head;
< prev index next >