src/hotspot/share/runtime/handshake.hpp

*** 1,7 ****
  /*
!  * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 28,44 ****
  #include "memory/allocation.hpp"
  #include "memory/iterator.hpp"
  #include "runtime/flags/flagSetting.hpp"
  #include "runtime/semaphore.hpp"
  
  class JavaThread;
  
  // A handshake closure is a callback that is executed for each JavaThread
  // while that thread is in a safepoint safe state. The callback is executed
! // either by the thread itself or by the VM thread while keeping the thread
! // in a blocked state. A handshake can be performed with a single
! // JavaThread as well.
  class HandshakeClosure : public ThreadClosure {
    const char* const _name;
   public:
    HandshakeClosure(const char* name) : _name(name) {}
    const char* name() const {
--- 28,48 ----
  #include "memory/allocation.hpp"
  #include "memory/iterator.hpp"
  #include "runtime/flags/flagSetting.hpp"
  #include "runtime/semaphore.hpp"
  
+ class HandshakeOperation;
  class JavaThread;
  
  // A handshake closure is a callback that is executed for each JavaThread
  // while that thread is in a safepoint safe state. The callback is executed
! // either by the target JavaThread itself or by the VMThread while keeping
! // the target thread in a blocked state. A handshake can be performed with a
! // single JavaThread as well. In that case, the callback is executed either
! // by the target JavaThread itself or, depending on whether the operation is
! // a direct handshake or not, by the JavaThread that requested the handshake
! // or the VMThread respectively.
  class HandshakeClosure : public ThreadClosure {
    const char* const _name;
   public:
    HandshakeClosure(const char* name) : _name(name) {}
    const char* name() const {
*** 50,100 ****
  class Handshake : public AllStatic {
   public:
    // Execution of handshake operation
    static void execute(HandshakeClosure* hs_cl);
    static bool execute(HandshakeClosure* hs_cl, JavaThread* target);
  };
  
! class HandshakeOperation;
! 
! // The HandshakeState keep tracks of an ongoing handshake for one JavaThread.
! // VM thread and JavaThread are serialized with the semaphore making sure
! // the operation is only done by either VM thread on behalf of the JavaThread
! // or the JavaThread itself.
  class HandshakeState {
    HandshakeOperation* volatile _operation;
  
!   Semaphore _semaphore;
    bool _thread_in_process_handshake;
  
!   bool claim_handshake_for_vmthread();
!   bool vmthread_can_process_handshake(JavaThread* target);
  
!   void clear_handshake(JavaThread* thread);
  
-   void process_self_inner(JavaThread* thread);
  public:
    HandshakeState();
  
!   void set_operation(JavaThread* thread, HandshakeOperation* op);
  
!   bool has_operation() const {
!     return _operation != NULL;
    }
  
!   void process_by_self(JavaThread* thread) {
      if (!_thread_in_process_handshake) {
        FlagSetting fs(_thread_in_process_handshake, true);
!       process_self_inner(thread);
      }
    }
! 
!   bool try_process_by_vmThread(JavaThread* target);
  
  #ifdef ASSERT
!   bool _vmthread_processing_handshake;
!   bool is_vmthread_processing_handshake() const { return _vmthread_processing_handshake; }
  #endif
  
  };
  
  #endif // SHARE_RUNTIME_HANDSHAKE_HPP
--- 54,108 ----
  class Handshake : public AllStatic {
   public:
    // Execution of handshake operation
    static void execute(HandshakeClosure* hs_cl);
    static bool execute(HandshakeClosure* hs_cl, JavaThread* target);
+   static bool execute_direct(HandshakeClosure* hs_cl, JavaThread* target);
  };
  
! // The HandshakeState keeps track of an ongoing handshake for this JavaThread.
! // VMThread/Handshaker and JavaThread are serialized with semaphore _processing_sem
! // making sure the operation is only done by either VMThread/Handshaker on behalf
! // of the JavaThread or by the target JavaThread itself.
  class HandshakeState {
+   JavaThread* _handshakee;
    HandshakeOperation* volatile _operation;
+   HandshakeOperation* volatile _operation_direct;
  
!   Semaphore _handshake_turn_sem;  // Used to serialize direct handshakes for this JavaThread.
!   Semaphore _processing_sem;
    bool _thread_in_process_handshake;
  
!   bool claim_handshake(bool is_direct);
!   bool possibly_can_process_handshake();
!   bool can_process_handshake();
!   void clear_handshake(bool is_direct);
    
!   void process_self_inner();
  
  public:
    HandshakeState();
  
!   void set_thread(JavaThread* thread) { _handshakee = thread; }
  
!   void set_operation(HandshakeOperation* op);
!   bool has_operation() const { return _operation != NULL || _operation_direct != NULL; }
!   bool has_specific_operation(bool is_direct) const {
!     return is_direct ? _operation_direct != NULL : _operation != NULL;
    }
  
!   void process_by_self() {
      if (!_thread_in_process_handshake) {
        FlagSetting fs(_thread_in_process_handshake, true);
!       process_self_inner();
      }
    }
!   bool try_process(HandshakeOperation* op);
  
  #ifdef ASSERT
!   Thread* _active_handshaker;
!   Thread* get_active_handshaker() const { return _active_handshaker; }
  #endif
  
  };
  
  #endif // SHARE_RUNTIME_HANDSHAKE_HPP