1 /*

     2  * Copyright (c) 1997, 2017, 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 "classfile/stringTable.hpp"

    27 #include "classfile/symbolTable.hpp"

    28 #include "classfile/systemDictionary.hpp"

    29 #include "code/codeCache.hpp"

    30 #include "code/icBuffer.hpp"

    31 #include "code/nmethod.hpp"

    32 #include "code/pcDesc.hpp"

    33 #include "code/scopeDesc.hpp"

    34 #include "gc/shared/collectedHeap.hpp"

    35 #include "gc/shared/gcLocker.inline.hpp"

    36 #include "gc/shared/strongRootsScope.hpp"

    37 #include "gc/shared/workgroup.hpp"

    38 #include "interpreter/interpreter.hpp"

    39 #include "logging/log.hpp"

    40 #include "logging/logStream.hpp"

    41 #include "memory/resourceArea.hpp"

    42 #include "memory/universe.inline.hpp"

    43 #include "oops/oop.inline.hpp"

    44 #include "oops/symbol.hpp"

    45 #include "runtime/atomic.hpp"

    46 #include "runtime/compilationPolicy.hpp"

    47 #include "runtime/deoptimization.hpp"

    48 #include "runtime/frame.inline.hpp"

    49 #include "runtime/interfaceSupport.hpp"

    50 #include "runtime/mutexLocker.hpp"

    51 #include "runtime/orderAccess.inline.hpp"

    52 #include "runtime/osThread.hpp"

    53 #include "runtime/safepoint.hpp"

    54 #include "runtime/signature.hpp"

    55 #include "runtime/stubCodeGenerator.hpp"

    56 #include "runtime/stubRoutines.hpp"

    57 #include "runtime/sweeper.hpp"

    58 #include "runtime/synchronizer.hpp"

    59 #include "runtime/thread.inline.hpp"

    60 #include "runtime/timerTrace.hpp"

    61 #include "services/runtimeService.hpp"

    62 #include "trace/tracing.hpp"

    63 #include "trace/traceMacros.hpp"

    64 #include "utilities/events.hpp"

    65 #include "utilities/macros.hpp"

    66 #if INCLUDE_ALL_GCS

    67 #include "gc/cms/concurrentMarkSweepThread.hpp"

    68 #include "gc/g1/suspendibleThreadSet.hpp"

    69 #endif // INCLUDE_ALL_GCS

    70 #ifdef COMPILER1

    71 #include "c1/c1_globals.hpp"

    72 #endif

    73 

    74 // --------------------------------------------------------------------------------------------------

    75 // Implementation of Safepoint begin/end

    76 

    77 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;

    78 volatile int  SafepointSynchronize::_waiting_to_block = 0;

    79 volatile int SafepointSynchronize::_safepoint_counter = 0;

    80 int SafepointSynchronize::_current_jni_active_count = 0;

    81 long  SafepointSynchronize::_end_of_last_safepoint = 0;

    82 static volatile int PageArmed = 0 ;        // safepoint polling page is RO|RW vs PROT_NONE

    83 static volatile int TryingToBlock = 0 ;    // proximate value -- for advisory use only

    84 static bool timeout_error_printed = false;

    85 

    86 // Roll all threads forward to a safepoint and suspend them all

    87 void SafepointSynchronize::begin() {

    88   EventSafepointBegin begin_event;

    89   Thread* myThread = Thread::current();

    90   assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint");

    91 

    92   if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {

    93     _safepoint_begin_time = os::javaTimeNanos();

    94     _ts_of_current_safepoint = tty->time_stamp().seconds();

    95   }

    96 

    97 #if INCLUDE_ALL_GCS

    98   if (UseConcMarkSweepGC) {

    99     // In the future we should investigate whether CMS can use the

   100     // more-general mechanism below.  DLD (01/05).

   101     ConcurrentMarkSweepThread::synchronize(false);

   102   } else if (UseG1GC) {

   103     SuspendibleThreadSet::synchronize();

   104   }

   105 #endif // INCLUDE_ALL_GCS

   106 

   107   // By getting the Threads_lock, we assure that no threads are about to start or

   108   // exit. It is released again in SafepointSynchronize::end().

   109   Threads_lock->lock();

   110 

   111   assert( _state == _not_synchronized, "trying to safepoint synchronize with wrong state");

   112 

   113   int nof_threads = Threads::number_of_threads();

   114 

   115   log_debug(safepoint)("Safepoint synchronization initiated. (%d)", nof_threads);

   116 

   117   RuntimeService::record_safepoint_begin();

   118 

   119   MutexLocker mu(Safepoint_lock);

   120 

   121   // Reset the count of active JNI critical threads

   122   _current_jni_active_count = 0;

   123 

   124   // Set number of threads to wait for, before we initiate the callbacks

   125   _waiting_to_block = nof_threads;

   126   TryingToBlock     = 0 ;

   127   int still_running = nof_threads;

   128 

   129   // Save the starting time, so that it can be compared to see if this has taken

   130   // too long to complete.

   131   jlong safepoint_limit_time = 0;

   132   timeout_error_printed = false;

   133 

   134   // PrintSafepointStatisticsTimeout can be specified separately. When

   135   // specified, PrintSafepointStatistics will be set to true in

   136   // deferred_initialize_stat method. The initialization has to be done

   137   // early enough to avoid any races. See bug 6880029 for details.

   138   if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {

   139     deferred_initialize_stat();

   140   }

   141 

   142   // Begin the process of bringing the system to a safepoint.

   143   // Java threads can be in several different states and are

   144   // stopped by different mechanisms:

   145   //

   146   //  1. Running interpreted

   147   //     The interpreter dispatch table is changed to force it to

   148   //     check for a safepoint condition between bytecodes.

   149   //  2. Running in native code

   150   //     When returning from the native code, a Java thread must check

   151   //     the safepoint _state to see if we must block.  If the

   152   //     VM thread sees a Java thread in native, it does

   153   //     not wait for this thread to block.  The order of the memory

   154   //     writes and reads of both the safepoint state and the Java

   155   //     threads state is critical.  In order to guarantee that the

   156   //     memory writes are serialized with respect to each other,

   157   //     the VM thread issues a memory barrier instruction

   158   //     (on MP systems).  In order to avoid the overhead of issuing

   159   //     a memory barrier for each Java thread making native calls, each Java

   160   //     thread performs a write to a single memory page after changing

   161   //     the thread state.  The VM thread performs a sequence of

   162   //     mprotect OS calls which forces all previous writes from all

   163   //     Java threads to be serialized.  This is done in the

   164   //     os::serialize_thread_states() call.  This has proven to be

   165   //     much more efficient than executing a membar instruction

   166   //     on every call to native code.

   167   //  3. Running compiled Code

   168   //     Compiled code reads a global (Safepoint Polling) page that

   169   //     is set to fault if we are trying to get to a safepoint.

   170   //  4. Blocked

   171   //     A thread which is blocked will not be allowed to return from the

   172   //     block condition until the safepoint operation is complete.

   173   //  5. In VM or Transitioning between states

   174   //     If a Java thread is currently running in the VM or transitioning

   175   //     between states, the safepointing code will wait for the thread to

   176   //     block itself when it attempts transitions to a new state.

   177   //

   178   {

   179     EventSafepointStateSynchronization sync_event;

   180     int initial_running = 0;

   181 

   182     _state            = _synchronizing;

   183     OrderAccess::fence();

   184 

   185     // Flush all thread states to memory

   186     if (!UseMembar) {

   187       os::serialize_thread_states();

   188     }

   189 

   190     // Make interpreter safepoint aware

   191     Interpreter::notice_safepoints();

   192 

   193     if (DeferPollingPageLoopCount < 0) {

   194       // Make polling safepoint aware

   195       guarantee (PageArmed == 0, "invariant") ;

   196       PageArmed = 1 ;

   197       os::make_polling_page_unreadable();

   198     }

   199 

   200     // Consider using active_processor_count() ... but that call is expensive.

   201     int ncpus = os::processor_count() ;

   202 

   203 #ifdef ASSERT

   204     for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {

   205       assert(cur->safepoint_state()->is_running(), "Illegal initial state");

   206       // Clear the visited flag to ensure that the critical counts are collected properly.

   207       cur->set_visited_for_critical_count(false);

   208     }

   209 #endif // ASSERT

   210 

   211     if (SafepointTimeout)

   212       safepoint_limit_time = os::javaTimeNanos() + (jlong)SafepointTimeoutDelay * MICROUNITS;

   213 

   214     // Iterate through all threads until it have been determined how to stop them all at a safepoint

   215     unsigned int iterations = 0;

   216     int steps = 0 ;

   217     while(still_running > 0) {

   218       for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {

   219         assert(!cur->is_ConcurrentGC_thread(), "A concurrent GC thread is unexpectly being suspended");

   220         ThreadSafepointState *cur_state = cur->safepoint_state();

   221         if (cur_state->is_running()) {

   222           cur_state->examine_state_of_thread();

   223           if (!cur_state->is_running()) {

   224             still_running--;

   225             // consider adjusting steps downward:

   226             //   steps = 0

   227             //   steps -= NNN

   228             //   steps >>= 1

   229             //   steps = MIN(steps, 2000-100)

   230             //   if (iterations != 0) steps -= NNN

   231           }

   232           LogTarget(Trace, safepoint) lt;

   233           if (lt.is_enabled()) {

   234             ResourceMark rm;

   235             LogStream ls(lt);

   236             cur_state->print_on(&ls);

   237           }

   238         }

   239       }

   240 

   241       if (iterations == 0) {

   242         initial_running = still_running;

   243         if (PrintSafepointStatistics) {

   244           begin_statistics(nof_threads, still_running);

   245         }

   246       }

   247 

   248       if (still_running > 0) {

   249         // Check for if it takes to long

   250         if (SafepointTimeout && safepoint_limit_time < os::javaTimeNanos()) {

   251           print_safepoint_timeout(_spinning_timeout);

   252         }

   253 

   254         // Spin to avoid context switching.

   255         // There's a tension between allowing the mutators to run (and rendezvous)

   256         // vs spinning.  As the VM thread spins, wasting cycles, it consumes CPU that

   257         // a mutator might otherwise use profitably to reach a safepoint.  Excessive

   258         // spinning by the VM thread on a saturated system can increase rendezvous latency.

   259         // Blocking or yielding incur their own penalties in the form of context switching

   260         // and the resultant loss of $ residency.

   261         //

   262         // Further complicating matters is that yield() does not work as naively expected

   263         // on many platforms -- yield() does not guarantee that any other ready threads

   264         // will run.   As such we revert to naked_short_sleep() after some number of iterations.

   265         // nakes_short_sleep() is implemented as a short unconditional sleep.

   266         // Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping

   267         // can actually increase the time it takes the VM thread to detect that a system-wide

   268         // stop-the-world safepoint has been reached.  In a pathological scenario such as that

   269         // described in CR6415670 the VMthread may sleep just before the mutator(s) become safe.

   270         // In that case the mutators will be stalled waiting for the safepoint to complete and the

   271         // the VMthread will be sleeping, waiting for the mutators to rendezvous.  The VMthread

   272         // will eventually wake up and detect that all mutators are safe, at which point

   273         // we'll again make progress.

   274         //

   275         // Beware too that that the VMThread typically runs at elevated priority.

   276         // Its default priority is higher than the default mutator priority.

   277         // Obviously, this complicates spinning.

   278         //

   279         // Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0).

   280         // Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will.

   281         //

   282         // See the comments in synchronizer.cpp for additional remarks on spinning.

   283         //

   284         // In the future we might:

   285         // 1. Modify the safepoint scheme to avoid potentially unbounded spinning.

   286         //    This is tricky as the path used by a thread exiting the JVM (say on

   287         //    on JNI call-out) simply stores into its state field.  The burden

   288         //    is placed on the VM thread, which must poll (spin).

   289         // 2. Find something useful to do while spinning.  If the safepoint is GC-related

   290         //    we might aggressively scan the stacks of threads that are already safe.

   291         // 3. Use Solaris schedctl to examine the state of the still-running mutators.

   292         //    If all the mutators are ONPROC there's no reason to sleep or yield.

   293         // 4. YieldTo() any still-running mutators that are ready but OFFPROC.

   294         // 5. Check system saturation.  If the system is not fully saturated then

   295         //    simply spin and avoid sleep/yield.

   296         // 6. As still-running mutators rendezvous they could unpark the sleeping

   297         //    VMthread.  This works well for still-running mutators that become

   298         //    safe.  The VMthread must still poll for mutators that call-out.

   299         // 7. Drive the policy on time-since-begin instead of iterations.

   300         // 8. Consider making the spin duration a function of the # of CPUs:

   301         //    Spin = (((ncpus-1) * M) + K) + F(still_running)

   302         //    Alternately, instead of counting iterations of the outer loop

   303         //    we could count the # of threads visited in the inner loop, above.

   304         // 9. On windows consider using the return value from SwitchThreadTo()

   305         //    to drive subsequent spin/SwitchThreadTo()/Sleep(N) decisions.

   306 

   307         if (int(iterations) == DeferPollingPageLoopCount) {

   308           guarantee (PageArmed == 0, "invariant") ;

   309           PageArmed = 1 ;

   310           os::make_polling_page_unreadable();

   311         }

   312 

   313         // Instead of (ncpus > 1) consider either (still_running < (ncpus + EPSILON)) or

   314         // ((still_running + _waiting_to_block - TryingToBlock)) < ncpus)

   315         ++steps ;

   316         if (ncpus > 1 && steps < SafepointSpinBeforeYield) {

   317           SpinPause() ;     // MP-Polite spin

   318         } else

   319           if (steps < DeferThrSuspendLoopCount) {

   320             os::naked_yield() ;

   321           } else {

   322             os::naked_short_sleep(1);

   323           }

   324 

   325         iterations ++ ;

   326       }

   327       assert(iterations < (uint)max_jint, "We have been iterating in the safepoint loop too long");

   328     }

   329     assert(still_running == 0, "sanity check");

   330 

   331     if (PrintSafepointStatistics) {

   332       update_statistics_on_spin_end();

   333     }

   334 

   335     if (sync_event.should_commit()) {

   336       sync_event.set_safepointId(safepoint_counter());

   337       sync_event.set_initialThreadCount(initial_running);

   338       sync_event.set_runningThreadCount(_waiting_to_block);

   339       sync_event.set_iterations(iterations);

   340       sync_event.commit();

   341     }

   342   } //EventSafepointStateSync

   343 

   344   // wait until all threads are stopped

   345   {

   346     EventSafepointWaitBlocked wait_blocked_event;

   347     int initial_waiting_to_block = _waiting_to_block;

   348 

   349     while (_waiting_to_block > 0) {

   350       log_debug(safepoint)("Waiting for %d thread(s) to block", _waiting_to_block);

   351       if (!SafepointTimeout || timeout_error_printed) {

   352         Safepoint_lock->wait(true);  // true, means with no safepoint checks

   353       } else {

   354         // Compute remaining time

   355         jlong remaining_time = safepoint_limit_time - os::javaTimeNanos();

   356 

   357         // If there is no remaining time, then there is an error

   358         if (remaining_time < 0 || Safepoint_lock->wait(true, remaining_time / MICROUNITS)) {

   359           print_safepoint_timeout(_blocking_timeout);

   360         }

   361       }

   362     }

   363     assert(_waiting_to_block == 0, "sanity check");

   364 

   365 #ifndef PRODUCT

   366     if (SafepointTimeout) {

   367       jlong current_time = os::javaTimeNanos();

   368       if (safepoint_limit_time < current_time) {

   369         tty->print_cr("# SafepointSynchronize: Finished after "

   370                       INT64_FORMAT_W(6) " ms",

   371                       (int64_t)((current_time - safepoint_limit_time) / MICROUNITS +

   372                                 (jlong)SafepointTimeoutDelay));

   373       }

   374     }

   375 #endif

   376 

   377     assert((_safepoint_counter & 0x1) == 0, "must be even");

   378     assert(Threads_lock->owned_by_self(), "must hold Threads_lock");

   379     _safepoint_counter ++;

   380 

   381     // Record state

   382     _state = _synchronized;

   383 

   384     OrderAccess::fence();

   385 

   386     if (wait_blocked_event.should_commit()) {

   387       wait_blocked_event.set_safepointId(safepoint_counter());

   388       wait_blocked_event.set_runningThreadCount(initial_waiting_to_block);

   389       wait_blocked_event.commit();

   390     }

   391   } // EventSafepointWaitBlocked

   392 

   393 #ifdef ASSERT

   394   for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {

   395     // make sure all the threads were visited

   396     assert(cur->was_visited_for_critical_count(), "missed a thread");

   397   }

   398 #endif // ASSERT

   399 

   400   // Update the count of active JNI critical regions

   401   GCLocker::set_jni_lock_count(_current_jni_active_count);

   402 

   403   if (log_is_enabled(Debug, safepoint)) {

   404     log_debug(safepoint)("Entering safepoint region: %s", VMThread::vm_safepoint_description());

   405   }

   406 

   407   RuntimeService::record_safepoint_synchronized();

   408   if (PrintSafepointStatistics) {

   409     update_statistics_on_sync_end(os::javaTimeNanos());

   410   }

   411 

   412   // Call stuff that needs to be run when a safepoint is just about to be completed

   413   {

   414     EventSafepointCleanup cleanup_event;

   415     do_cleanup_tasks();

   416     if (cleanup_event.should_commit()) {

   417       cleanup_event.set_safepointId(safepoint_counter());

   418       cleanup_event.commit();

   419     }

   420   }

   421 

   422   if (PrintSafepointStatistics) {

   423     // Record how much time spend on the above cleanup tasks

   424     update_statistics_on_cleanup_end(os::javaTimeNanos());

   425   }

   426   if (begin_event.should_commit()) {

   427     begin_event.set_safepointId(safepoint_counter());

   428     begin_event.set_totalThreadCount(nof_threads);

   429     begin_event.set_jniCriticalThreadCount(_current_jni_active_count);

   430     begin_event.commit();

   431   }

   432 }

   433 

   434 // Wake up all threads, so they are ready to resume execution after the safepoint

   435 // operation has been carried out

   436 void SafepointSynchronize::end() {

   437   EventSafepointEnd event;

   438   int safepoint_id = safepoint_counter(); // Keep the odd counter as "id"

   439 

   440   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");

   441   assert((_safepoint_counter & 0x1) == 1, "must be odd");

   442   _safepoint_counter ++;

   443   // memory fence isn't required here since an odd _safepoint_counter

   444   // value can do no harm and a fence is issued below anyway.

   445 

   446   DEBUG_ONLY(Thread* myThread = Thread::current();)

   447   assert(myThread->is_VM_thread(), "Only VM thread can execute a safepoint");

   448 

   449   if (PrintSafepointStatistics) {

   450     end_statistics(os::javaTimeNanos());

   451   }

   452 

   453 #ifdef ASSERT

   454   // A pending_exception cannot be installed during a safepoint.  The threads

   455   // may install an async exception after they come back from a safepoint into

   456   // pending_exception after they unblock.  But that should happen later.

   457   for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) {

   458     assert (!(cur->has_pending_exception() &&

   459               cur->safepoint_state()->is_at_poll_safepoint()),

   460             "safepoint installed a pending exception");

   461   }

   462 #endif // ASSERT

   463 

   464   if (PageArmed) {

   465     // Make polling safepoint aware

   466     os::make_polling_page_readable();

   467     PageArmed = 0 ;

   468   }

   469 

   470   // Remove safepoint check from interpreter

   471   Interpreter::ignore_safepoints();

   472 

   473   {

   474     MutexLocker mu(Safepoint_lock);

   475 

   476     assert(_state == _synchronized, "must be synchronized before ending safepoint synchronization");

   477 

   478     // Set to not synchronized, so the threads will not go into the signal_thread_blocked method

   479     // when they get restarted.

   480     _state = _not_synchronized;

   481     OrderAccess::fence();

   482 

   483     log_debug(safepoint)("Leaving safepoint region");

   484 

   485     // Start suspended threads

   486     for(JavaThread *current = Threads::first(); current; current = current->next()) {

   487       // A problem occurring on Solaris is when attempting to restart threads

   488       // the first #cpus - 1 go well, but then the VMThread is preempted when we get

   489       // to the next one (since it has been running the longest).  We then have

   490       // to wait for a cpu to become available before we can continue restarting

   491       // threads.

   492       // FIXME: This causes the performance of the VM to degrade when active and with

   493       // large numbers of threads.  Apparently this is due to the synchronous nature

   494       // of suspending threads.

   495       //

   496       // TODO-FIXME: the comments above are vestigial and no longer apply.

   497       // Furthermore, using solaris' schedctl in this particular context confers no benefit

   498       if (VMThreadHintNoPreempt) {

   499         os::hint_no_preempt();

   500       }

   501       ThreadSafepointState* cur_state = current->safepoint_state();

   502       assert(cur_state->type() != ThreadSafepointState::_running, "Thread not suspended at safepoint");

   503       cur_state->restart();

   504       assert(cur_state->is_running(), "safepoint state has not been reset");

   505     }

   506 

   507     RuntimeService::record_safepoint_end();

   508 

   509     // Release threads lock, so threads can be created/destroyed again. It will also starts all threads

   510     // blocked in signal_thread_blocked

   511     Threads_lock->unlock();

   512 

   513   }

   514 #if INCLUDE_ALL_GCS

   515   // If there are any concurrent GC threads resume them.

   516   if (UseConcMarkSweepGC) {

   517     ConcurrentMarkSweepThread::desynchronize(false);

   518   } else if (UseG1GC) {

   519     SuspendibleThreadSet::desynchronize();

   520   }

   521 #endif // INCLUDE_ALL_GCS

   522   // record this time so VMThread can keep track how much time has elapsed

   523   // since last safepoint.

   524   _end_of_last_safepoint = os::javaTimeMillis();

   525 

   526   if (event.should_commit()) {

   527     event.set_safepointId(safepoint_id);

   528     event.commit();

   529   }

   530 }

   531 

   532 bool SafepointSynchronize::is_cleanup_needed() {

   533   // Need a safepoint if there are many monitors to deflate.

   534   if (ObjectSynchronizer::is_cleanup_needed()) return true;

   535   // Need a safepoint if some inline cache buffers is non-empty

   536   if (!InlineCacheBuffer::is_empty()) return true;

   537   return false;

   538 }

   539 

   540 static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {

   541   if (event.should_commit()) {

   542     event.set_safepointId(SafepointSynchronize::safepoint_counter());

   543     event.set_name(name);

   544     event.commit();

   545   }

   546 }

   547 

   548 class ParallelSPCleanupThreadClosure : public ThreadClosure {

   549 private:

   550   CodeBlobClosure* _nmethod_cl;

   551   DeflateMonitorCounters* _counters;

   552 

   553 public:

   554   ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :

   555     _counters(counters),

   556     _nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()) {}

   557 

   558   void do_thread(Thread* thread) {

   559     ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);

   560     if (_nmethod_cl != NULL && thread->is_Java_thread() &&

   561         ! thread->is_Code_cache_sweeper_thread()) {

   562       JavaThread* jt = (JavaThread*) thread;

   563       jt->nmethods_do(_nmethod_cl);

   564     }

   565   }

   566 };

   567 

   568 class ParallelSPCleanupTask : public AbstractGangTask {

   569 private:

   570   SubTasksDone _subtasks;

   571   ParallelSPCleanupThreadClosure _cleanup_threads_cl;

   572   uint _num_workers;

   573   DeflateMonitorCounters* _counters;

   574 public:

   575   ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :

   576     AbstractGangTask("Parallel Safepoint Cleanup"),

   577     _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),

   578     _num_workers(num_workers),

   579     _subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),

   580     _counters(counters) {}

   581 

   582   void work(uint worker_id) {

   583     // All threads deflate monitors and mark nmethods (if necessary).

   584     Threads::parallel_java_threads_do(&_cleanup_threads_cl);

   585 

   586     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {

   587       const char* name = "deflating idle monitors";

   588       EventSafepointCleanupTask event;

   589       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   590       ObjectSynchronizer::deflate_idle_monitors(_counters);

   591       event_safepoint_cleanup_task_commit(event, name);

   592     }

   593 

   594     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {

   595       const char* name = "updating inline caches";

   596       EventSafepointCleanupTask event;

   597       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   598       InlineCacheBuffer::update_inline_caches();

   599       event_safepoint_cleanup_task_commit(event, name);

   600     }

   601 

   602     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {

   603       const char* name = "compilation policy safepoint handler";

   604       EventSafepointCleanupTask event;

   605       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   606       CompilationPolicy::policy()->do_safepoint_work();

   607       event_safepoint_cleanup_task_commit(event, name);

   608     }

   609 

   610     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {

   611       if (SymbolTable::needs_rehashing()) {

   612         const char* name = "rehashing symbol table";

   613         EventSafepointCleanupTask event;

   614         TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   615         SymbolTable::rehash_table();

   616         event_safepoint_cleanup_task_commit(event, name);

   617       }

   618     }

   619 

   620     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {

   621       if (StringTable::needs_rehashing()) {

   622         const char* name = "rehashing string table";

   623         EventSafepointCleanupTask event;

   624         TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   625         StringTable::rehash_table();

   626         event_safepoint_cleanup_task_commit(event, name);

   627       }

   628     }

   629 

   630     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {

   631       // CMS delays purging the CLDG until the beginning of the next safepoint and to

   632       // make sure concurrent sweep is done

   633       const char* name = "purging class loader data graph";

   634       EventSafepointCleanupTask event;

   635       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   636       ClassLoaderDataGraph::purge_if_needed();

   637       event_safepoint_cleanup_task_commit(event, name);

   638     }

   639     _subtasks.all_tasks_completed(_num_workers);

   640   }

   641 };

   642 

   643 // Various cleaning tasks that should be done periodically at safepoints.

   644 void SafepointSynchronize::do_cleanup_tasks() {

   645 

   646   TraceTime timer("safepoint cleanup tasks", TRACETIME_LOG(Info, safepoint, cleanup));

   647 

   648   // Prepare for monitor deflation.

   649   DeflateMonitorCounters deflate_counters;

   650   ObjectSynchronizer::prepare_deflate_idle_monitors(&deflate_counters);

   651 

   652   CollectedHeap* heap = Universe::heap();

   653   assert(heap != NULL, "heap not initialized yet?");

   654   WorkGang* cleanup_workers = heap->get_safepoint_workers();

   655   if (cleanup_workers != NULL) {

   656     // Parallel cleanup using GC provided thread pool.

   657     uint num_cleanup_workers = cleanup_workers->active_workers();

   658     ParallelSPCleanupTask cleanup(num_cleanup_workers, &deflate_counters);

   659     StrongRootsScope srs(num_cleanup_workers);

   660     cleanup_workers->run_task(&cleanup);

   661   } else {

   662     // Serial cleanup using VMThread.

   663     ParallelSPCleanupTask cleanup(1, &deflate_counters);

   664     StrongRootsScope srs(1);

   665     cleanup.work(0);

   666   }

   667 

   668   // Finish monitor deflation.

   669   ObjectSynchronizer::finish_deflate_idle_monitors(&deflate_counters);

   670 }

   671 

   672 

   673 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {

   674   switch(state) {

   675   case _thread_in_native:

   676     // native threads are safe if they have no java stack or have walkable stack

   677     return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();

   678 

   679    // blocked threads should have already have walkable stack

   680   case _thread_blocked:

   681     assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");

   682     return true;

   683 

   684   default:

   685     return false;

   686   }

   687 }

   688 

   689 

   690 // See if the thread is running inside a lazy critical native and

   691 // update the thread critical count if so.  Also set a suspend flag to

   692 // cause the native wrapper to return into the JVM to do the unlock

   693 // once the native finishes.

   694 void SafepointSynchronize::check_for_lazy_critical_native(JavaThread *thread, JavaThreadState state) {

   695   if (state == _thread_in_native &&

   696       thread->has_last_Java_frame() &&

   697       thread->frame_anchor()->walkable()) {

   698     // This thread might be in a critical native nmethod so look at

   699     // the top of the stack and increment the critical count if it

   700     // is.

   701     frame wrapper_frame = thread->last_frame();

   702     CodeBlob* stub_cb = wrapper_frame.cb();

   703     if (stub_cb != NULL &&

   704         stub_cb->is_nmethod() &&

   705         stub_cb->as_nmethod_or_null()->is_lazy_critical_native()) {

   706       // A thread could potentially be in a critical native across

   707       // more than one safepoint, so only update the critical state on

   708       // the first one.  When it returns it will perform the unlock.

   709       if (!thread->do_critical_native_unlock()) {

   710 #ifdef ASSERT

   711         if (!thread->in_critical()) {

   712           GCLocker::increment_debug_jni_lock_count();

   713         }

   714 #endif

   715         thread->enter_critical();

   716         // Make sure the native wrapper calls back on return to

   717         // perform the needed critical unlock.

   718         thread->set_critical_native_unlock();

   719       }

   720     }

   721   }

   722 }

   723 

   724 

   725 

   726 // -------------------------------------------------------------------------------------------------------

   727 // Implementation of Safepoint callback point

   728 

   729 void SafepointSynchronize::block(JavaThread *thread) {

   730   assert(thread != NULL, "thread must be set");

   731   assert(thread->is_Java_thread(), "not a Java thread");

   732 

   733   // Threads shouldn't block if they are in the middle of printing, but...

   734   ttyLocker::break_tty_lock_for_safepoint(os::current_thread_id());

   735 

   736   // Only bail from the block() call if the thread is gone from the

   737   // thread list; starting to exit should still block.

   738   if (thread->is_terminated()) {

   739      // block current thread if we come here from native code when VM is gone

   740      thread->block_if_vm_exited();

   741 

   742      // otherwise do nothing

   743      return;

   744   }

   745 

   746   JavaThreadState state = thread->thread_state();

   747   thread->frame_anchor()->make_walkable(thread);

   748 

   749   // Check that we have a valid thread_state at this point

   750   switch(state) {

   751     case _thread_in_vm_trans:

   752     case _thread_in_Java:        // From compiled code

   753 

   754       // We are highly likely to block on the Safepoint_lock. In order to avoid blocking in this case,

   755       // we pretend we are still in the VM.

   756       thread->set_thread_state(_thread_in_vm);

   757 

   758       if (is_synchronizing()) {

   759          Atomic::inc (&TryingToBlock) ;

   760       }

   761 

   762       // We will always be holding the Safepoint_lock when we are examine the state

   763       // of a thread. Hence, the instructions between the Safepoint_lock->lock() and

   764       // Safepoint_lock->unlock() are happening atomic with regards to the safepoint code

   765       Safepoint_lock->lock_without_safepoint_check();

   766       if (is_synchronizing()) {

   767         // Decrement the number of threads to wait for and signal vm thread

   768         assert(_waiting_to_block > 0, "sanity check");

   769         _waiting_to_block--;

   770         thread->safepoint_state()->set_has_called_back(true);

   771 

   772         DEBUG_ONLY(thread->set_visited_for_critical_count(true));

   773         if (thread->in_critical()) {

   774           // Notice that this thread is in a critical section

   775           increment_jni_active_count();

   776         }

   777 

   778         // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread

   779         if (_waiting_to_block == 0) {

   780           Safepoint_lock->notify_all();

   781         }

   782       }

   783 

   784       // We transition the thread to state _thread_blocked here, but

   785       // we can't do our usual check for external suspension and then

   786       // self-suspend after the lock_without_safepoint_check() call

   787       // below because we are often called during transitions while

   788       // we hold different locks. That would leave us suspended while

   789       // holding a resource which results in deadlocks.

   790       thread->set_thread_state(_thread_blocked);

   791       Safepoint_lock->unlock();

   792 

   793       // We now try to acquire the threads lock. Since this lock is hold by the VM thread during

   794       // the entire safepoint, the threads will all line up here during the safepoint.

   795       Threads_lock->lock_without_safepoint_check();

   796       // restore original state. This is important if the thread comes from compiled code, so it

   797       // will continue to execute with the _thread_in_Java state.

   798       thread->set_thread_state(state);

   799       Threads_lock->unlock();

   800       break;

   801 

   802     case _thread_in_native_trans:

   803     case _thread_blocked_trans:

   804     case _thread_new_trans:

   805       if (thread->safepoint_state()->type() == ThreadSafepointState::_call_back) {

   806         thread->print_thread_state();

   807         fatal("Deadlock in safepoint code.  "

   808               "Should have called back to the VM before blocking.");

   809       }

   810 

   811       // We transition the thread to state _thread_blocked here, but

   812       // we can't do our usual check for external suspension and then

   813       // self-suspend after the lock_without_safepoint_check() call

   814       // below because we are often called during transitions while

   815       // we hold different locks. That would leave us suspended while

   816       // holding a resource which results in deadlocks.

   817       thread->set_thread_state(_thread_blocked);

   818 

   819       // It is not safe to suspend a thread if we discover it is in _thread_in_native_trans. Hence,

   820       // the safepoint code might still be waiting for it to block. We need to change the state here,

   821       // so it can see that it is at a safepoint.

   822 

   823       // Block until the safepoint operation is completed.

   824       Threads_lock->lock_without_safepoint_check();

   825 

   826       // Restore state

   827       thread->set_thread_state(state);

   828 

   829       Threads_lock->unlock();

   830       break;

   831 

   832     default:

   833      fatal("Illegal threadstate encountered: %d", state);

   834   }

   835 

   836   // Check for pending. async. exceptions or suspends - except if the

   837   // thread was blocked inside the VM. has_special_runtime_exit_condition()

   838   // is called last since it grabs a lock and we only want to do that when

   839   // we must.

   840   //

   841   // Note: we never deliver an async exception at a polling point as the

   842   // compiler may not have an exception handler for it. The polling

   843   // code will notice the async and deoptimize and the exception will

   844   // be delivered. (Polling at a return point is ok though). Sure is

   845   // a lot of bother for a deprecated feature...

   846   //

   847   // We don't deliver an async exception if the thread state is

   848   // _thread_in_native_trans so JNI functions won't be called with

   849   // a surprising pending exception. If the thread state is going back to java,

   850   // async exception is checked in check_special_condition_for_native_trans().

   851 

   852   if (state != _thread_blocked_trans &&

   853       state != _thread_in_vm_trans &&

   854       thread->has_special_runtime_exit_condition()) {

   855     thread->handle_special_runtime_exit_condition(

   856       !thread->is_at_poll_safepoint() && (state != _thread_in_native_trans));

   857   }

   858 }

   859 

   860 // ------------------------------------------------------------------------------------------------------

   861 // Exception handlers

   862 

   863 

   864 void SafepointSynchronize::handle_polling_page_exception(JavaThread *thread) {

   865   assert(thread->is_Java_thread(), "polling reference encountered by VM thread");

   866   assert(thread->thread_state() == _thread_in_Java, "should come from Java code");

   867   assert(SafepointSynchronize::is_synchronizing(), "polling encountered outside safepoint synchronization");

   868 

   869   if (ShowSafepointMsgs) {

   870     tty->print("handle_polling_page_exception: ");

   871   }

   872 

   873   if (PrintSafepointStatistics) {

   874     inc_page_trap_count();

   875   }

   876 

   877   ThreadSafepointState* state = thread->safepoint_state();

   878 

   879   state->handle_polling_page_exception();

   880 }

   881 

   882 

   883 void SafepointSynchronize::print_safepoint_timeout(SafepointTimeoutReason reason) {

   884   if (!timeout_error_printed) {

   885     timeout_error_printed = true;

   886     // Print out the thread info which didn't reach the safepoint for debugging

   887     // purposes (useful when there are lots of threads in the debugger).

   888     tty->cr();

   889     tty->print_cr("# SafepointSynchronize::begin: Timeout detected:");

   890     if (reason ==  _spinning_timeout) {

   891       tty->print_cr("# SafepointSynchronize::begin: Timed out while spinning to reach a safepoint.");

   892     } else if (reason == _blocking_timeout) {

   893       tty->print_cr("# SafepointSynchronize::begin: Timed out while waiting for threads to stop.");

   894     }

   895 

   896     tty->print_cr("# SafepointSynchronize::begin: Threads which did not reach the safepoint:");

   897     ThreadSafepointState *cur_state;

   898     ResourceMark rm;

   899     for(JavaThread *cur_thread = Threads::first(); cur_thread;

   900         cur_thread = cur_thread->next()) {

   901       cur_state = cur_thread->safepoint_state();

   902 

   903       if (cur_thread->thread_state() != _thread_blocked &&

   904           ((reason == _spinning_timeout && cur_state->is_running()) ||

   905            (reason == _blocking_timeout && !cur_state->has_called_back()))) {

   906         tty->print("# ");

   907         cur_thread->print();

   908         tty->cr();

   909       }

   910     }

   911     tty->print_cr("# SafepointSynchronize::begin: (End of list)");

   912   }

   913 

   914   // To debug the long safepoint, specify both DieOnSafepointTimeout &

   915   // ShowMessageBoxOnError.

   916   if (DieOnSafepointTimeout) {

   917     fatal("Safepoint sync time longer than " INTX_FORMAT "ms detected when executing %s.",

   918           SafepointTimeoutDelay, VMThread::vm_safepoint_description());

   919   }

   920 }

   921 

   922 

   923 // -------------------------------------------------------------------------------------------------------

   924 // Implementation of ThreadSafepointState

   925 

   926 ThreadSafepointState::ThreadSafepointState(JavaThread *thread) {

   927   _thread = thread;

   928   _type   = _running;

   929   _has_called_back = false;

   930   _at_poll_safepoint = false;

   931 }

   932 

   933 void ThreadSafepointState::create(JavaThread *thread) {

   934   ThreadSafepointState *state = new ThreadSafepointState(thread);

   935   thread->set_safepoint_state(state);

   936 }

   937 

   938 void ThreadSafepointState::destroy(JavaThread *thread) {

   939   if (thread->safepoint_state()) {

   940     delete(thread->safepoint_state());

   941     thread->set_safepoint_state(NULL);

   942   }

   943 }

   944 

   945 void ThreadSafepointState::examine_state_of_thread() {

   946   assert(is_running(), "better be running or just have hit safepoint poll");

   947 

   948   JavaThreadState state = _thread->thread_state();

   949 

   950   // Save the state at the start of safepoint processing.

   951   _orig_thread_state = state;

   952 

   953   // Check for a thread that is suspended. Note that thread resume tries

   954   // to grab the Threads_lock which we own here, so a thread cannot be

   955   // resumed during safepoint synchronization.

   956 

   957   // We check to see if this thread is suspended without locking to

   958   // avoid deadlocking with a third thread that is waiting for this

   959   // thread to be suspended. The third thread can notice the safepoint

   960   // that we're trying to start at the beginning of its SR_lock->wait()

   961   // call. If that happens, then the third thread will block on the

   962   // safepoint while still holding the underlying SR_lock. We won't be

   963   // able to get the SR_lock and we'll deadlock.

   964   //

   965   // We don't need to grab the SR_lock here for two reasons:

   966   // 1) The suspend flags are both volatile and are set with an

   967   //    Atomic::cmpxchg() call so we should see the suspended

   968   //    state right away.

   969   // 2) We're being called from the safepoint polling loop; if

   970   //    we don't see the suspended state on this iteration, then

   971   //    we'll come around again.

   972   //

   973   bool is_suspended = _thread->is_ext_suspended();

   974   if (is_suspended) {

   975     roll_forward(_at_safepoint);

   976     return;

   977   }

   978 

   979   // Some JavaThread states have an initial safepoint state of

   980   // running, but are actually at a safepoint. We will happily

   981   // agree and update the safepoint state here.

   982   if (SafepointSynchronize::safepoint_safe(_thread, state)) {

   983     SafepointSynchronize::check_for_lazy_critical_native(_thread, state);

   984     roll_forward(_at_safepoint);

   985     return;

   986   }

   987 

   988   if (state == _thread_in_vm) {

   989     roll_forward(_call_back);

   990     return;

   991   }

   992 

   993   // All other thread states will continue to run until they

   994   // transition and self-block in state _blocked

   995   // Safepoint polling in compiled code causes the Java threads to do the same.

   996   // Note: new threads may require a malloc so they must be allowed to finish

   997 

   998   assert(is_running(), "examine_state_of_thread on non-running thread");

   999   return;

  1000 }

  1001 

  1002 // Returns true is thread could not be rolled forward at present position.

  1003 void ThreadSafepointState::roll_forward(suspend_type type) {

  1004   _type = type;

  1005 

  1006   switch(_type) {

  1007     case _at_safepoint:

  1008       SafepointSynchronize::signal_thread_at_safepoint();

  1009       DEBUG_ONLY(_thread->set_visited_for_critical_count(true));

  1010       if (_thread->in_critical()) {

  1011         // Notice that this thread is in a critical section

  1012         SafepointSynchronize::increment_jni_active_count();

  1013       }

  1014       break;

  1015 

  1016     case _call_back:

  1017       set_has_called_back(false);

  1018       break;

  1019 

  1020     case _running:

  1021     default:

  1022       ShouldNotReachHere();

  1023   }

  1024 }

  1025 

  1026 void ThreadSafepointState::restart() {

  1027   switch(type()) {

  1028     case _at_safepoint:

  1029     case _call_back:

  1030       break;

  1031 

  1032     case _running:

  1033     default:

  1034        tty->print_cr("restart thread " INTPTR_FORMAT " with state %d",

  1035                      p2i(_thread), _type);

  1036        _thread->print();

  1037       ShouldNotReachHere();

  1038   }

  1039   _type = _running;

  1040   set_has_called_back(false);

  1041 }

  1042 

  1043 

  1044 void ThreadSafepointState::print_on(outputStream *st) const {

  1045   const char *s = NULL;

  1046 

  1047   switch(_type) {

  1048     case _running                : s = "_running";              break;

  1049     case _at_safepoint           : s = "_at_safepoint";         break;

  1050     case _call_back              : s = "_call_back";            break;

  1051     default:

  1052       ShouldNotReachHere();

  1053   }

  1054 

  1055   st->print_cr("Thread: " INTPTR_FORMAT

  1056               "  [0x%2x] State: %s _has_called_back %d _at_poll_safepoint %d",

  1057                p2i(_thread), _thread->osthread()->thread_id(), s, _has_called_back,

  1058                _at_poll_safepoint);

  1059 

  1060   _thread->print_thread_state_on(st);

  1061 }

  1062 

  1063 // ---------------------------------------------------------------------------------------------------------------------

  1064 

  1065 // Block the thread at the safepoint poll or poll return.

  1066 void ThreadSafepointState::handle_polling_page_exception() {

  1067 

  1068   // Check state.  block() will set thread state to thread_in_vm which will

  1069   // cause the safepoint state _type to become _call_back.

  1070   assert(type() == ThreadSafepointState::_running,

  1071          "polling page exception on thread not running state");

  1072 

  1073   // Step 1: Find the nmethod from the return address

  1074   if (ShowSafepointMsgs && Verbose) {

  1075     tty->print_cr("Polling page exception at " INTPTR_FORMAT, p2i(thread()->saved_exception_pc()));

  1076   }

  1077   address real_return_addr = thread()->saved_exception_pc();

  1078 

  1079   CodeBlob *cb = CodeCache::find_blob(real_return_addr);

  1080   assert(cb != NULL && cb->is_compiled(), "return address should be in nmethod");

  1081   CompiledMethod* nm = (CompiledMethod*)cb;

  1082 

  1083   // Find frame of caller

  1084   frame stub_fr = thread()->last_frame();

  1085   CodeBlob* stub_cb = stub_fr.cb();

  1086   assert(stub_cb->is_safepoint_stub(), "must be a safepoint stub");

  1087   RegisterMap map(thread(), true);

  1088   frame caller_fr = stub_fr.sender(&map);

  1089 

  1090   // Should only be poll_return or poll

  1091   assert( nm->is_at_poll_or_poll_return(real_return_addr), "should not be at call" );

  1092 

  1093   // This is a poll immediately before a return. The exception handling code

  1094   // has already had the effect of causing the return to occur, so the execution

  1095   // will continue immediately after the call. In addition, the oopmap at the

  1096   // return point does not mark the return value as an oop (if it is), so

  1097   // it needs a handle here to be updated.

  1098   if( nm->is_at_poll_return(real_return_addr) ) {

  1099     // See if return type is an oop.

  1100     bool return_oop = nm->method()->is_returning_oop();

  1101     Handle return_value;

  1102     if (return_oop) {

  1103       // The oop result has been saved on the stack together with all

  1104       // the other registers. In order to preserve it over GCs we need

  1105       // to keep it in a handle.

  1106       oop result = caller_fr.saved_oop_result(&map);

  1107       assert(oopDesc::is_oop_or_null(result), "must be oop");

  1108       return_value = Handle(thread(), result);

  1109       assert(Universe::heap()->is_in_or_null(result), "must be heap pointer");

  1110     }

  1111 

  1112     // Block the thread

  1113     SafepointSynchronize::block(thread());

  1114 

  1115     // restore oop result, if any

  1116     if (return_oop) {

  1117       caller_fr.set_saved_oop_result(&map, return_value());

  1118     }

  1119   }

  1120 

  1121   // This is a safepoint poll. Verify the return address and block.

  1122   else {

  1123     set_at_poll_safepoint(true);

  1124 

  1125     // verify the blob built the "return address" correctly

  1126     assert(real_return_addr == caller_fr.pc(), "must match");

  1127 

  1128     // Block the thread

  1129     SafepointSynchronize::block(thread());

  1130     set_at_poll_safepoint(false);

  1131 

  1132     // If we have a pending async exception deoptimize the frame

  1133     // as otherwise we may never deliver it.

  1134     if (thread()->has_async_condition()) {