--- old/src/hotspot/share/runtime/handshake.cpp	2019-11-26 11:55:18.550697351 +0100
+++ new/src/hotspot/share/runtime/handshake.cpp	2019-11-26 11:55:18.286685519 +0100
@@ -32,7 +32,6 @@
 #include "runtime/osThread.hpp"
 #include "runtime/semaphore.inline.hpp"
 #include "runtime/task.hpp"
-#include "runtime/timerTrace.hpp"
 #include "runtime/thread.hpp"
 #include "runtime/vmThread.hpp"
 #include "utilities/formatBuffer.hpp"
@@ -86,6 +85,14 @@
   fatal("Handshake operation timed out");
 }
 
+static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int vmt_executed, const char* extra) {
+  if (start_time_ns != 0) {
+    jlong completion_time = os::javaTimeNanos() - start_time_ns;
+    log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by targeted threads: %d, Total completion time: " JLONG_FORMAT " ns%s",
+                        name, targets, targets - vmt_executed, completion_time, extra);
+  }
+}
+
 class VM_HandshakeOneThread: public VM_Handshake {
   JavaThread* _target;
  public:
@@ -94,20 +101,25 @@
 
   void doit() {
     DEBUG_ONLY(_op->check_state();)
-    TraceTime timer("Finished executing single-target operation (VM_HandshakeOneThread::doit)", TRACETIME_LOG(Info, handshake));
+
+    jlong start_time_ns = 0;
+    if (log_is_enabled(Info, handshake)) {
+      start_time_ns = os::javaTimeNanos();
+    }
 
     ThreadsListHandle tlh;
     if (tlh.includes(_target)) {
       set_handshake(_target);
     } else {
-      log_trace(handshake)("JavaThread " INTPTR_FORMAT " is not alive", p2i(_target));
+      log_handshake_info(start_time_ns, _op->name(), 0, 0, " (thread dead)");
       return;
     }
 
     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
-    jlong start_time = os::elapsed_counter();
+    jlong timeout_start_time = os::elapsed_counter();
+    bool by_vm_thread = false;
     do {
-      if (handshake_has_timed_out(start_time)) {
+      if (handshake_has_timed_out(timeout_start_time)) {
         handle_timeout();
       }
 
@@ -116,10 +128,11 @@
       // locked during certain phases.
       {
         MutexLocker ml(Threads_lock);
-        _target->handshake_process_by_vmthread();
+        by_vm_thread = _target->handshake_process_by_vmthread();
       }
     } while (!poll_for_completed_thread());
     DEBUG_ONLY(_op->check_state();)
+    log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0, "");
   }
 
   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
@@ -133,7 +146,12 @@
 
   void doit() {
     DEBUG_ONLY(_op->check_state();)
-    TraceTime timer("Finished executing multi-target operation (VM_HandshakeAllThreads::doit)", TRACETIME_LOG(Info, handshake));
+
+    jlong start_time_ns = 0;
+    if (log_is_enabled(Info, handshake)) {
+      start_time_ns = os::javaTimeNanos();
+    }
+    int handshake_executed_by_vm_thread = 0;
 
     JavaThreadIteratorWithHandle jtiwh;
     int number_of_threads_issued = 0;
@@ -143,11 +161,11 @@
     }
 
     if (number_of_threads_issued < 1) {
-      log_debug(handshake)("No threads to handshake.");
+      log_handshake_info(start_time_ns, _op->name(), 0, 0, " (no threads)");
       return;
     }
 
-    log_debug(handshake)("Threads signaled, begin processing blocked threads by VMThtread");
+    log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThtread");
     const jlong start_time = os::elapsed_counter();
     int number_of_threads_completed = 0;
     do {
@@ -168,7 +186,9 @@
           for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
             // A new thread on the ThreadsList will not have an operation,
             // hence it is skipped in handshake_process_by_vmthread.
-            thr->handshake_process_by_vmthread();
+            if (thr->handshake_process_by_vmthread()) {
+              handshake_executed_by_vm_thread++;
+            }
           }
       }
 
@@ -180,6 +200,8 @@
     } while (number_of_threads_issued > number_of_threads_completed);
     assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
     DEBUG_ONLY(_op->check_state();)
+
+    log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread, "");
   }
 
   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
@@ -197,7 +219,7 @@
       _hs_op(hs_op), _target_thread(target), _all_threads(false), _executed(false) {}
 
   void doit() {
-    log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation");
+    log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation, operation: %s", name());
     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
       if (_all_threads || t == _target_thread) {
         if (t == _target_thread) {
@@ -213,10 +235,10 @@
 };
 
 void HandshakeOperation::do_handshake(JavaThread* thread) {
-  ResourceMark rm;
-  FormatBufferResource message("Operation for thread " PTR_FORMAT ", is_vm_thread: %s",
-                               p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()));
-  TraceTime timer(message, TRACETIME_LOG(Debug, handshake, task));
+  jlong start_time_ns = 0;
+  if (log_is_enabled(Debug, handshake, task)) {
+    start_time_ns = os::javaTimeNanos();
+  }
 
   // Only actually execute the operation for non terminated threads.
   if (!thread->is_terminated()) {
@@ -226,6 +248,12 @@
 
   // Use the semaphore to inform the VM thread that we have completed the operation
   _done.signal();
+
+  if (start_time_ns != 0) {
+    jlong completion_time = os::javaTimeNanos() - start_time_ns;
+    log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns",
+                               name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
+  }
 }
 
 void Handshake::execute(HandshakeOperation* hs_op) {
@@ -322,37 +350,41 @@
   return false;
 }
 
-void HandshakeState::process_by_vmthread(JavaThread* target) {
+bool HandshakeState::process_by_vmthread(JavaThread* target) {
   assert(Thread::current()->is_VM_thread(), "should call from vm thread");
   // Threads_lock must be held here, but that is assert()ed in
   // possibly_vmthread_can_process_handshake().
 
   if (!has_operation()) {
     // JT has already cleared its handshake
-    return;
+    return false;
   }
 
   if (!possibly_vmthread_can_process_handshake(target)) {
     // JT is observed in an unsafe state, it must notice the handshake itself
-    return;
+    return false;
   }
 
   // Claim the semaphore if there still an operation to be executed.
   if (!claim_handshake_for_vmthread()) {
-    return;
+    return false;
   }
 
   // If we own the semaphore at this point and while owning the semaphore
   // can observe a safe state the thread cannot possibly continue without
   // getting caught by the semaphore.
+  bool executed = false;
   if (vmthread_can_process_handshake(target)) {
     guarantee(!_semaphore.trywait(), "we should already own the semaphore");
     log_trace(handshake)("Processing handshake by VMThtread");
     _operation->do_handshake(target);
     // Disarm after VM thread have executed the operation.
     clear_handshake(target);
-    // Release the thread
+    executed = true;
   }
 
+  // Release the thread
   _semaphore.signal();
+
+  return executed;
 }
--- old/src/hotspot/share/runtime/handshake.hpp	2019-11-26 11:55:19.722749880 +0100
+++ new/src/hotspot/share/runtime/handshake.hpp	2019-11-26 11:55:19.461738182 +0100
@@ -97,7 +97,7 @@
     }
   }
 
-  void process_by_vmthread(JavaThread* target);
+  bool process_by_vmthread(JavaThread* target);
 };
 
 #endif // SHARE_RUNTIME_HANDSHAKE_HPP
--- old/src/hotspot/share/runtime/thread.hpp	2019-11-26 11:55:20.885802005 +0100
+++ new/src/hotspot/share/runtime/thread.hpp	2019-11-26 11:55:20.620790128 +0100
@@ -1329,8 +1329,8 @@
     _handshake.process_by_self(this);
   }
 
-  void handshake_process_by_vmthread() {
-    _handshake.process_by_vmthread(this);
+  bool handshake_process_by_vmthread() {
+    return _handshake.process_by_vmthread(this);
   }
 
   // Suspend/resume support for JavaThread