src/hotspot/share/classfile/classLoaderData.cpp

rev 57511 : [mq]: metaspace-improvement

*** 57,66 ****
--- 57,68 ----
  #include "classfile/systemDictionary.hpp"
  #include "logging/log.hpp"
  #include "logging/logStream.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/metadataFactory.hpp"
+ #include "memory/metaspace/classLoaderMetaspace.hpp"
+ #include "memory/metaspace/metaspaceEnums.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/access.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "oops/oopHandle.inline.hpp"
  #include "oops/weakHandle.inline.hpp"
*** 71,80 ****
--- 73,84 ----
  #include "runtime/safepoint.hpp"
  #include "utilities/growableArray.hpp"
  #include "utilities/macros.hpp"
  #include "utilities/ostream.hpp"
  
+ using metaspace::ClassLoaderMetaspace;
+ 
  ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
  
  void ClassLoaderData::init_null_class_loader_data() {
    assert(_the_null_class_loader_data == NULL, "cannot initialize twice");
    assert(ClassLoaderDataGraph::_head == NULL, "cannot initialize twice");
*** 757,773 ****
      MutexLocker ml(_metaspace_lock,  Mutex::_no_safepoint_check_flag);
      // Check if _metaspace got allocated while we were waiting for this lock.
      if ((metaspace = _metaspace) == NULL) {
        if (this == the_null_class_loader_data()) {
          assert (class_loader() == NULL, "Must be");
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::BootMetaspaceType);
        } else if (is_unsafe_anonymous()) {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::UnsafeAnonymousMetaspaceType);
        } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType);
        } else {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::StandardMetaspaceType);
        }
        // Ensure _metaspace is stable, since it is examined without a lock
        OrderAccess::release_store(&_metaspace, metaspace);
      }
    }
--- 761,777 ----
      MutexLocker ml(_metaspace_lock,  Mutex::_no_safepoint_check_flag);
      // Check if _metaspace got allocated while we were waiting for this lock.
      if ((metaspace = _metaspace) == NULL) {
        if (this == the_null_class_loader_data()) {
          assert (class_loader() == NULL, "Must be");
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, metaspace::BootMetaspaceType);
        } else if (is_unsafe_anonymous()) {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, metaspace::UnsafeAnonymousMetaspaceType);
        } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, metaspace::ReflectionMetaspaceType);
        } else {
!         metaspace = new ClassLoaderMetaspace(_metaspace_lock, metaspace::StandardMetaspaceType);
        }
        // Ensure _metaspace is stable, since it is examined without a lock
        OrderAccess::release_store(&_metaspace, metaspace);
      }
    }
*** 954,966 ****
  
    guarantee(this == class_loader_data(cl) || is_unsafe_anonymous(), "Must be the same");
    guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || is_unsafe_anonymous(), "must be");
  
    // Verify the integrity of the allocated space.
    if (metaspace_or_null() != NULL) {
!     metaspace_or_null()->verify();
    }
  
    for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
      guarantee(k->class_loader_data() == this, "Must be the same");
      k->verify();
      assert(k != k->next_link(), "no loops!");
--- 958,972 ----
  
    guarantee(this == class_loader_data(cl) || is_unsafe_anonymous(), "Must be the same");
    guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || is_unsafe_anonymous(), "must be");
  
    // Verify the integrity of the allocated space.
+ #ifdef ASSERT
    if (metaspace_or_null() != NULL) {
!     metaspace_or_null()->verify(false);
    }
+ #endif
  
    for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
      guarantee(k->class_loader_data() == this, "Must be the same");
      k->verify();
      assert(k != k->next_link(), "no loops!");