src/share/vm/classfile/systemDictionary.cpp

rev 13113 : 8182651: Add TRACE_ONLY conditional macro to support more fine-grained INCLUDE_TRACE programming
Reviewed-by:

@@ -70,13 +70,11 @@
 #include "runtime/mutexLocker.hpp"
 #include "runtime/orderAccess.inline.hpp"
 #include "runtime/signature.hpp"
 #include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
-#include "trace/traceMacros.hpp"
 #include "utilities/macros.hpp"
-#include "utilities/ticks.hpp"
 #if INCLUDE_CDS
 #include "classfile/sharedClassUtil.hpp"
 #include "classfile/systemDictionaryShared.hpp"
 #endif
 #if INCLUDE_JVMCI

@@ -613,36 +611,35 @@
     }
   }
   return NULL;
 }
 
-static void post_class_load_event(const Ticks& start_time,
-                                  InstanceKlass* k,
-                                  const ClassLoaderData* init_cld) {
 #if INCLUDE_TRACE
-  EventClassLoad event(UNTIMED);
-  if (event.should_commit()) {
-    event.set_starttime(start_time);
-    event.set_loadedClass(k);
-    event.set_definingClassLoader(k->class_loader_data());
-    event.set_initiatingClassLoader(init_cld);
-    event.commit();
+static void post_class_load_event(EventClassLoad* event,
+                                  const InstanceKlass* k,
+                                  const ClassLoaderData* init_cld) {
+  assert(event != NULL, "invariant");
+  assert(k != NULL, "invariant");
+
+  if (event->should_commit()) {
+    event->set_loadedClass(k);
+    //event->set_definingClassLoader(k->class_loader_data());
+    event->set_initiatingClassLoader(init_cld);
+    event->commit();
   }
-#endif // INCLUDE_TRACE
 }
 
-static void class_define_event(InstanceKlass* k,
+static void post_class_define_event(const InstanceKlass* k,
                                const ClassLoaderData* def_cld) {
-#if INCLUDE_TRACE
   EventClassDefine event;
   if (event.should_commit()) {
     event.set_definedClass(k);
     event.set_definingClassLoader(def_cld);
     event.commit();
   }
-#endif // INCLUDE_TRACE
 }
+#endif // INCLUDE_TRACE
 
 // Be careful when modifying this code: once you have run
 // placeholders()->find_and_add(PlaceholderTable::LOAD_INSTANCE),
 // you need to find_and_remove it before returning.
 // So be careful to not exit with a CHECK_ macro betweeen these calls.

@@ -651,11 +648,11 @@
                                                         Handle protection_domain,
                                                         TRAPS) {
   assert(name != NULL && !FieldType::is_array(name) &&
          !FieldType::is_obj(name), "invalid class name");
 
-  Ticks class_load_start_time = Ticks::now();
+  TRACE_ONLY(EventClassLoad ev;)
 
   HandleMark hm(THREAD);
 
   // Fix for 4474172; see evaluation for more details
   class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));

@@ -897,11 +894,11 @@
 
   if (HAS_PENDING_EXCEPTION || k == NULL) {
     return NULL;
   }
 
-  post_class_load_event(class_load_start_time, k, loader_data);
+  TRACE_ONLY(post_class_load_event(&ev, k, loader_data);)
 
 #ifdef ASSERT
   {
     ClassLoaderData* loader_data = k->class_loader_data();
     MutexLocker mu(SystemDictionary_lock, THREAD);

@@ -1020,12 +1017,11 @@
                                               Handle protection_domain,
                                               ClassFileStream* st,
                                               const InstanceKlass* host_klass,
                                               GrowableArray<Handle>* cp_patches,
                                               TRAPS) {
-
-  Ticks class_load_start_time = Ticks::now();
+  TRACE_ONLY(EventClassLoad ev;)
 
   ClassLoaderData* loader_data;
   if (host_klass != NULL) {
     // Create a new CLD for anonymous class, that uses the same class loader
     // as the host_klass

@@ -1080,11 +1076,11 @@
     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, loader_data);
+    TRACE_ONLY(post_class_load_event(&ev, k, loader_data);)
   }
   assert(host_klass != NULL || NULL == cp_patches,
          "cp_patches only found with host_klass");
 
   return k;

@@ -1662,11 +1658,11 @@
   if (JvmtiExport::should_post_class_load()) {
       assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
       JvmtiExport::post_class_load((JavaThread *) THREAD, k);
 
   }
-  class_define_event(k, loader_data);
+  TRACE_ONLY(post_class_define_event(k, loader_data);)
 }
 
 // Support parallel classloading
 // All parallel class loaders, including bootstrap classloader
 // lock a placeholder entry for this class/class_loader pair