src/hotspot/share/classfile/classLoaderDataGraph.cpp

*** 285,351 ****
    ClassLoaderData* _next;
    HandleMark       _hm;  // clean up handles when this is done.
    Handle           _holder;
    Thread*          _thread;
  
-   void hold_next() {
-     if (_next != NULL) {
-       _holder = Handle(_thread, _next->holder_phantom());
-     }
-   }
  public:
    ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) {
      _thread = Thread::current();
      assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
-     hold_next();
-   }
- 
-   bool repeat() const {
-     return _next != NULL;
    }
  
    ClassLoaderData* get_next() {
!     ClassLoaderData* next = _next;
!     if (_next != NULL) {
!       _next = _next->next();
!       hold_next();
      }
!     return next;
    }
  };
  
  // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
  // if they are not calling the function from a safepoint.
  void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->classes_do(klass_closure);
    }
  }
  
  void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->classes_do(f);
    }
  }
  
  void ClassLoaderDataGraph::methods_do(void f(Method*)) {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->methods_do(f);
    }
  }
  
  void ClassLoaderDataGraph::modules_do(void f(ModuleEntry*)) {
    assert_locked_or_safepoint(Module_lock);
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->modules_do(f);
    }
  }
  
  void ClassLoaderDataGraph::modules_unloading_do(void f(ModuleEntry*)) {
--- 285,346 ----
    ClassLoaderData* _next;
    HandleMark       _hm;  // clean up handles when this is done.
    Handle           _holder;
    Thread*          _thread;
  
  public:
    ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) {
      _thread = Thread::current();
      assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    }
  
    ClassLoaderData* get_next() {
!     ClassLoaderData* cld = _next;
!     // Skip already unloaded CLD for concurrent unloading.
!     while (cld != NULL && !cld->is_alive()) {
!       cld = cld->next();
      }
!     if (cld != NULL) {
!       // Keep cld that is being returned alive.
!       _holder = Handle(_thread, cld->holder_phantom());
!       _next = cld->next();
!     } else {
!       _next = NULL;
!     }
!     return cld;
    }
+ 
+ 
  };
  
  // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
  // if they are not calling the function from a safepoint.
  void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->classes_do(klass_closure);
    }
  }
  
  void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->classes_do(f);
    }
  }
  
  void ClassLoaderDataGraph::methods_do(void f(Method*)) {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->methods_do(f);
    }
  }
  
  void ClassLoaderDataGraph::modules_do(void f(ModuleEntry*)) {
    assert_locked_or_safepoint(Module_lock);
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->modules_do(f);
    }
  }
  
  void ClassLoaderDataGraph::modules_unloading_do(void f(ModuleEntry*)) {
*** 359,370 ****
  }
  
  void ClassLoaderDataGraph::packages_do(void f(PackageEntry*)) {
    assert_locked_or_safepoint(Module_lock);
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->packages_do(f);
    }
  }
  
  void ClassLoaderDataGraph::packages_unloading_do(void f(PackageEntry*)) {
--- 354,364 ----
  }
  
  void ClassLoaderDataGraph::packages_do(void f(PackageEntry*)) {
    assert_locked_or_safepoint(Module_lock);
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->packages_do(f);
    }
  }
  
  void ClassLoaderDataGraph::packages_unloading_do(void f(PackageEntry*)) {
*** 377,388 ****
    }
  }
  
  void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->loaded_classes_do(klass_closure);
    }
  }
  
  // This case can block but cannot do unloading (called from CDS)
--- 371,381 ----
    }
  }
  
  void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->loaded_classes_do(klass_closure);
    }
  }
  
  // This case can block but cannot do unloading (called from CDS)
*** 402,413 ****
      cld->classes_do(f);
    }
  }
  
  #define FOR_ALL_DICTIONARY(X)   ClassLoaderDataGraphIterator iter; \
!                                 ClassLoaderData* X; \
!                                 while ((X = iter.get_next()) != NULL) \
                                    if (X->dictionary() != NULL)
  
  // Walk classes in the loaded class dictionaries in various forms.
  // Only walks the classes defined in this class loader.
  void ClassLoaderDataGraph::dictionary_classes_do(void f(InstanceKlass*)) {
--- 395,405 ----
      cld->classes_do(f);
    }
  }
  
  #define FOR_ALL_DICTIONARY(X)   ClassLoaderDataGraphIterator iter; \
!                                 while (ClassLoaderData* X = iter.get_next()) \
                                    if (X->dictionary() != NULL)
  
  // Walk classes in the loaded class dictionaries in various forms.
  // Only walks the classes defined in this class loader.
  void ClassLoaderDataGraph::dictionary_classes_do(void f(InstanceKlass*)) {
*** 694,712 ****
    return 0;
  }
  
  void ClassLoaderDataGraph::verify() {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->verify();
    }
  }
  
  void ClassLoaderDataGraph::print_on(outputStream * const out) {
    ClassLoaderDataGraphIterator iter;
!   while (iter.repeat()) {
!     ClassLoaderData* cld = iter.get_next();
      cld->print_on(out);
    }
  }
  #endif // PRODUCT
--- 686,702 ----
    return 0;
  }
  
  void ClassLoaderDataGraph::verify() {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->verify();
    }
  }
  
  void ClassLoaderDataGraph::print_on(outputStream * const out) {
    ClassLoaderDataGraphIterator iter;
!   while (ClassLoaderData* cld = iter.get_next()) {
      cld->print_on(out);
    }
  }
  #endif // PRODUCT