src/hotspot/share/classfile/classLoaderDataGraph.cpp

*** 184,14 ***
  }
  
  // GC root of class loader data created.
  ClassLoaderData* volatile ClassLoaderDataGraph::_head = NULL;
  ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
- ClassLoaderData* ClassLoaderDataGraph::_saved_unloading = NULL;
- ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
  
- bool ClassLoaderDataGraph::_should_purge = false;
  bool ClassLoaderDataGraph::_should_clean_deallocate_lists = false;
  bool ClassLoaderDataGraph::_safepoint_cleanup_needed = false;
  bool ClassLoaderDataGraph::_metaspace_oom = false;
  
  // Add a new class loader data node to the list.  Assign the newly created
--- 184,11 ---

*** 247,13 ***
    return loader_data;
  }
  
  void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
!   // Only walk the head until any clds not purged from prior unloading
-   // (CMS doesn't purge right away).
-   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cl->do_cld(cld);
    }
  }
  
--- 244,11 ---
    return loader_data;
  }
  
  void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
!   for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cl->do_cld(cld);
    }
  }
  

*** 381,11 ***
  
  void ClassLoaderDataGraph::modules_unloading_do(void f(ModuleEntry*)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->modules_do(f);
    }
  }
  
--- 376,11 ---
  
  void ClassLoaderDataGraph::modules_unloading_do(void f(ModuleEntry*)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->modules_do(f);
    }
  }
  

*** 399,11 ***
  
  void ClassLoaderDataGraph::packages_unloading_do(void f(PackageEntry*)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->packages_do(f);
    }
  }
  
--- 394,11 ---
  
  void ClassLoaderDataGraph::packages_unloading_do(void f(PackageEntry*)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->packages_do(f);
    }
  }
  

*** 424,11 ***
  
  void ClassLoaderDataGraph::classes_unloading_do(void f(Klass* const)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->classes_do(f);
    }
  }
  
--- 419,11 ---
  
  void ClassLoaderDataGraph::classes_unloading_do(void f(Klass* const)) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
!   for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cld->classes_do(f);
    }
  }
  

*** 474,36 ***
      tempst.print("System Dictionary for %s class loader", cld->loader_name_and_id());
      cld->dictionary()->print_table_statistics(st, tempst.as_string());
    }
  }
  
- GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
-   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
-   assert(_head == NULL || _saved_head != NULL, "remember_new_clds(true) not called?");
- 
-   GrowableArray<ClassLoaderData*>* array = new GrowableArray<ClassLoaderData*>();
- 
-   // The CLDs in [_head, _saved_head] were all added during last call to remember_new_clds(true);
-   ClassLoaderData* curr = _head;
-   while (curr != _saved_head) {
-     if (!curr->claimed(ClassLoaderData::_claim_strong)) {
-       array->push(curr);
-       LogTarget(Debug, class, loader, data) lt;
-       if (lt.is_enabled()) {
-         LogStream ls(lt);
-         ls.print("found new CLD: ");
-         curr->print_value_on(&ls);
-         ls.cr();
-       }
-     }
- 
-     curr = curr->_next;
-   }
- 
-   return array;
- }
- 
  #ifndef PRODUCT
  bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
    assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
      if (loader_data == data) {
--- 469,10 ---

*** 542,14 ***
    ClassLoaderData* prev = NULL;
    bool seen_dead_loader = false;
    uint loaders_processed = 0;
    uint loaders_removed = 0;
  
-   // Save previous _unloading pointer for CMS which may add to unloading list before
-   // purging and we don't want to rewalk the previously unloaded class loader data.
-   _saved_unloading = _unloading;
- 
    data = _head;
    while (data != NULL) {
      if (data->is_alive()) {
        prev = data;
        data = data->next();
--- 511,10 ---