< prev index next >
src/hotspot/share/classfile/classLoaderData.cpp
Print this page
@@ -83,22 +83,40 @@
volatile size_t ClassLoaderDataGraph::_num_array_classes = 0;
volatile size_t ClassLoaderDataGraph::_num_instance_classes = 0;
ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
-ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
+void ClassLoaderData::init_null_class_loader_data() {
+ assert(_the_null_class_loader_data == NULL, "cannot initialize twice");
+ assert(ClassLoaderDataGraph::_head == NULL, "cannot initialize twice");
+
+ _the_null_class_loader_data = new ClassLoaderData(Handle(), false);
+ ClassLoaderDataGraph::_head = _the_null_class_loader_data;
+ assert(_the_null_class_loader_data->is_the_null_class_loader_data(), "Must be");
+
+ LogTarget(Debug, class, loader, data) lt;
+ if (lt.is_enabled()) {
+ ResourceMark rm;
+ LogStream ls(lt);
+ ls.print("create ");
+ _the_null_class_loader_data->print_value_on(&ls);
+ ls.cr();
+ }
+}
+
+ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous) :
_class_loader(h_class_loader()),
_is_anonymous(is_anonymous),
// An anonymous class loader data doesn't have anything to keep
// it from being unloaded during parsing of the anonymous class.
// The null-class-loader should always be kept alive.
_keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0),
_metaspace(NULL), _unloading(false), _klasses(NULL),
_modules(NULL), _packages(NULL),
_claimed(0), _modified_oops(true), _accumulated_modified_oops(false),
_jmethod_ids(NULL), _handles(), _deallocate_list(NULL),
- _next(NULL), _dependencies(dependencies),
+ _next(NULL),
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true,
Monitor::_safepoint_check_never)) {
// A ClassLoaderData created solely for an anonymous class should never have a
// ModuleEntryTable or PackageEntryTable created for it. The defining package
@@ -110,32 +128,20 @@
_unnamed_module = ModuleEntry::create_boot_unnamed_module(this);
} else {
// Create unnamed module for all other loaders
_unnamed_module = ModuleEntry::create_unnamed_module(this);
}
- } else {
- _unnamed_module = NULL;
- }
-
- if (!is_anonymous) {
_dictionary = create_dictionary();
} else {
+ _packages = NULL;
+ _unnamed_module = NULL;
_dictionary = NULL;
}
- TRACE_INIT_ID(this);
-}
-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);
-}
+ NOT_PRODUCT(_dependency_count = 0); // number of class loader dependencies
-void ClassLoaderData::Dependencies::init(TRAPS) {
- // Create empty dependencies array to add to. CMS requires this to be
- // an oop so that it can track additions via card marks. We think.
- _list_head = oopFactory::new_objectArray(2, CHECK);
+ TRACE_INIT_ID(this);
}
ClassLoaderData::ChunkedHandleList::~ChunkedHandleList() {
Chunk* c = _head;
while (c != NULL) {
@@ -154,10 +160,20 @@
*handle = o;
OrderAccess::release_store(&_head->_size, _head->_size + 1);
return handle;
}
+int ClassLoaderData::ChunkedHandleList::count() const {
+ int count = 0;
+ Chunk* chunk = _head;
+ while (chunk != NULL) {
+ count += chunk->_size;
+ chunk = chunk->_next;
+ }
+ return count;
+}
+
inline void ClassLoaderData::ChunkedHandleList::oops_do_chunk(OopClosure* f, Chunk* c, const juint size) {
for (juint i = 0; i < size; i++) {
if (c->_data[i] != NULL) {
f->do_oop(&c->_data[i]);
}
@@ -173,20 +189,19 @@
oops_do_chunk(f, c, c->_size);
}
}
}
-#ifdef ASSERT
class VerifyContainsOopClosure : public OopClosure {
- oop* _target;
+ oop _target;
bool _found;
public:
- VerifyContainsOopClosure(oop* target) : _target(target), _found(false) {}
+ VerifyContainsOopClosure(oop target) : _target(target), _found(false) {}
void do_oop(oop* p) {
- if (p == _target) {
+ if (p != NULL && *p == _target) {
_found = true;
}
}
void do_oop(narrowOop* p) {
@@ -197,16 +212,15 @@
bool found() const {
return _found;
}
};
-bool ClassLoaderData::ChunkedHandleList::contains(oop* p) {
+bool ClassLoaderData::ChunkedHandleList::contains(oop p) {
VerifyContainsOopClosure cl(p);
oops_do(&cl);
return cl.found();
}
-#endif // ASSERT
bool ClassLoaderData::claim() {
if (_claimed == 1) {
return false;
}
@@ -242,18 +256,13 @@
if (clear_mod_oops) {
clear_modified_oops();
}
f->do_oop(&_class_loader);
- _dependencies.oops_do(f);
_handles.oops_do(f);
}
-void ClassLoaderData::Dependencies::oops_do(OopClosure* f) {
- f->do_oop((oop*)&_list_head);
-}
-
void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
// Lock-free access requires load_acquire
for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) {
klass_closure->do_klass(k);
assert(k != k->next_link(), "no loops!");
@@ -324,11 +333,11 @@
}
}
}
}
-void ClassLoaderData::record_dependency(const Klass* k, TRAPS) {
+void ClassLoaderData::record_dependency(const Klass* k) {
assert(k != NULL, "invariant");
ClassLoaderData * const from_cld = this;
ClassLoaderData * const to_cld = k->class_loader_data();
@@ -359,80 +368,30 @@
if (from == to || java_lang_ClassLoader::isAncestor(from, to)) {
return; // this class loader is in the parent list, no need to add it.
}
}
- // It's a dependency we won't find through GC, add it. This is relatively rare.
- // Must handle over GC point.
- Handle dependency(THREAD, to);
- from_cld->_dependencies.add(dependency, CHECK);
-
+ // It's a dependency we won't find through GC, add it.
+ if (!_handles.contains(to)) {
+ NOT_PRODUCT(Atomic::inc(&_dependency_count));
+ LogTarget(Trace, class, loader, data) lt;
+ if (lt.is_enabled()) {
+ ResourceMark rm;
+ LogStream ls(lt);
+ ls.print("adding dependency from ");
+ print_value_on(&ls);
+ ls.print(" to ");
+ to_cld->print_value_on(&ls);
+ ls.cr();
+ }
+ Handle dependency(Thread::current(), to);
+ add_handle(dependency);
// Added a potentially young gen oop to the ClassLoaderData
record_modified_oops();
-}
-
-
-void ClassLoaderData::Dependencies::add(Handle dependency, TRAPS) {
- // Check first if this dependency is already in the list.
- // Save a pointer to the last to add to under the lock.
- objArrayOop ok = _list_head;
- objArrayOop last = NULL;
- while (ok != NULL) {
- last = ok;
- if (ok->obj_at(0) == dependency()) {
- // Don't need to add it
- return;
- }
- ok = (objArrayOop)ok->obj_at(1);
}
-
- // Must handle over GC points
- assert (last != NULL, "dependencies should be initialized");
- objArrayHandle last_handle(THREAD, last);
-
- // Create a new dependency node with fields for (class_loader or mirror, next)
- objArrayOop deps = oopFactory::new_objectArray(2, CHECK);
- deps->obj_at_put(0, dependency());
-
- // Must handle over GC points
- objArrayHandle new_dependency(THREAD, deps);
-
- // Add the dependency under lock
- locked_add(last_handle, new_dependency, THREAD);
}
-void ClassLoaderData::Dependencies::locked_add(objArrayHandle last_handle,
- objArrayHandle new_dependency,
- Thread* THREAD) {
-
- // Have to lock and put the new dependency on the end of the dependency
- // array so the card mark for CMS sees that this dependency is new.
- // Can probably do this lock free with some effort.
- ObjectLocker ol(Handle(THREAD, _list_head), THREAD);
-
- oop loader_or_mirror = new_dependency->obj_at(0);
-
- // Since the dependencies are only added, add to the end.
- objArrayOop end = last_handle();
- objArrayOop last = NULL;
- while (end != NULL) {
- last = end;
- // check again if another thread added it to the end.
- if (end->obj_at(0) == loader_or_mirror) {
- // Don't need to add it
- return;
- }
- end = (objArrayOop)end->obj_at(1);
- }
- assert (last != NULL, "dependencies should be initialized");
- // fill in the first element with the oop in new_dependency.
- if (last->obj_at(0) == NULL) {
- last->obj_at_put(0, new_dependency->obj_at(0));
- } else {
- last->obj_at_put(1, new_dependency());
- }
-}
void ClassLoaderDataGraph::clear_claimed_marks() {
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
cld->clear_claimed();
}
@@ -451,19 +410,19 @@
} else {
ClassLoaderDataGraph::inc_instance_classes(1);
}
}
- if (publicize && k->class_loader_data() != NULL) {
+ if (publicize) {
+ LogTarget(Trace, class, loader, data) lt;
+ if (lt.is_enabled()) {
ResourceMark rm;
- log_trace(class, loader, data)("Adding k: " PTR_FORMAT " %s to CLD: "
- PTR_FORMAT " loader: " PTR_FORMAT " %s",
- p2i(k),
- k->external_name(),
- p2i(k->class_loader_data()),
- p2i((void *)k->class_loader()),
- loader_name());
+ LogStream ls(lt);
+ ls.print("Adding k: " PTR_FORMAT " %s to ", p2i(k), k->external_name());
+ print_value_on(&ls);
+ ls.cr();
+ }
}
}
// Class iterator used by the compiler. It gets some number of classes at
// a safepoint to decay invocation counters on the methods.
@@ -576,16 +535,12 @@
LogTarget(Debug, class, loader, data) lt;
if (lt.is_enabled()) {
ResourceMark rm;
LogStream ls(lt);
- ls.print(": unload loader data " INTPTR_FORMAT, p2i(this));
- ls.print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)class_loader()),
- loader_name());
- if (is_anonymous()) {
- ls.print(" for anonymous class " INTPTR_FORMAT " ", p2i(_klasses));
- }
+ ls.print("unload ");
+ print_value_on(&ls);
ls.cr();
}
// Some items on the _deallocate_list need to free their C heap structures
// if they are not already on the _klasses list.
@@ -777,18 +732,12 @@
if ((metaspace = _metaspace) == NULL) {
if (this == the_null_class_loader_data()) {
assert (class_loader() == NULL, "Must be");
metaspace = new Metaspace(_metaspace_lock, Metaspace::BootMetaspaceType);
} else if (is_anonymous()) {
- if (class_loader() != NULL) {
- log_trace(class, loader, data)("is_anonymous: %s", class_loader()->klass()->internal_name());
- }
metaspace = new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType);
} else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) {
- if (class_loader() != NULL) {
- log_trace(class, loader, data)("is_reflection: %s", class_loader()->klass()->internal_name());
- }
metaspace = new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType);
} else {
metaspace = new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType);
}
// Ensure _metaspace is stable, since it is examined without a lock
@@ -806,11 +755,11 @@
void ClassLoaderData::remove_handle(OopHandle h) {
assert(!is_unloading(), "Do not remove a handle for a CLD that is unloading");
oop* ptr = h.ptr_raw();
if (ptr != NULL) {
- assert(_handles.contains(ptr), "Got unexpected handle " PTR_FORMAT, p2i(ptr));
+ assert(_handles.contains(*ptr), "Got unexpected handle " PTR_FORMAT, p2i(ptr));
// This root is not walked in safepoints, and hence requires an appropriate
// decorator that e.g. maintains the SATB invariant in SATB collectors.
RootAccess<IN_CONCURRENT_ROOT>::oop_store(ptr, oop(NULL));
}
}
@@ -900,53 +849,48 @@
}
}
}
// These anonymous class loaders are to contain classes used for JSR292
-ClassLoaderData* ClassLoaderData::anonymous_class_loader_data(oop loader, TRAPS) {
+ClassLoaderData* ClassLoaderData::anonymous_class_loader_data(Handle loader) {
// Add a new class loader data to the graph.
- Handle lh(THREAD, loader);
- return ClassLoaderDataGraph::add(lh, true, THREAD);
+ return ClassLoaderDataGraph::add(loader, true);
}
-const char* ClassLoaderData::loader_name() {
+const char* ClassLoaderData::loader_name() const {
// Handles null class loader
return SystemDictionary::loader_name(class_loader());
}
-#ifndef PRODUCT
-// Define to dump klasses
-#undef CLD_DUMP_KLASSES
-void ClassLoaderData::dump(outputStream * const out) {
- out->print("ClassLoaderData CLD: " PTR_FORMAT ", loader: " PTR_FORMAT ", loader_klass: " PTR_FORMAT " %s {",
- p2i(this), p2i((void *)class_loader()),
- p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name());
- if (claimed()) out->print(" claimed ");
- if (is_unloading()) out->print(" unloading ");
- out->cr();
- if (metaspace_or_null() != NULL) {
- out->print_cr("metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null()));
- metaspace_or_null()->dump(out);
+void ClassLoaderData::print_value_on(outputStream* out) const {
+ if (class_loader() != NULL) {
+ out->print("loader data: " INTPTR_FORMAT " for instance ", p2i(this));
+ class_loader()->print_value_on(out); // includes loader_name() and address of class loader instance
} else {
- out->print_cr("metaspace: NULL");
- }
-
-#ifdef CLD_DUMP_KLASSES
- if (Verbose) {
- Klass* k = _klasses;
- while (k != NULL) {
- out->print_cr("klass " PTR_FORMAT ", %s", p2i(k), k->name()->as_C_string());
- assert(k != k->next_link(), "no loops!");
- k = k->next_link();
+ // loader data: 0xsomeaddr of <bootloader>
+ out->print("loader data: " INTPTR_FORMAT " of %s", p2i(this), loader_name());
}
+ if (is_anonymous()) {
+ out->print(" anonymous");
}
-#endif // CLD_DUMP_KLASSES
-#undef CLD_DUMP_KLASSES
+}
+
+#ifndef PRODUCT
+void ClassLoaderData::print_on(outputStream* out) const {
+ out->print("ClassLoaderData CLD: " PTR_FORMAT ", loader: " PTR_FORMAT ", loader_klass: %s {",
+ p2i(this), p2i((void *)class_loader()), loader_name());
+ if (is_anonymous()) out->print(" anonymous");
+ if (claimed()) out->print(" claimed");
+ if (is_unloading()) out->print(" unloading");
+ out->print(" metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null()));
+
if (_jmethod_ids != NULL) {
Method::print_jmethod_ids(this, out);
}
+ out->print(" handles count %d", _handles.count());
+ out->print(" dependencies %d", _dependency_count);
out->print_cr("}");
}
#endif // PRODUCT
void ClassLoaderData::verify() {
@@ -986,20 +930,16 @@
bool ClassLoaderDataGraph::_should_purge = false;
bool ClassLoaderDataGraph::_metaspace_oom = 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
- // actual ClassLoaderData object.
- ClassLoaderData::Dependencies dependencies(CHECK_NULL);
-
+ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_anonymous) {
NoSafepointVerifier no_safepoints; // we mustn't GC until we've installed the
// ClassLoaderData in the graph since the CLD
// contains unhandled oops
- ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous, dependencies);
+ ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous);
if (!is_anonymous) {
// First, Atomically set it
ClassLoaderData* old = java_lang_ClassLoader::cmpxchg_loader_data(cld, loader(), NULL);
@@ -1019,50 +959,22 @@
cld->set_next(next);
ClassLoaderData* exchanged = Atomic::cmpxchg(cld, list_head, next);
if (exchanged == next) {
LogTarget(Debug, class, loader, data) lt;
if (lt.is_enabled()) {
- PauseNoSafepointVerifier pnsv(&no_safepoints); // Need safe points for JavaCalls::call_virtual
+ ResourceMark rm;
LogStream ls(lt);
- print_creation(&ls, loader, cld, CHECK_NULL);
+ ls.print("create ");
+ cld->print_value_on(&ls);
+ ls.cr();
}
return cld;
}
next = exchanged;
} while (true);
}
-void ClassLoaderDataGraph::print_creation(outputStream* out, Handle loader, ClassLoaderData* cld, TRAPS) {
- Handle string;
- if (loader.not_null()) {
- // Include the result of loader.toString() in the output. This allows
- // the user of the log to identify the class loader instance.
- JavaValue result(T_OBJECT);
- Klass* spec_klass = SystemDictionary::ClassLoader_klass();
- JavaCalls::call_virtual(&result,
- loader,
- spec_klass,
- vmSymbols::toString_name(),
- vmSymbols::void_string_signature(),
- CHECK);
- assert(result.get_type() == T_OBJECT, "just checking");
- string = Handle(THREAD, (oop)result.get_jobject());
- }
-
- ResourceMark rm;
- out->print("create class loader data " INTPTR_FORMAT, p2i(cld));
- out->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)cld->class_loader()),
- cld->loader_name());
-
- if (string.not_null()) {
- out->print(": ");
- java_lang_String::print(string(), out);
- }
- out->cr();
-}
-
-
void ClassLoaderDataGraph::oops_do(OopClosure* f, bool must_claim) {
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
cld->oops_do(f, must_claim);
}
}
@@ -1475,46 +1387,28 @@
ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {}
#ifndef PRODUCT
// callable from debugger
extern "C" int print_loader_data_graph() {
- ClassLoaderDataGraph::dump_on(tty);
+ ResourceMark rm;
+ ClassLoaderDataGraph::print_on(tty);
return 0;
}
void ClassLoaderDataGraph::verify() {
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
data->verify();
}
}
-void ClassLoaderDataGraph::dump_on(outputStream * const out) {
+void ClassLoaderDataGraph::print_on(outputStream * const out) {
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
- data->dump(out);
+ data->print_on(out);
}
- MetaspaceAux::dump(out);
}
#endif // PRODUCT
-void ClassLoaderData::print_value_on(outputStream* out) const {
- if (class_loader() == NULL) {
- out->print("NULL class loader");
- } else {
- out->print("class loader " INTPTR_FORMAT " ", p2i(this));
- class_loader()->print_value_on(out);
- }
-}
-
-void ClassLoaderData::print_on(outputStream* out) const {
- if (class_loader() == NULL) {
- out->print("NULL class loader");
- } else {
- out->print("class loader " INTPTR_FORMAT " ", p2i(this));
- class_loader()->print_on(out);
- }
-}
-
#if INCLUDE_TRACE
Ticks ClassLoaderDataGraph::_class_unload_time;
void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
< prev index next >