truffle: src/share/vm/classfile/classLoaderData.cpp comparison

comparison src/share/vm/classfile/classLoaderData.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 e4a6e7f1b90b
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 if (TraceClassLoaderData && Verbose && k->class_loader_data() != NULL) {
 ResourceMark rm;
 tty->print_cr("[TraceClassLoaderData] Adding k: " PTR_FORMAT " %s to CLD: "
 PTR_FORMAT " loader: " PTR_FORMAT " %s",
-k,
+p2i(k),
 k->external_name(),
-k->class_loader_data(),
+p2i(k->class_loader_data()),
-(void *)k->class_loader(),
+p2i((void *)k->class_loader()),
 loader_name());
 }
 }
 // This is called by InstanceKlass::deallocate_contents() to remove the
 // 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("[ClassLoaderData: unload loader data " INTPTR_FORMAT, p2i(this));
-tty->print(" for instance "PTR_FORMAT" of %s", (void *)class_loader(),
+tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)class_loader()),
 loader_name());
 if (is_anonymous()) {
-tty->print(" for anonymous class  "PTR_FORMAT " ", _klasses);
+tty->print(" for anonymous class  " INTPTR_FORMAT " ", p2i(_klasses));
 }
 tty->print_cr("]");
 }
 }
 #undef CLD_DUMP_KLASSES
 void ClassLoaderData::dump(outputStream * const out) {
 ResourceMark rm;
 out->print("ClassLoaderData CLD: "PTR_FORMAT", loader: "PTR_FORMAT", loader_klass: "PTR_FORMAT" %s {",
-this, (void *)class_loader(),
+p2i(this), p2i((void *)class_loader()),
-class_loader() != NULL ? class_loader()->klass() : NULL, loader_name());
+p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name());
 if (claimed()) out->print(" claimed ");
 if (is_unloading()) out->print(" unloading ");
-out->print(" handles " INTPTR_FORMAT, handles());
+out->print(" handles " INTPTR_FORMAT, p2i(handles()));
 out->cr();
 if (metaspace_or_null() != NULL) {
-out->print_cr("metaspace: " PTR_FORMAT, metaspace_or_null());
+out->print_cr("metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null()));
 metaspace_or_null()->dump(out);
 } else {
 out->print_cr("metaspace: NULL");
 }
 k->verify();
 assert(k != k->next_link(), "no loops!");
 }
 }
+bool ClassLoaderData::contains_klass(Klass* klass) {
+for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
+if (k == klass) return true;
+}
+return false;
+}
 // GC root of class loader data created.
 ClassLoaderData* ClassLoaderDataGraph::_head = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
+ClassLoaderData* ClassLoaderDataGraph::_saved_unloading = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
+bool ClassLoaderDataGraph::_should_purge = false;
 // 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(Handle loader, bool is_anonymous, TRAPS) {
 // We need to allocate all the oops for the ClassLoaderData before allocating the
 ClassLoaderData* exchanged = (ClassLoaderData*)Atomic::cmpxchg_ptr(cld, list_head, next);
 if (exchanged == next) {
 if (TraceClassLoaderData) {
 ResourceMark rm;
 tty->print("[ClassLoaderData: ");
-tty->print("create class loader data "PTR_FORMAT, cld);
+tty->print("create class loader data " INTPTR_FORMAT, p2i(cld));
-tty->print(" for instance "PTR_FORMAT" of %s", (void *)cld->class_loader(),
+tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)cld->class_loader()),
 cld->loader_name());
 tty->print_cr("]");
 }
 return cld;
 }
 }
 }
 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()) {
+// 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()) {
 cld->classes_do(f);
 }
 }
 GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
 return array;
 }
 #ifndef PRODUCT
-// for debugging and hsfind(x)
-bool ClassLoaderDataGraph::contains(address x) {
-// I think we need the _metaspace_lock taken here because the class loader
-// data graph could be changing while we are walking it (new entries added,
-// new entries being unloaded, etc).
-if (DumpSharedSpaces) {
-// There are only two metaspaces to worry about.
-ClassLoaderData* ncld = ClassLoaderData::the_null_class_loader_data();
-return (ncld->ro_metaspace()->contains(x) || ncld->rw_metaspace()->contains(x));
-}
-if (UseSharedSpaces && MetaspaceShared::is_in_shared_space(x)) {
-return true;
-}
-for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
-if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
-return true;
-}
-}
-// Could also be on an unloading list which is okay, ie. still allocated
-// for a little while.
-for (ClassLoaderData* ucld = _unloading; ucld != NULL; ucld = ucld->next()) {
-if (ucld->metaspace_or_null() != NULL && ucld->metaspace_or_null()->contains(x)) {
-return true;
-}
-}
-return false;
-}
 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 if (loader_data == data) {
 return true;
 }
 // and deallocation later.
 bool ClassLoaderDataGraph::do_unloading(BoolObjectClosure* is_alive_closure) {
 ClassLoaderData* data = _head;
 ClassLoaderData* prev = NULL;
 bool seen_dead_loader = false;
+// 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;
 // mark metadata seen on the stack and code cache so we can delete
 // unneeded entries.
 bool has_redefined_a_class = JvmtiExport::has_redefined_a_class();
 MetadataOnStackMark md_on_stack;
 while (data != NULL) {
 return seen_dead_loader;
 }
 void ClassLoaderDataGraph::purge() {
+assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
 ClassLoaderData* list = _unloading;
 _unloading = NULL;
 ClassLoaderData* next = list;
 while (next != NULL) {
 ClassLoaderData* purge_me = next;
 void ClassLoaderData::print_value_on(outputStream* out) const {
 if (class_loader() == NULL) {
 out->print("NULL class_loader");
 } else {
-out->print("class loader "PTR_FORMAT, this);
+out->print("class loader " INTPTR_FORMAT, p2i(this));
 class_loader()->print_value_on(out);
 }
 }
 #if INCLUDE_TRACE

Mercurial > hg > truffle

comparison src/share/vm/classfile/classLoaderData.cpp @ 18041:52b4284cb496