SWS start processing on handshaker

src/hotspot/share/runtime/handshake.cpp

@@ -47,19 +47,23 @@ class HandshakeOperation : public CHeapObj<mtThread> {
   // Once it reaches zero all handshake operations have been performed.
   int32_t             _pending_threads;
   JavaThread*         _target;
+  Thread*             _requester;
 
   // Must use AsyncHandshakeOperation when using AsyncHandshakeClosure.
-  HandshakeOperation(AsyncHandshakeClosure* cl, JavaThread* target) :
+  HandshakeOperation(AsyncHandshakeClosure* cl, JavaThread* target, Thread* requester) :
     _handshake_cl(cl),
     _pending_threads(1),
-    _target(target) {}
+    _target(target),
+    _requester(requester) {}
 
  public:
-  HandshakeOperation(HandshakeClosure* cl, JavaThread* target) :
+  HandshakeOperation(HandshakeClosure* cl, JavaThread* target, Thread* requester) :
     _handshake_cl(cl),
     _pending_threads(1),
-    _target(target) {}
+    _target(target),
+    _requester(requester) {}
   virtual ~HandshakeOperation() {}
+  void prepare(JavaThread* current_target, Thread* executioner);
   void do_handshake(JavaThread* thread);
   bool is_completed() {
     int32_t val = Atomic::load(&_pending_threads);
@@ -76,7 +80,7 @@ class AsyncHandshakeOperation : public HandshakeOperation {
   jlong _start_time_ns;
  public:
   AsyncHandshakeOperation(AsyncHandshakeClosure* cl, JavaThread* target, jlong start_ns)
-    : HandshakeOperation(cl, target), _start_time_ns(start_ns) {}
+    : HandshakeOperation(cl, target, NULL), _start_time_ns(start_ns) {}
   virtual ~AsyncHandshakeOperation() { delete _handshake_cl; }
   jlong start_time() const           { return _start_time_ns; }
 };
@@ -275,6 +279,19 @@ class VM_HandshakeAllThreads: public VM_Handshake {
   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 };
 
+void HandshakeOperation::prepare(JavaThread* current_target, Thread* executioner) {
+  if (current_target->is_terminated()) {
+    // Will never execute any handshakes on this thread.
+    return;
+  }
+  StackWatermarkSet::start_processing(current_target, StackWatermarkKind::gc);
+  if (_requester != NULL && _requester != executioner && _requester->is_Java_thread()) {
+    // The handshake closure may contains oop Handles from the _requester.
+    // We must make sure we can use them.
+    StackWatermarkSet::start_processing(_requester->as_Java_thread(), StackWatermarkKind::gc);
+  }
+}
+
 void HandshakeOperation::do_handshake(JavaThread* thread) {
   jlong start_time_ns = 0;
   if (log_is_enabled(Debug, handshake, task)) {
@@ -304,14 +321,14 @@ void HandshakeOperation::do_handshake(JavaThread* thread) {
 }
 
 void Handshake::execute(HandshakeClosure* hs_cl) {
-  HandshakeOperation cto(hs_cl, NULL);
+  HandshakeOperation cto(hs_cl, NULL, Thread::current());
   VM_HandshakeAllThreads handshake(&cto);
   VMThread::execute(&handshake);
 }
 
 void Handshake::execute(HandshakeClosure* hs_cl, JavaThread* target) {
   JavaThread* self = JavaThread::current();
-  HandshakeOperation op(hs_cl, target);
+  HandshakeOperation op(hs_cl, target, Thread::current());
 
   jlong start_time_ns = os::javaTimeNanos();
 
@@ -521,9 +538,7 @@ HandshakeState::ProcessResult HandshakeState::try_process(HandshakeOperation* ma
         pr_ret = HandshakeState::_succeeded;
       }
 
-      if (!_handshakee->is_terminated()) {
-        StackWatermarkSet::start_processing(_handshakee, StackWatermarkKind::gc);
-      }
+      op->prepare(_handshakee, current_thread);
 
       _active_handshaker = current_thread;
       op->do_handshake(_handshakee);