jdk-sandbox: comparison hotspot/src/share/vm/classfile/systemDictionary.cpp

equal deleted inserted replaced

-:f9e300086063
+:b7bcf7497f93
 #include "runtime/javaCalls.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/signature.hpp"
 #include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
+#if INCLUDE_TRACE
+#include "trace/tracing.hpp"
+#include "trace/traceMacros.hpp"
+#endif
 Dictionary*            SystemDictionary::_dictionary          = NULL;
 PlaceholderTable*      SystemDictionary::_placeholders        = NULL;
 Dictionary*            SystemDictionary::_shared_dictionary   = NULL;
 }
 return (nh);
 }
-Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name, Handle class_loader, Handle protection_domain, TRAPS) {
+Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
+Handle class_loader,
+Handle protection_domain,
+TRAPS) {
 assert(name != NULL && !FieldType::is_array(name) &&
 !FieldType::is_obj(name), "invalid class name");
+TracingTime class_load_start_time = Tracing::time();
 // UseNewReflection
 // Fix for 4474172; see evaluation for more details
 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
 ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL);
 if (!HAS_PENDING_EXCEPTION) {
 { // Grabbing the Compile_lock prevents systemDictionary updates
 // during compilations.
 MutexLocker mu(Compile_lock, THREAD);
 update_dictionary(d_index, d_hash, p_index, p_hash,
 k, class_loader, THREAD);
 }
 if (JvmtiExport::should_post_class_load()) {
 Thread *thread = THREAD;
 assert(thread->is_Java_thread(), "thread->is_Java_thread()");
 JvmtiExport::post_class_load((JavaThread *) thread, k());
 }
 if (load_instance_added == true) {
 // clean up placeholder entries for LOAD_INSTANCE success or error
 // This brackets the SystemDictionary updates for both defining
 // and initiating loaders
 MutexLocker mu(SystemDictionary_lock, THREAD);
 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, THREAD);
 SystemDictionary_lock->notify_all();
 }
 }
 if (HAS_PENDING_EXCEPTION || k.is_null()) {
 return NULL;
 }
+post_class_load_event(class_load_start_time, k, class_loader);
 #ifdef ASSERT
 {
 ClassLoaderData* loader_data = k->class_loader_data();
 MutexLocker mu(SystemDictionary_lock, THREAD);
 KlassHandle host_klass,
 GrowableArray<Handle>* cp_patches,
 TRAPS) {
 TempNewSymbol parsed_name = NULL;
+TracingTime class_load_start_time = Tracing::time();
 ClassLoaderData* loader_data;
 if (host_klass.not_null()) {
 // Create a new CLD for anonymous class, that uses the same class loader
 // as the host_klass
 assert(EnableInvokeDynamic, "");
 // notify jvmti
 if (JvmtiExport::should_post_class_load()) {
 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
 }
+post_class_load_event(class_load_start_time, k, class_loader);
 }
 assert(host_klass.not_null() || cp_patches == NULL,
 "cp_patches only found with host_klass");
 return k();
 if (JvmtiExport::should_post_class_load()) {
 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
 }
 }
 // Support parallel classloading
 // All parallel class loaders, including bootstrap classloader
 // lock a placeholder entry for this class/class_loader pair
 }
 }
 }
 return newsize;
 }
 // Assumes classes in the SystemDictionary are only unloaded at a safepoint
 // Note: anonymous classes are not in the SD.
 bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) {
 // First, mark for unload all ClassLoaderData referencing a dead class loader.
 bool has_dead_loaders = ClassLoaderDataGraph::do_unloading(is_alive);
 // defined, not each time it is referenced from a new class loader
 if (k->class_loader() == class_loader()) {
 k->set_prototype_header(markOopDesc::biased_locking_prototype());
 }
 }
-// Assign a classid if one has not already been assigned.  The
-// counter does not need to be atomically incremented since this
-// is only done while holding the SystemDictionary_lock.
-// All loaded classes get a unique ID.
-TRACE_INIT_ID(k);
 // Make a new system dictionary entry.
 Klass* sd_check = find_class(d_index, d_hash, name, loader_data);
 if (sd_check == NULL) {
 dictionary()->add_klass(name, loader_data, k);
 }
 guarantee(probe != NULL || name != NULL,
 "Loaded klasses should be in SystemDictionary");
 }
+// utility function for class load event
+void SystemDictionary::post_class_load_event(TracingTime start_time,
+instanceKlassHandle k,
+Handle initiating_loader) {
+#if INCLUDE_TRACE
+EventClassLoad event(UNTIMED);
+if (event.should_commit()) {
+event.set_endtime(Tracing::time());
+event.set_starttime(start_time);
+event.set_loadedClass(k());
+oop defining_class_loader = k->class_loader();
+event.set_definingClassLoader(defining_class_loader !=  NULL ?
+defining_class_loader->klass() : (Klass*)NULL);
+oop class_loader = initiating_loader.is_null() ? (oop)NULL : initiating_loader();
+event.set_initiatingClassLoader(class_loader != NULL ?
+class_loader->klass() : (Klass*)NULL);
+event.commit();
+}
+#endif /* INCLUDE_TRACE */
+}
 #ifndef PRODUCT
 // statistics code
 class ClassStatistics: AllStatic {
 private:

changeset 18025	b7bcf7497f93
parent 17373	7d8bb2a8787e
child 20405	3321f6b16639