8284016: Normalize handshake closure names

src/hotspot/share/classfile/javaClasses.cpp

@@ -1899,19 +1899,19 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
     return nullptr;
   }
 
-  class GetStackTraceClosure : public HandshakeClosure {
+  class GetStackTraceHandshakeClosure : public HandshakeClosure {
   public:
     const Handle _java_thread;
     int _depth;
     bool _retry_handshake;
     GrowableArray<Method*>* _methods;
     GrowableArray<int>*     _bcis;
 
-    GetStackTraceClosure(Handle java_thread) :
-        HandshakeClosure("GetStackTraceClosure"), _java_thread(java_thread), _depth(0), _retry_handshake(false),
+    GetStackTraceHandshakeClosure(Handle java_thread) :
+        HandshakeClosure("GetStackTraceHandshakeClosure"), _java_thread(java_thread), _depth(0), _retry_handshake(false),
         _methods(nullptr), _bcis(nullptr) {
     }
-    ~GetStackTraceClosure() {
+    ~GetStackTraceHandshakeClosure() {
       delete _methods;
       delete _bcis;
     }
@@ -1977,13 +1977,13 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
   // Handshake with target
   ResourceMark rm(THREAD);
   HandleMark   hm(THREAD);
-  GetStackTraceClosure gstc(Handle(THREAD, java_thread));
+  GetStackTraceHandshakeClosure gsthc(Handle(THREAD, java_thread));
   do {
-   Handshake::execute(&gstc, &tlh, thread);
-  } while (gstc.read_reset_retry());
+   Handshake::execute(&gsthc, &tlh, thread);
+  } while (gsthc.read_reset_retry());
 
   // Stop if no stack trace is found.
-  if (gstc._depth == 0) {
+  if (gsthc._depth == 0) {
     return nullptr;
   }
 
@@ -1993,12 +1993,12 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
   if (k->should_be_initialized()) {
     k->initialize(CHECK_NULL);
   }
-  objArrayHandle trace = oopFactory::new_objArray_handle(k, gstc._depth, CHECK_NULL);
+  objArrayHandle trace = oopFactory::new_objArray_handle(k, gsthc._depth, CHECK_NULL);
 
-  for (int i = 0; i < gstc._depth; i++) {
-    methodHandle method(THREAD, gstc._methods->at(i));
+  for (int i = 0; i < gsthc._depth; i++) {
+    methodHandle method(THREAD, gsthc._methods->at(i));
     oop element = java_lang_StackTraceElement::create(method,
-                                                      gstc._bcis->at(i),
+                                                      gsthc._bcis->at(i),
                                                       CHECK_NULL);
     trace->obj_at_put(i, element);
   }

src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp

@@ -1145,22 +1145,22 @@ void ShenandoahConcurrentGC::op_update_refs() {
   ShenandoahHeap::heap()->update_heap_references(true /*concurrent*/);
 }
 
-class ShenandoahUpdateThreadClosure : public HandshakeClosure {
+class ShenandoahUpdateThreadHandshakeClosure : public HandshakeClosure {
 private:
   // This closure runs when thread is stopped for handshake, which means
   // we can use non-concurrent closure here, as long as it only updates
   // locations modified by the thread itself, i.e. stack locations.
   ShenandoahNonConcUpdateRefsClosure _cl;
 public:
-  ShenandoahUpdateThreadClosure();
+  ShenandoahUpdateThreadHandshakeClosure();
   void do_thread(Thread* thread);
 };
 
-ShenandoahUpdateThreadClosure::ShenandoahUpdateThreadClosure() :
+ShenandoahUpdateThreadHandshakeClosure::ShenandoahUpdateThreadHandshakeClosure() :
   HandshakeClosure("Shenandoah Update Thread Roots") {
 }
 
-void ShenandoahUpdateThreadClosure::do_thread(Thread* thread) {
+void ShenandoahUpdateThreadHandshakeClosure::do_thread(Thread* thread) {
   if (thread->is_Java_thread()) {
     JavaThread* jt = JavaThread::cast(thread);
     ResourceMark rm;
@@ -1169,7 +1169,7 @@ void ShenandoahUpdateThreadClosure::do_thread(Thread* thread) {
 }
 
 void ShenandoahConcurrentGC::op_update_thread_roots() {
-  ShenandoahUpdateThreadClosure cl;
+  ShenandoahUpdateThreadHandshakeClosure cl;
   Handshake::execute(&cl);
 }
 

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -1245,9 +1245,9 @@ class ShenandoahRetireGCLABClosure : public ThreadClosure {
   }
 };
 
-class ShenandoahGCStatePropagator : public HandshakeClosure {
+class ShenandoahGCStatePropagatorHandshakeClosure : public HandshakeClosure {
 public:
-  explicit ShenandoahGCStatePropagator(char gc_state) :
+  explicit ShenandoahGCStatePropagatorHandshakeClosure(char gc_state) :
     HandshakeClosure("Shenandoah GC State Change"),
     _gc_state(gc_state) {}
 
@@ -1258,9 +1258,9 @@ class ShenandoahGCStatePropagator : public HandshakeClosure {
   char _gc_state;
 };
 
-class ShenandoahPrepareForUpdateRefs : public HandshakeClosure {
+class ShenandoahPrepareForUpdateRefsHandshakeClosure : public HandshakeClosure {
 public:
-  explicit ShenandoahPrepareForUpdateRefs(char gc_state) :
+  explicit ShenandoahPrepareForUpdateRefsHandshakeClosure(char gc_state) :
     HandshakeClosure("Shenandoah Prepare for Update Refs"),
     _retire(ResizeTLAB), _propagator(gc_state) {}
 
@@ -1272,7 +1272,7 @@ class ShenandoahPrepareForUpdateRefs : public HandshakeClosure {
   }
 private:
   ShenandoahRetireGCLABClosure _retire;
-  ShenandoahGCStatePropagator _propagator;
+  ShenandoahGCStatePropagatorHandshakeClosure _propagator;
 };
 
 void ShenandoahHeap::evacuate_collection_set(bool concurrent) {
@@ -1295,7 +1295,7 @@ void ShenandoahHeap::concurrent_prepare_for_update_refs() {
   }
 
   // This will propagate the gc state and retire gclabs and plabs for threads that require it.
-  ShenandoahPrepareForUpdateRefs prepare_for_update_refs(_gc_state.raw_value());
+  ShenandoahPrepareForUpdateRefsHandshakeClosure prepare_for_update_refs(_gc_state.raw_value());
 
   // The handshake won't touch worker threads (or control thread, or VM thread), so do those separately.
   Threads::non_java_threads_do(&prepare_for_update_refs);
@@ -1327,7 +1327,7 @@ void ShenandoahHeap::concurrent_final_roots(HandshakeClosure* handshake_closure)
     set_gc_state_concurrent(WEAK_ROOTS, false);
   }
 
-  ShenandoahGCStatePropagator propagator(_gc_state.raw_value());
+  ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value());
   Threads::non_java_threads_do(&propagator);
   if (handshake_closure == nullptr) {
     Handshake::execute(&propagator);
@@ -2020,14 +2020,14 @@ void ShenandoahHeap::parallel_heap_region_iterate(ShenandoahHeapRegionClosure* b
   }
 }
 
-class ShenandoahRendezvousClosure : public HandshakeClosure {
+class ShenandoahRendezvousHandshakeClosure : public HandshakeClosure {
 public:
-  inline ShenandoahRendezvousClosure(const char* name) : HandshakeClosure(name) {}
+  inline ShenandoahRendezvousHandshakeClosure(const char* name) : HandshakeClosure(name) {}
   inline void do_thread(Thread* thread) {}
 };
 
 void ShenandoahHeap::rendezvous_threads(const char* name) {
-  ShenandoahRendezvousClosure cl(name);
+  ShenandoahRendezvousHandshakeClosure cl(name);
   Handshake::execute(&cl);
 }
 
@@ -2069,7 +2069,7 @@ void ShenandoahHeap::prepare_update_heap_references() {
 void ShenandoahHeap::propagate_gc_state_to_all_threads() {
   assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at Shenandoah safepoint");
   if (_gc_state_changed) {
-    ShenandoahGCStatePropagator propagator(_gc_state.raw_value());
+    ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value());
     Threads::threads_do(&propagator);
     _gc_state_changed = false;
   }

src/hotspot/share/gc/z/zMark.cpp

@@ -532,13 +532,13 @@ bool ZMark::try_steal(ZMarkContext* context) {
   return try_steal_local(context) || try_steal_global(context);
 }
 
-class ZMarkFlushStacksClosure : public HandshakeClosure {
+class ZMarkFlushStacksHandshakeClosure : public HandshakeClosure {
 private:
   ZMark* const _mark;
   bool         _flushed;
 
 public:
-  ZMarkFlushStacksClosure(ZMark* mark)
+  ZMarkFlushStacksHandshakeClosure(ZMark* mark)
     : HandshakeClosure("ZMarkFlushStacks"),
       _mark(mark),
       _flushed(false) {}
@@ -585,7 +585,7 @@ class VM_ZMarkFlushOperation : public VM_Operation {
 };
 
 bool ZMark::flush() {
-  ZMarkFlushStacksClosure cl(this);
+  ZMarkFlushStacksHandshakeClosure cl(this);
   VM_ZMarkFlushOperation vm_cl(&cl);
   Handshake::execute(&cl);
   VMThread::execute(&vm_cl);
@@ -956,7 +956,7 @@ bool ZMark::try_end() {
   }
 
   // Try end marking
-  ZMarkFlushStacksClosure cl(this);
+  ZMarkFlushStacksHandshakeClosure cl(this);
   Threads::non_java_threads_do(&cl);
 
   // Check if non-java threads have any pending marking

src/hotspot/share/prims/scopedMemoryAccess.cpp

@@ -105,15 +105,15 @@ static frame get_last_frame(JavaThread* jt) {
   return last_frame;
 }
 
-class ScopedAsyncExceptionHandshake : public AsyncExceptionHandshake {
+class ScopedAsyncExceptionHandshakeClosure : public AsyncExceptionHandshakeClosure {
   OopHandle _session;
 
 public:
-  ScopedAsyncExceptionHandshake(OopHandle& session, OopHandle& error)
-    : AsyncExceptionHandshake(error),
+  ScopedAsyncExceptionHandshakeClosure(OopHandle& session, OopHandle& error)
+    : AsyncExceptionHandshakeClosure(error),
       _session(session) {}
 
-  ~ScopedAsyncExceptionHandshake() {
+  ~ScopedAsyncExceptionHandshakeClosure() {
     _session.release(Universe::vm_global());
   }
 
@@ -122,17 +122,17 @@ class ScopedAsyncExceptionHandshake : public AsyncExceptionHandshake {
     bool ignored;
     if (is_accessing_session(jt, _session.resolve(), ignored)) {
       // Throw exception to unwind out from the scoped access
-      AsyncExceptionHandshake::do_thread(thread);
+      AsyncExceptionHandshakeClosure::do_thread(thread);
     }
   }
 };
 
-class CloseScopedMemoryClosure : public HandshakeClosure {
+class CloseScopedMemoryHandshakeClosure : public HandshakeClosure {
   jobject _session;
   jobject _error;
 
 public:
-  CloseScopedMemoryClosure(jobject session, jobject error)
+  CloseScopedMemoryHandshakeClosure(jobject session, jobject error)
     : HandshakeClosure("CloseScopedMemory")
     , _session(session)
     , _error(error) {}
@@ -159,7 +159,7 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
       // the scoped access.
       OopHandle session(Universe::vm_global(), JNIHandles::resolve(_session));
       OopHandle error(Universe::vm_global(), JNIHandles::resolve(_error));
-      jt->install_async_exception(new ScopedAsyncExceptionHandshake(session, error));
+      jt->install_async_exception(new ScopedAsyncExceptionHandshakeClosure(session, error));
     } else if (!in_scoped) {
       frame last_frame = get_last_frame(jt);
       if (last_frame.is_compiled_frame() && last_frame.can_be_deoptimized()) {
@@ -213,7 +213,7 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
  * closed (deopt), this method returns false, signalling that the session cannot be closed safely.
  */
 JVM_ENTRY(void, ScopedMemoryAccess_closeScope(JNIEnv *env, jobject receiver, jobject session, jobject error))
-  CloseScopedMemoryClosure cl(session, error);
+  CloseScopedMemoryHandshakeClosure cl(session, error);
   Handshake::execute(&cl);
 JVM_END
 

src/hotspot/share/prims/whitebox.cpp

@@ -2246,7 +2246,7 @@ WB_END
 #endif // INCLUDE_CDS
 
 WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thread_handle))
-  class ReadMonitorsClosure : public HandshakeClosure {
+  class ReadMonitorsHandshakeClosure : public HandshakeClosure {
     jboolean _executed;
 
     void do_thread(Thread* th) {
@@ -2281,24 +2281,24 @@ WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thr
     }
 
    public:
-    ReadMonitorsClosure() : HandshakeClosure("WB_HandshakeReadMonitors"), _executed(false) {}
+    ReadMonitorsHandshakeClosure() : HandshakeClosure("WB_HandshakeReadMonitors"), _executed(false) {}
     jboolean executed() const { return _executed; }
   };
 
-  ReadMonitorsClosure rmc;
+  ReadMonitorsHandshakeClosure rmhc;
   if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      Handshake::execute(&rmc, &tlh, target);
+      Handshake::execute(&rmhc, &tlh, target);
     }
   }
-  return rmc.executed();
+  return rmhc.executed();
 WB_END
 
 WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle, jboolean all_threads))
-  class TraceSelfClosure : public HandshakeClosure {
+  class TraceSelfHandshakeClosure : public HandshakeClosure {
     jint _num_threads_completed;
 
     void do_thread(Thread* th) {
@@ -2312,27 +2312,27 @@ WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_han
     }
 
   public:
-    TraceSelfClosure(Thread* thread) : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {}
+    TraceSelfHandshakeClosure(Thread* thread) : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {}
 
     jint num_threads_completed() const { return _num_threads_completed; }
   };
-  TraceSelfClosure tsc(Thread::current());
+  TraceSelfHandshakeClosure tshc(Thread::current());
 
   if (all_threads) {
-    Handshake::execute(&tsc);
+    Handshake::execute(&tshc);
   } else if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      Handshake::execute(&tsc, &tlh, target);
+      Handshake::execute(&tshc, &tlh, target);
     }
   }
-  return tsc.num_threads_completed();
+  return tshc.num_threads_completed();
 WB_END
 
 WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle))
-  class TraceSelfClosure : public AsyncHandshakeClosure {
+  class TraceSelfHandshakeClosure : public AsyncHandshakeClosure {
     JavaThread* _self;
     void do_thread(Thread* th) {
       assert(th->is_Java_thread(), "sanity");
@@ -2347,15 +2347,15 @@ WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject threa
     }
 
   public:
-    TraceSelfClosure(JavaThread* self_target) : AsyncHandshakeClosure("WB_TraceSelf"), _self(self_target) {}
+    TraceSelfHandshakeClosure(JavaThread* self_target) : AsyncHandshakeClosure("WB_TraceSelf"), _self(self_target) {}
   };
   if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      TraceSelfClosure* tsc = new TraceSelfClosure(target);
-      Handshake::execute(tsc, target);
+      TraceSelfHandshakeClosure* tshc = new TraceSelfHandshakeClosure(target);
+      Handshake::execute(tshc, target);
     }
   }
 WB_END

src/hotspot/share/runtime/deoptimization.cpp

@@ -1049,9 +1049,9 @@ JRT_LEAF(BasicType, Deoptimization::unpack_frames(JavaThread* thread, int exec_m
   return bt;
 JRT_END
 
-class DeoptimizeMarkedClosure : public HandshakeClosure {
+class DeoptimizeMarkedHandshakeClosure : public HandshakeClosure {
  public:
-  DeoptimizeMarkedClosure() : HandshakeClosure("Deoptimize") {}
+  DeoptimizeMarkedHandshakeClosure() : HandshakeClosure("Deoptimize") {}
   void do_thread(Thread* thread) {
     JavaThread* jt = JavaThread::cast(thread);
     jt->deoptimize_marked_methods();
@@ -1064,7 +1064,7 @@ void Deoptimization::deoptimize_all_marked() {
   // Make the dependent methods not entrant
   CodeCache::make_marked_nmethods_deoptimized();
 
-  DeoptimizeMarkedClosure deopt;
+  DeoptimizeMarkedHandshakeClosure deopt;
   if (SafepointSynchronize::is_at_safepoint()) {
     Threads::java_threads_do(&deopt);
   } else {