< prev index next >

src/hotspot/share/runtime/handshake.cpp

Print this page


   1 /*
   2  * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/log.hpp"
  27 #include "logging/logStream.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "runtime/atomic.hpp"
  30 #include "runtime/handshake.hpp"
  31 #include "runtime/interfaceSupport.inline.hpp"
  32 #include "runtime/osThread.hpp"
  33 #include "runtime/semaphore.inline.hpp"
  34 #include "runtime/task.hpp"
  35 #include "runtime/thread.hpp"
  36 #include "runtime/vmThread.hpp"
  37 #include "utilities/formatBuffer.hpp"
  38 #include "utilities/preserveException.hpp"
  39 
  40 
  41 class HandshakeOperation: public StackObj {






  42   HandshakeClosure* _handshake_cl;
  43   int32_t _pending_threads;
  44   bool _executed;
  45   bool _is_direct;
  46 public:
  47   HandshakeOperation(HandshakeClosure* cl, bool is_direct = false) :
  48     _handshake_cl(cl),
  49     _pending_threads(1),
  50     _executed(false),
  51     _is_direct(is_direct) {}
  52 
  53   void do_handshake(JavaThread* thread);
  54   bool is_completed() {
  55     int64_t val = Atomic::load(&_pending_threads);
  56     assert(val >= 0, "_pending_threads cannot be negative");
  57     return val == 0;
  58   }
  59   void add_target_count(int count) { Atomic::add(&_pending_threads, count); }
  60   bool executed() const { return _executed; }
  61   const char* name() { return _handshake_cl->name(); }
  62 
  63   bool is_direct() { return _is_direct; }
  64 
  65 #ifdef ASSERT
  66   void check_state() {
  67     assert(_pending_threads == 0, "Must be zero");
  68   }
  69 #endif
  70 };
  71 


  72 class VM_Handshake: public VM_Operation {
  73   const jlong _handshake_timeout;
  74  public:
  75   bool evaluate_at_safepoint() const { return false; }
  76 
  77  protected:
  78   HandshakeOperation* const _op;
  79 
  80   VM_Handshake(HandshakeOperation* op) :
  81       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
  82 









  83   bool handshake_has_timed_out(jlong start_time);
  84   static void handle_timeout();
  85 };
  86 
  87 bool VM_Handshake::handshake_has_timed_out(jlong start_time) {
  88   // Check if handshake operation has timed out
  89   if (_handshake_timeout > 0) {
  90     return os::elapsed_counter() >= (start_time + _handshake_timeout);
  91   }
  92   return false;
  93 }
  94 
  95 void VM_Handshake::handle_timeout() {
  96   LogStreamHandle(Warning, handshake) log_stream;
  97   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
  98     if (thr->has_handshake()) {
  99       log_stream.print("Thread " PTR_FORMAT " has not cleared its handshake op", p2i(thr));
 100       thr->print_thread_state_on(&log_stream);
 101     }
 102   }
 103   log_stream.flush();
 104   fatal("Handshake operation timed out");
 105 }
 106 
 107 static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int vmt_executed, const char* extra = NULL) {
 108   if (start_time_ns != 0) {
 109     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 110     log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by targeted threads: %d, Total completion time: " JLONG_FORMAT " ns%s%s",
 111                         name, targets,
 112                         targets - vmt_executed,
 113                         completion_time,
 114                         extra != NULL ? ", " : "",
 115                         extra != NULL ? extra : "");
 116   }
 117 }
 118 
 119 class VM_HandshakeOneThread: public VM_Handshake {
 120   JavaThread* _target;
 121  public:
 122   VM_HandshakeOneThread(HandshakeOperation* op, JavaThread* target) :
 123     VM_Handshake(op), _target(target) {}
 124 
 125   void doit() {


 126     jlong start_time_ns = 0;
 127     if (log_is_enabled(Info, handshake)) {
 128       start_time_ns = os::javaTimeNanos();
 129     }
 130 
 131     ThreadsListHandle tlh;
 132     if (tlh.includes(_target)) {
 133       _target->set_handshake_operation(_op);
 134     } else {
 135       log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
 136       return;
 137     }
 138 
 139     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
 140     jlong timeout_start_time = os::elapsed_counter();
 141     bool by_vm_thread = false;
 142     do {
 143       if (handshake_has_timed_out(timeout_start_time)) {
 144         handle_timeout();
 145       }
 146       by_vm_thread = _target->handshake_try_process(_op);
 147     } while (!_op->is_completed());
 148     DEBUG_ONLY(_op->check_state();)
 149     log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
 150   }
 151 
 152   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
 153 
 154   bool executed() const { return _op->executed(); }
 155 };
 156 
 157 class VM_HandshakeAllThreads: public VM_Handshake {
 158  public:
 159   VM_HandshakeAllThreads(HandshakeOperation* op) : VM_Handshake(op) {}
 160 
 161   void doit() {


 162     jlong start_time_ns = 0;
 163     if (log_is_enabled(Info, handshake)) {
 164       start_time_ns = os::javaTimeNanos();
 165     }
 166     int handshake_executed_by_vm_thread = 0;
 167 
 168     JavaThreadIteratorWithHandle jtiwh;
 169     int number_of_threads_issued = 0;
 170     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 171       thr->set_handshake_operation(_op);
 172       number_of_threads_issued++;
 173     }
 174 
 175     if (number_of_threads_issued < 1) {
 176       log_handshake_info(start_time_ns, _op->name(), 0, 0);
 177       return;
 178     }
 179     // _op was created with a count == 1 so don't double count.
 180     _op->add_target_count(number_of_threads_issued - 1);
 181 
 182     log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
 183     const jlong start_time = os::elapsed_counter();

 184     do {
 185       // Check if handshake operation has timed out
 186       if (handshake_has_timed_out(start_time)) {
 187         handle_timeout();
 188       }
 189 
 190       // Have VM thread perform the handshake operation for blocked threads.
 191       // Observing a blocked state may of course be transient but the processing is guarded
 192       // by semaphores and we optimistically begin by working on the blocked threads
 193       jtiwh.rewind();
 194       for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 195         // A new thread on the ThreadsList will not have an operation,
 196         // hence it is skipped in handshake_try_process.
 197         if (thr->handshake_try_process(_op)) {
 198           handshake_executed_by_vm_thread++;
 199         }
 200       }
 201     } while (!_op->is_completed());






 202     DEBUG_ONLY(_op->check_state();)
 203 
 204     log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
 205   }
 206 
 207   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 208 };
 209 
 210 class VM_HandshakeFallbackOperation : public VM_Operation {
 211   HandshakeClosure* _handshake_cl;
 212   Thread* _target_thread;
 213   bool _all_threads;
 214   bool _executed;
 215 public:
 216   VM_HandshakeFallbackOperation(HandshakeClosure* cl) :
 217       _handshake_cl(cl), _target_thread(NULL), _all_threads(true), _executed(false) {}
 218   VM_HandshakeFallbackOperation(HandshakeClosure* cl, Thread* target) :
 219       _handshake_cl(cl), _target_thread(target), _all_threads(false), _executed(false) {}
 220 
 221   void doit() {
 222     log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation, operation: %s", name());
 223     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 224       if (_all_threads || t == _target_thread) {
 225         if (t == _target_thread) {
 226           _executed = true;
 227         }
 228         _handshake_cl->do_thread(t);
 229       }
 230     }
 231   }
 232 
 233   VMOp_Type type() const { return VMOp_HandshakeFallback; }
 234   bool executed() const { return _executed; }
 235 };
 236 
 237 void HandshakeOperation::do_handshake(JavaThread* thread) {
 238   jlong start_time_ns = 0;
 239   if (log_is_enabled(Debug, handshake, task)) {
 240     start_time_ns = os::javaTimeNanos();
 241   }
 242 
 243   // Only actually execute the operation for non terminated threads.
 244   if (!thread->is_terminated()) {
 245     _handshake_cl->do_thread(thread);
 246     _executed = true;
 247   }
 248 
 249   if (start_time_ns != 0) {
 250     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 251     log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns",
 252                                name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
 253   }
 254 
 255   // Inform VMThread/Handshaker that we have completed the operation
 256   Atomic::dec(&_pending_threads);
 257 
 258   // It is no longer safe to refer to 'this' as the VMThread/Handshaker may have destroyed this operation
 259 }
 260 
 261 void Handshake::execute(HandshakeClosure* thread_cl) {
 262   if (SafepointMechanism::uses_thread_local_poll()) {
 263     HandshakeOperation ho(thread_cl);
 264     VM_HandshakeAllThreads handshake(&ho);
 265     VMThread::execute(&handshake);
 266   } else {
 267     VM_HandshakeFallbackOperation op(thread_cl);
 268     VMThread::execute(&op);
 269   }
 270 }
 271 
 272 bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
 273   if (SafepointMechanism::uses_thread_local_poll()) {
 274     HandshakeOperation ho(thread_cl);
 275     VM_HandshakeOneThread handshake(&ho, target);
 276     VMThread::execute(&handshake);
 277     return handshake.executed();
 278   } else {
 279     VM_HandshakeFallbackOperation op(thread_cl, target);
 280     VMThread::execute(&op);
 281     return op.executed();
 282   }
 283 }
 284 
 285 bool Handshake::execute_direct(HandshakeClosure* thread_cl, JavaThread* target) {
 286   if (!SafepointMechanism::uses_thread_local_poll()) {
 287     VM_HandshakeFallbackOperation op(thread_cl, target);
 288     VMThread::execute(&op);
 289     return op.executed();
 290   }
 291   JavaThread* self = JavaThread::current();
 292   HandshakeOperation op(thread_cl, /*is_direct*/ true);
 293 
 294   jlong start_time_ns = 0;
 295   if (log_is_enabled(Info, handshake)) {
 296     start_time_ns = os::javaTimeNanos();
 297   }
 298 
 299   ThreadsListHandle tlh;
 300   if (tlh.includes(target)) {
 301     target->set_handshake_operation(&op);
 302   } else {
 303     log_handshake_info(start_time_ns, op.name(), 0, 0, "(thread dead)");
 304     return false;
 305   }
 306 
 307   bool by_handshaker = false;
 308   while (!op.is_completed()) {
 309     by_handshaker = target->handshake_try_process(&op);
 310     // Check for pending handshakes to avoid possible deadlocks where our
 311     // target is trying to handshake us.
 312     if (SafepointMechanism::should_block(self)) {
 313       ThreadBlockInVM tbivm(self);
 314     }
 315   }
 316   DEBUG_ONLY(op.check_state();)
 317   log_handshake_info(start_time_ns, op.name(), 1, by_handshaker ? 1 : 0);
 318 
 319   return op.executed();
 320 }
 321 
 322 HandshakeState::HandshakeState() :
 323   _operation(NULL),
 324   _operation_direct(NULL),
 325   _handshake_turn_sem(1),
 326   _processing_sem(1),
 327   _thread_in_process_handshake(false)
 328 {
 329   DEBUG_ONLY(_active_handshaker = NULL;)
 330 }
 331 
 332 void HandshakeState::set_operation(HandshakeOperation* op) {
 333   if (!op->is_direct()) {
 334     assert(Thread::current()->is_VM_thread(), "should be the VMThread");
 335     _operation = op;
 336   } else {
 337     assert(Thread::current()->is_Java_thread(), "should be a JavaThread");
 338     // Serialize direct handshakes so that only one proceeds at a time for a given target
 339     _handshake_turn_sem.wait_with_safepoint_check(JavaThread::current());
 340     _operation_direct = op;
 341   }
 342   SafepointMechanism::arm_local_poll_release(_handshakee);
 343 }
 344 
 345 void HandshakeState::clear_handshake(bool is_direct) {
 346   if (!is_direct) {
 347     _operation = NULL;
 348   } else {
 349     _operation_direct = NULL;
 350     _handshake_turn_sem.signal();
 351   }
 352 }
 353 
 354 void HandshakeState::process_self_inner() {
 355   assert(Thread::current() == _handshakee, "should call from _handshakee");
 356   assert(!_handshakee->is_terminated(), "should not be a terminated thread");
 357   assert(_handshakee->thread_state() != _thread_blocked, "should not be in a blocked state");
 358   assert(_handshakee->thread_state() != _thread_in_native, "should not be in native");
 359   JavaThread* self = _handshakee;
 360 
 361   do {
 362     ThreadInVMForHandshake tivm(self);
 363     if (!_processing_sem.trywait()) {
 364       _processing_sem.wait_with_safepoint_check(self);
 365     }
 366     if (has_operation()) {
 367       HandleMark hm(self);
 368       CautiouslyPreserveExceptionMark pem(self);
 369       HandshakeOperation * op = _operation;
 370       if (op != NULL) {
 371         // Disarm before executing the operation
 372         clear_handshake(/*is_direct*/ false);
 373         op->do_handshake(self);
 374       }
 375       op = _operation_direct;
 376       if (op != NULL) {
 377         // Disarm before executing the operation
 378         clear_handshake(/*is_direct*/ true);
 379         op->do_handshake(self);
 380       }

 381     }
 382     _processing_sem.signal();
 383   } while (has_operation());
 384 }
 385 
 386 bool HandshakeState::can_process_handshake() {
 387   // handshake_safe may only be called with polls armed.
 388   // Handshaker controls this by first claiming the handshake via claim_handshake().
 389   return SafepointSynchronize::handshake_safe(_handshakee);
 390 }
 391 
 392 bool HandshakeState::possibly_can_process_handshake() {
 393   // Note that this method is allowed to produce false positives.
 394   if (_handshakee->is_ext_suspended()) {
 395     return true;
 396   }
 397   if (_handshakee->is_terminated()) {
 398     return true;
 399   }
 400   switch (_handshakee->thread_state()) {
 401   case _thread_in_native:
 402     // native threads are safe if they have no java stack or have walkable stack
 403     return !_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable();
 404 
 405   case _thread_blocked:
 406     return true;
 407 
 408   default:
 409     return false;
 410   }
 411 }
 412 
 413 bool HandshakeState::claim_handshake(bool is_direct) {
 414   if (!_processing_sem.trywait()) {
 415     return false;
 416   }
 417   if (has_specific_operation(is_direct)){
 418     return true;
 419   }
 420   _processing_sem.signal();
 421   return false;
 422 }
 423 
 424 bool HandshakeState::try_process(HandshakeOperation* op) {
 425   bool is_direct = op->is_direct();
 426 
 427   if (!has_specific_operation(is_direct)){
 428     // JT has already cleared its handshake
 429     return false;
 430   }
 431 
 432   if (!possibly_can_process_handshake()) {
 433     // JT is observed in an unsafe state, it must notice the handshake itself
 434     return false;
 435   }
 436 
 437   // Claim the semaphore if there still an operation to be executed.
 438   if (!claim_handshake(is_direct)) {
 439     return false;
 440   }
 441 
 442   // Check if the handshake operation is the same as the one we meant to execute. The
 443   // handshake could have been already processed by the handshakee and a new handshake
 444   // by another JavaThread might be in progress.
 445   if ( (is_direct && op != _operation_direct)) {
 446     _processing_sem.signal();
 447     return false;
 448   }
 449 
 450   // If we own the semaphore at this point and while owning the semaphore
 451   // can observe a safe state the thread cannot possibly continue without
 452   // getting caught by the semaphore.
 453   bool executed = false;
 454   if (can_process_handshake()) {
 455     guarantee(!_processing_sem.trywait(), "we should already own the semaphore");
 456     log_trace(handshake)("Processing handshake by %s", Thread::current()->is_VM_thread() ? "VMThread" : "Handshaker");
 457     DEBUG_ONLY(_active_handshaker = Thread::current();)
 458     op->do_handshake(_handshakee);
 459     DEBUG_ONLY(_active_handshaker = NULL;)
 460     // Disarm after we have executed the operation.
 461     clear_handshake(is_direct);
 462     executed = true;
 463   }
 464 
 465   // Release the thread
 466   _processing_sem.signal();
 467 
 468   return executed;
 469 }
   1 /*
   2  * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/log.hpp"
  27 #include "logging/logStream.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "runtime/atomic.hpp"
  30 #include "runtime/handshake.hpp"
  31 #include "runtime/interfaceSupport.inline.hpp"
  32 #include "runtime/osThread.hpp"
  33 #include "runtime/semaphore.inline.hpp"
  34 #include "runtime/task.hpp"
  35 #include "runtime/thread.hpp"
  36 #include "runtime/vmThread.hpp"
  37 #include "utilities/formatBuffer.hpp"
  38 #include "utilities/preserveException.hpp"
  39 

  40 class HandshakeOperation: public StackObj {
  41 public:
  42   virtual void do_handshake(JavaThread* thread) = 0;
  43 };
  44 
  45 class HandshakeThreadsOperation: public HandshakeOperation {
  46   static Semaphore _done;
  47   HandshakeClosure* _handshake_cl;

  48   bool _executed;

  49 public:
  50   HandshakeThreadsOperation(HandshakeClosure* cl) : _handshake_cl(cl), _executed(false) {}





  51   void do_handshake(JavaThread* thread);
  52   bool thread_has_completed() { return _done.trywait(); }





  53   bool executed() const { return _executed; }
  54   const char* name() { return _handshake_cl->name(); }
  55 


  56 #ifdef ASSERT
  57   void check_state() {
  58     assert(!_done.trywait(), "Must be zero");
  59   }
  60 #endif
  61 };
  62 
  63 Semaphore HandshakeThreadsOperation::_done(0);
  64 
  65 class VM_Handshake: public VM_Operation {
  66   const jlong _handshake_timeout;
  67  public:
  68   bool evaluate_at_safepoint() const { return false; }
  69 
  70  protected:
  71   HandshakeThreadsOperation* const _op;
  72 
  73   VM_Handshake(HandshakeThreadsOperation* op) :
  74       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
  75 
  76   void set_handshake(JavaThread* target) {
  77     target->set_handshake_operation(_op);
  78   }
  79 
  80   // This method returns true for threads completed their operation
  81   // and true for threads canceled their operation.
  82   // A cancellation can happen if the thread is exiting.
  83   bool poll_for_completed_thread() { return _op->thread_has_completed(); }
  84 
  85   bool handshake_has_timed_out(jlong start_time);
  86   static void handle_timeout();
  87 };
  88 
  89 bool VM_Handshake::handshake_has_timed_out(jlong start_time) {
  90   // Check if handshake operation has timed out
  91   if (_handshake_timeout > 0) {
  92     return os::elapsed_counter() >= (start_time + _handshake_timeout);
  93   }
  94   return false;
  95 }
  96 
  97 void VM_Handshake::handle_timeout() {
  98   LogStreamHandle(Warning, handshake) log_stream;
  99   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
 100     if (thr->has_handshake()) {
 101       log_stream.print("Thread " PTR_FORMAT " has not cleared its handshake op", p2i(thr));
 102       thr->print_thread_state_on(&log_stream);
 103     }
 104   }
 105   log_stream.flush();
 106   fatal("Handshake operation timed out");
 107 }
 108 
 109 static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int vmt_executed, const char* extra = NULL) {
 110   if (start_time_ns != 0) {
 111     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 112     log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by targeted threads: %d, Total completion time: " JLONG_FORMAT " ns%s%s",
 113                         name, targets,
 114                         targets - vmt_executed,
 115                         completion_time,
 116                         extra != NULL ? ", " : "",
 117                         extra != NULL ? extra : "");
 118   }
 119 }
 120 
 121 class VM_HandshakeOneThread: public VM_Handshake {
 122   JavaThread* _target;
 123  public:
 124   VM_HandshakeOneThread(HandshakeThreadsOperation* op, JavaThread* target) :
 125     VM_Handshake(op), _target(target) {}
 126 
 127   void doit() {
 128     DEBUG_ONLY(_op->check_state();)
 129 
 130     jlong start_time_ns = 0;
 131     if (log_is_enabled(Info, handshake)) {
 132       start_time_ns = os::javaTimeNanos();
 133     }
 134 
 135     ThreadsListHandle tlh;
 136     if (tlh.includes(_target)) {
 137       set_handshake(_target);
 138     } else {
 139       log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
 140       return;
 141     }
 142 
 143     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
 144     jlong timeout_start_time = os::elapsed_counter();
 145     bool by_vm_thread = false;
 146     do {
 147       if (handshake_has_timed_out(timeout_start_time)) {
 148         handle_timeout();
 149       }
 150       by_vm_thread = _target->handshake_try_process_by_vmThread();
 151     } while (!poll_for_completed_thread());
 152     DEBUG_ONLY(_op->check_state();)
 153     log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
 154   }
 155 
 156   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
 157 
 158   bool executed() const { return _op->executed(); }
 159 };
 160 
 161 class VM_HandshakeAllThreads: public VM_Handshake {
 162  public:
 163   VM_HandshakeAllThreads(HandshakeThreadsOperation* op) : VM_Handshake(op) {}
 164 
 165   void doit() {
 166     DEBUG_ONLY(_op->check_state();)
 167 
 168     jlong start_time_ns = 0;
 169     if (log_is_enabled(Info, handshake)) {
 170       start_time_ns = os::javaTimeNanos();
 171     }
 172     int handshake_executed_by_vm_thread = 0;
 173 
 174     JavaThreadIteratorWithHandle jtiwh;
 175     int number_of_threads_issued = 0;
 176     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 177       set_handshake(thr);
 178       number_of_threads_issued++;
 179     }
 180 
 181     if (number_of_threads_issued < 1) {
 182       log_handshake_info(start_time_ns, _op->name(), 0, 0);
 183       return;
 184     }


 185 
 186     log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
 187     const jlong start_time = os::elapsed_counter();
 188     int number_of_threads_completed = 0;
 189     do {
 190       // Check if handshake operation has timed out
 191       if (handshake_has_timed_out(start_time)) {
 192         handle_timeout();
 193       }
 194 
 195       // Have VM thread perform the handshake operation for blocked threads.
 196       // Observing a blocked state may of course be transient but the processing is guarded
 197       // by semaphores and we optimistically begin by working on the blocked threads
 198       jtiwh.rewind();
 199       for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 200         // A new thread on the ThreadsList will not have an operation,
 201         // hence it is skipped in handshake_process_by_vmthread.
 202         if (thr->handshake_try_process_by_vmThread()) {
 203           handshake_executed_by_vm_thread++;
 204         }
 205       }
 206       while (poll_for_completed_thread()) {
 207         // Includes canceled operations by exiting threads.
 208         number_of_threads_completed++;
 209       }
 210 
 211     } while (number_of_threads_issued > number_of_threads_completed);
 212     assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
 213     DEBUG_ONLY(_op->check_state();)
 214 
 215     log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
 216   }
 217 
 218   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 219 };
 220 
 221 class VM_HandshakeFallbackOperation : public VM_Operation {
 222   HandshakeClosure* _handshake_cl;
 223   Thread* _target_thread;
 224   bool _all_threads;
 225   bool _executed;
 226 public:
 227   VM_HandshakeFallbackOperation(HandshakeClosure* cl) :
 228       _handshake_cl(cl), _target_thread(NULL), _all_threads(true), _executed(false) {}
 229   VM_HandshakeFallbackOperation(HandshakeClosure* cl, Thread* target) :
 230       _handshake_cl(cl), _target_thread(target), _all_threads(false), _executed(false) {}
 231 
 232   void doit() {
 233     log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation, operation: %s", name());
 234     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 235       if (_all_threads || t == _target_thread) {
 236         if (t == _target_thread) {
 237           _executed = true;
 238         }
 239         _handshake_cl->do_thread(t);
 240       }
 241     }
 242   }
 243 
 244   VMOp_Type type() const { return VMOp_HandshakeFallback; }
 245   bool executed() const { return _executed; }
 246 };
 247 
 248 void HandshakeThreadsOperation::do_handshake(JavaThread* thread) {
 249   jlong start_time_ns = 0;
 250   if (log_is_enabled(Debug, handshake, task)) {
 251     start_time_ns = os::javaTimeNanos();
 252   }
 253 
 254   // Only actually execute the operation for non terminated threads.
 255   if (!thread->is_terminated()) {
 256     _handshake_cl->do_thread(thread);
 257     _executed = true;
 258   }
 259 
 260   if (start_time_ns != 0) {
 261     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 262     log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns",
 263                                name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
 264   }
 265 
 266   // Use the semaphore to inform the VM thread that we have completed the operation
 267   _done.signal();
 268 
 269   // It is no longer safe to refer to 'this' as the VMThread may have destroyed this operation
 270 }
 271 
 272 void Handshake::execute(HandshakeClosure* thread_cl) {
 273   if (SafepointMechanism::uses_thread_local_poll()) {
 274     HandshakeThreadsOperation cto(thread_cl);
 275     VM_HandshakeAllThreads handshake(&cto);
 276     VMThread::execute(&handshake);
 277   } else {
 278     VM_HandshakeFallbackOperation op(thread_cl);
 279     VMThread::execute(&op);
 280   }
 281 }
 282 
 283 bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
 284   if (SafepointMechanism::uses_thread_local_poll()) {
 285     HandshakeThreadsOperation cto(thread_cl);
 286     VM_HandshakeOneThread handshake(&cto, target);
 287     VMThread::execute(&handshake);
 288     return handshake.executed();
 289   } else {
 290     VM_HandshakeFallbackOperation op(thread_cl, target);
 291     VMThread::execute(&op);
 292     return op.executed();
 293   }
 294 }
 295 
 296 HandshakeState::HandshakeState() : _operation(NULL), _semaphore(1), _thread_in_process_handshake(false) {
 297   DEBUG_ONLY(_vmthread_processing_handshake = false;)











































 298 }
 299 
 300 void HandshakeState::set_operation(JavaThread* target, HandshakeOperation* op) {


 301   _operation = op;
 302   SafepointMechanism::arm_local_poll_release(target);






 303 }
 304 
 305 void HandshakeState::clear_handshake(JavaThread* target) {

 306   _operation = NULL;
 307   SafepointMechanism::disarm_if_needed(target, true /* release */);



 308 }
 309 
 310 void HandshakeState::process_self_inner(JavaThread* thread) {
 311   assert(Thread::current() == thread, "should call from thread");
 312   assert(!thread->is_terminated(), "should not be a terminated thread");
 313   assert(thread->thread_state() != _thread_blocked, "should not be in a blocked state");
 314   assert(thread->thread_state() != _thread_in_native, "should not be in native");

 315 
 316   do {
 317     ThreadInVMForHandshake tivm(thread);
 318     if (!_semaphore.trywait()) {
 319       _semaphore.wait_with_safepoint_check(thread);









 320     }
 321     HandshakeOperation* op = Atomic::load_acquire(&_operation);
 322     if (op != NULL) {
 323       HandleMark hm(thread);
 324       CautiouslyPreserveExceptionMark pem(thread);
 325       // Disarm before execute the operation
 326       clear_handshake(thread);
 327       op->do_handshake(thread);
 328     }
 329     _semaphore.signal();
 330   } while (has_operation());
 331 }
 332 
 333 bool HandshakeState::vmthread_can_process_handshake(JavaThread* target) {
 334   // handshake_safe may only be called with polls armed.
 335   // VM thread controls this by first claiming the handshake via claim_handshake_for_vmthread.
 336   return SafepointSynchronize::handshake_safe(target);
 337 }
 338 
 339 static bool possibly_vmthread_can_process_handshake(JavaThread* target) {
 340   // Note that this method is allowed to produce false positives.
 341   if (target->is_ext_suspended()) {
 342     return true;
 343   }
 344   if (target->is_terminated()) {
 345     return true;
 346   }
 347   switch (target->thread_state()) {
 348   case _thread_in_native:
 349     // native threads are safe if they have no java stack or have walkable stack
 350     return !target->has_last_Java_frame() || target->frame_anchor()->walkable();
 351 
 352   case _thread_blocked:
 353     return true;
 354 
 355   default:
 356     return false;
 357   }
 358 }
 359 
 360 bool HandshakeState::claim_handshake_for_vmthread() {
 361   if (!_semaphore.trywait()) {
 362     return false;
 363   }
 364   if (has_operation()) {
 365     return true;
 366   }
 367   _semaphore.signal();
 368   return false;
 369 }
 370 
 371 bool HandshakeState::try_process_by_vmThread(JavaThread* target) {
 372   assert(Thread::current()->is_VM_thread(), "should call from vm thread");
 373 
 374   if (!has_operation()) {
 375     // JT has already cleared its handshake
 376     return false;
 377   }
 378 
 379   if (!possibly_vmthread_can_process_handshake(target)) {
 380     // JT is observed in an unsafe state, it must notice the handshake itself
 381     return false;
 382   }
 383 
 384   // Claim the semaphore if there still an operation to be executed.
 385   if (!claim_handshake_for_vmthread()) {








 386     return false;
 387   }
 388 
 389   // If we own the semaphore at this point and while owning the semaphore
 390   // can observe a safe state the thread cannot possibly continue without
 391   // getting caught by the semaphore.
 392   bool executed = false;
 393   if (vmthread_can_process_handshake(target)) {
 394     guarantee(!_semaphore.trywait(), "we should already own the semaphore");
 395     log_trace(handshake)("Processing handshake by VMThtread");
 396     DEBUG_ONLY(_vmthread_processing_handshake = true;)
 397     _operation->do_handshake(target);
 398     DEBUG_ONLY(_vmthread_processing_handshake = false;)
 399     // Disarm after VM thread have executed the operation.
 400     clear_handshake(target);
 401     executed = true;
 402   }
 403 
 404   // Release the thread
 405   _semaphore.signal();
 406 
 407   return executed;
 408 }
< prev index next >