8267920: Create separate Events buffer for VMOperations

Reviewed-by: coleenp, dholmes, tschatzl

Author: stefank

src/hotspot/share/runtime/vmThread.cpp

@@ -395,7 +395,7 @@ void VMThread::inner_execute(VM_Operation* op) {
   _cur_vm_operation = op;
 
   HandleMark hm(VMThread::vm_thread());
-  EventMark em("Executing %s VM operation: %s", prev_vm_operation != NULL ? "nested" : "", op->name());
+  EventMarkVMOperation em("Executing %sVM operation: %s", prev_vm_operation != NULL ? "nested " : "", op->name());
 
   log_debug(vmthread)("Evaluating %s %s VM operation: %s",
                        prev_vm_operation != NULL ? "nested" : "",

src/hotspot/share/utilities/events.cpp

@@ -35,6 +35,7 @@
 
 EventLog* Events::_logs = NULL;
 StringEventLog* Events::_messages = NULL;
+StringEventLog* Events::_vm_operations = NULL;
 ExceptionsEventLog* Events::_exceptions = NULL;
 StringEventLog* Events::_redefinitions = NULL;
 UnloadingEventLog* Events::_class_unloading = NULL;
@@ -91,6 +92,7 @@ void Events::print() {
 void Events::init() {
   if (LogEvents) {
     _messages = new StringEventLog("Events", "events");
+    _vm_operations = new StringEventLog("VM Operations", "vmops");
     _exceptions = new ExceptionsEventLog("Internal exceptions", "exc");
     _redefinitions = new StringEventLog("Classes redefined", "redef");
     _class_unloading = new UnloadingEventLog("Classes unloaded", "unload");
@@ -105,23 +107,20 @@ void eventlog_init() {
 ///////////////////////////////////////////////////////////////////////////
 // EventMark
 
-EventMark::EventMark(const char* format, ...) {
-  if (LogEvents) {
-    va_list ap;
-    va_start(ap, format);
-    // Save a copy of begin message and log it.
-    _buffer.printv(format, ap);
-    Events::log(NULL, "%s", _buffer.buffer());
-    va_end(ap);
-  }
+EventMarkBase::EventMarkBase(EventLogFunction log_function) :
+    _log_function(log_function),
+    _buffer() {}
+
+void EventMarkBase::log_start(const char* format, va_list argp) {
+  // Save a copy of begin message and log it.
+  _buffer.printv(format, argp);
+  _log_function(NULL, "%s", _buffer.buffer());
 }
 
-EventMark::~EventMark() {
-  if (LogEvents) {
-    // Append " done" to the begin message and log it
-    _buffer.append(" done");
-    Events::log(NULL, "%s", _buffer.buffer());
-  }
+void EventMarkBase::log_end() {
+  // Append " done" to the begin message and log it
+  _buffer.append(" done");
+  _log_function(NULL, "%s", _buffer.buffer());
 }
 
 void UnloadingEventLog::log(Thread* thread, InstanceKlass* ik) {

src/hotspot/share/utilities/events.hpp

@@ -220,6 +220,9 @@ class Events : AllStatic {
   // A log for generic messages that aren't well categorized.
   static StringEventLog* _messages;
 
+  // A log for VM Operations
+  static StringEventLog* _vm_operations;
+
   // A log for internal exception related messages, like internal
   // throws and implicit exceptions.
   static ExceptionsEventLog* _exceptions;
@@ -247,6 +250,8 @@ class Events : AllStatic {
   // Logs a generic message with timestamp and format as printf.
   static void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
 
+  static void log_vm_operation(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
+
   // Log exception related message
   static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
   static void log_exception(Thread* thread, Handle h_exception, const char* message, const char* file, int line);
@@ -270,6 +275,15 @@ inline void Events::log(Thread* thread, const char* format, ...) {
   }
 }
 
+inline void Events::log_vm_operation(Thread* thread, const char* format, ...) {
+  if (LogEvents && _vm_operations != NULL) {
+    va_list ap;
+    va_start(ap, format);
+    _vm_operations->logv(thread, format, ap);
+    va_end(ap);
+  }
+}
+
 inline void Events::log_exception(Thread* thread, const char* format, ...) {
   if (LogEvents && _exceptions != NULL) {
     va_list ap;
@@ -414,16 +428,49 @@ inline void EventLogBase<ExtendedStringLogMessage>::print(outputStream* out, Ext
   out->cr();
 }
 
+typedef void (*EventLogFunction)(Thread* thread, const char* format, ...);
+
+class EventMarkBase : public StackObj {
+  EventLogFunction _log_function;
+  StringLogMessage _buffer;
+
+  NONCOPYABLE(EventMarkBase);
+
+ protected:
+  void log_start(const char* format, va_list argp) ATTRIBUTE_PRINTF(2, 0);
+  void log_end();
+
+  EventMarkBase(EventLogFunction log_function);
+};
+
 // Place markers for the beginning and end up of a set of events.
-// These end up in the default log.
-class EventMark : public StackObj {
+template <EventLogFunction log_function>
+class EventMarkWithLogFunction : public EventMarkBase {
   StringLogMessage _buffer;
 
  public:
   // log a begin event, format as printf
-  EventMark(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
+  EventMarkWithLogFunction(const char* format, ...) ATTRIBUTE_PRINTF(2, 3) :
+      EventMarkBase(log_function) {
+    if (LogEvents) {
+      va_list ap;
+      va_start(ap, format);
+      log_start(format, ap);
+      va_end(ap);
+    }
+  }
   // log an end event
-  ~EventMark();
+  ~EventMarkWithLogFunction() {
+    if (LogEvents) {
+      log_end();
+    }
+  }
 };
 
+// These end up in the default log.
+typedef EventMarkWithLogFunction<Events::log> EventMark;
+
+// These end up in the vm_operation log.
+typedef EventMarkWithLogFunction<Events::log_vm_operation> EventMarkVMOperation;
+
 #endif // SHARE_UTILITIES_EVENTS_HPP