graal-jvmci-8: src/share/vm/classfile/classLoaderData.cpp comparison

comparison src/share/vm/classfile/classLoaderData.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	f2110083203d
children	190899198332

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 #include "classfile/classLoaderData.inline.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/metadataOnStackMark.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "code/codeCache.hpp"
+#include "memory/gcLocker.hpp"
 #include "memory/metadataFactory.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/oopFactory.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/mutex.hpp"
 #include "runtime/safepoint.hpp"
 #include "runtime/synchronizer.hpp"
 #include "utilities/growableArray.hpp"
 #include "utilities/ostream.hpp"
+#if INCLUDE_TRACE
+#include "trace/tracing.hpp"
+#endif
 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
-ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous) :
+ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
 _class_loader(h_class_loader()),
 _is_anonymous(is_anonymous), _keep_alive(is_anonymous), // initially
 _metaspace(NULL), _unloading(false), _klasses(NULL),
 _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
-_next(NULL), _dependencies(),
+_next(NULL), _dependencies(dependencies),
 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
 // empty
 }
 void ClassLoaderData::init_dependencies(TRAPS) {
+assert(!Universe::is_fully_initialized(), "should only be called when initializing");
+assert(is_the_null_class_loader_data(), "should only call this for the null class loader");
 _dependencies.init(CHECK);
 }
 void ClassLoaderData::Dependencies::init(TRAPS) {
 // Create empty dependencies array to add to. CMS requires this to be
 void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
 for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 klass_closure->do_klass(k);
 assert(k != k->next_link(), "no loops!");
+}
+}
+void ClassLoaderData::classes_do(void f(Klass * const)) {
+for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
+f(k);
 }
 }
 void ClassLoaderData::classes_do(void f(InstanceKlass*)) {
 for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 }
 void ClassLoaderData::unload() {
 _unloading = true;
+// Tell serviceability tools these classes are unloading
+classes_do(InstanceKlass::notify_unload_class);
 if (TraceClassLoaderData) {
 ResourceMark rm;
 tty->print("[ClassLoaderData: unload loader data "PTR_FORMAT, this);
 tty->print(" for instance "PTR_FORMAT" of %s", class_loader(),
 loader_name());
 return alive;
 }
 ClassLoaderData::~ClassLoaderData() {
+// Release C heap structures for all the classes.
+classes_do(InstanceKlass::release_C_heap_structures);
 Metaspace *m = _metaspace;
 if (m != NULL) {
 _metaspace = NULL;
 // release the metaspace
 delete m;
 }
 // These anonymous class loaders are to contain classes used for JSR292
 ClassLoaderData* ClassLoaderData::anonymous_class_loader_data(oop loader, TRAPS) {
 // Add a new class loader data to the graph.
-return ClassLoaderDataGraph::add(NULL, loader, CHECK_NULL);
+return ClassLoaderDataGraph::add(loader, true, CHECK_NULL);
 }
 const char* ClassLoaderData::loader_name() {
 // Handles null class loader
 return SystemDictionary::loader_name(class_loader());
 // GC root of class loader data created.
 ClassLoaderData* ClassLoaderDataGraph::_head = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
 // Add a new class loader data node to the list.  Assign the newly created
 // ClassLoaderData into the java/lang/ClassLoader object as a hidden field
-ClassLoaderData* ClassLoaderDataGraph::add(ClassLoaderData** cld_addr, Handle loader, TRAPS) {
+ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_anonymous, TRAPS) {
-// Not assigned a class loader data yet.
+// We need to allocate all the oops for the ClassLoaderData before allocating the
-// Create one.
+// actual ClassLoaderData object.
-ClassLoaderData* *list_head = &_head;
+ClassLoaderData::Dependencies dependencies(CHECK_NULL);
-ClassLoaderData* next = _head;
+No_Safepoint_Verifier no_safepoints; // we mustn't GC until we've installed the
-bool is_anonymous = (cld_addr == NULL);
+// ClassLoaderData in the graph since the CLD
-ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous);
+// contains unhandled oops
-if (cld_addr != NULL) {
+ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous, dependencies);
+if (!is_anonymous) {
+ClassLoaderData** cld_addr = java_lang_ClassLoader::loader_data_addr(loader());
 // First, Atomically set it
 ClassLoaderData* old = (ClassLoaderData*) Atomic::cmpxchg_ptr(cld, cld_addr, NULL);
 if (old != NULL) {
 delete cld;
 // Returns the data.
 }
 }
 // We won the race, and therefore the task of adding the data to the list of
 // class loader data
+ClassLoaderData** list_head = &_head;
+ClassLoaderData* next = _head;
 do {
 cld->set_next(next);
 ClassLoaderData* exchanged = (ClassLoaderData*)Atomic::cmpxchg_ptr(cld, list_head, next);
 if (exchanged == next) {
 if (TraceClassLoaderData) {
 tty->print("create class loader data "PTR_FORMAT, cld);
 tty->print(" for instance "PTR_FORMAT" of %s", cld->class_loader(),
 cld->loader_name());
 tty->print_cr("]");
 }
-// Create dependencies after the CLD is added to the list.  Otherwise,
-// the GC GC will not find the CLD and the _class_loader field will
-// not be updated.
-cld->init_dependencies(CHECK_NULL);
 return cld;
 }
 next = exchanged;
 } while (true);
 }
 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 cld->classes_do(klass_closure);
+}
+}
+void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
+for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
+cld->classes_do(f);
+}
+}
+void ClassLoaderDataGraph::classes_unloading_do(void f(Klass* const)) {
+assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
+for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
+cld->classes_do(f);
 }
 }
 GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
 assert(_head == NULL || _saved_head != NULL, "remember_new_clds(true) not called?");
 seen_dead_loader = true;
 ClassLoaderData* dead = data;
 dead->unload();
 data = data->next();
 // Remove from loader list.
+// This class loader data will no longer be found
+// in the ClassLoaderDataGraph.
 if (prev != NULL) {
 prev->set_next(data);
 } else {
 assert(dead == _head, "sanity check");
 _head = data;
 }
 dead->set_next(_unloading);
 _unloading = dead;
 }
+if (seen_dead_loader) {
+post_class_unload_events();
+}
 return seen_dead_loader;
 }
 void ClassLoaderDataGraph::purge() {
 ClassLoaderData* list = _unloading;
 while (next != NULL) {
 ClassLoaderData* purge_me = next;
 next = purge_me->next();
 delete purge_me;
 }
+Metaspace::purge();
+}
+void ClassLoaderDataGraph::post_class_unload_events(void) {
+#if INCLUDE_TRACE
+assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
+if (Tracing::enabled()) {
+if (Tracing::is_event_enabled(TraceClassUnloadEvent)) {
+assert(_unloading != NULL, "need class loader data unload list!");
+_class_unload_time = Tracing::time();
+classes_unloading_do(&class_unload_event);
+}
+Tracing::on_unloading_classes();
+}
+#endif
 }
 // CDS support
 // Global metaspaces for writing information to the shared archive.  When
 } else {
 out->print("class loader "PTR_FORMAT, this);
 class_loader()->print_value_on(out);
 }
 }
+#if INCLUDE_TRACE
+TracingTime ClassLoaderDataGraph::_class_unload_time;
+void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
+// post class unload event
+EventClassUnload event(UNTIMED);
+event.set_endtime(_class_unload_time);
+event.set_unloadedClass(k);
+oop defining_class_loader = k->class_loader();
+event.set_definingClassLoader(defining_class_loader != NULL ?
+defining_class_loader->klass() : (Klass*)NULL);
+event.commit();
+}
+#endif /* INCLUDE_TRACE */

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/classfile/classLoaderData.cpp @ 10408:836a62f43af9