       1 /*
       2  * Copyright (c) 1997, 2014, 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/symbolTable.hpp"
      27 #include "classfile/systemDictionary.hpp"
      28 #include "code/codeCache.hpp"
      29 #include "code/icBuffer.hpp"
      30 #include "code/nmethod.hpp"
      31 #include "code/pcDesc.hpp"
      32 #include "code/scopeDesc.hpp"
      33 #include "gc_interface/collectedHeap.hpp"
      34 #include "interpreter/interpreter.hpp"
      35 #include "memory/resourceArea.hpp"
      36 #include "memory/universe.inline.hpp"
      37 #include "oops/oop.inline.hpp"
      38 #include "oops/symbol.hpp"
      39 #include "runtime/compilationPolicy.hpp"
      40 #include "runtime/deoptimization.hpp"
      41 #include "runtime/frame.inline.hpp"
      42 #include "runtime/interfaceSupport.hpp"
      43 #include "runtime/mutexLocker.hpp"
      44 #include "runtime/orderAccess.inline.hpp"
      45 #include "runtime/osThread.hpp"
      46 #include "runtime/safepoint.hpp"
      47 #include "runtime/signature.hpp"
      48 #include "runtime/stubCodeGenerator.hpp"
      49 #include "runtime/stubRoutines.hpp"
      50 #include "runtime/sweeper.hpp"
      51 #include "runtime/synchronizer.hpp"
      52 #include "runtime/thread.inline.hpp"
      53 #include "services/runtimeService.hpp"
      54 #include "utilities/events.hpp"
      55 #include "utilities/macros.hpp"
      56 #ifdef TARGET_ARCH_x86
      57 # include "nativeInst_x86.hpp"
      58 # include "vmreg_x86.inline.hpp"
      59 #endif
      60 #ifdef TARGET_ARCH_sparc
      61 # include "nativeInst_sparc.hpp"
      62 # include "vmreg_sparc.inline.hpp"
      63 #endif
      64 #ifdef TARGET_ARCH_zero
      65 # include "nativeInst_zero.hpp"
      66 # include "vmreg_zero.inline.hpp"
      67 #endif
      68 #ifdef TARGET_ARCH_arm
      69 # include "nativeInst_arm.hpp"
      70 # include "vmreg_arm.inline.hpp"
      71 #endif
      72 #ifdef TARGET_ARCH_ppc
      73 # include "nativeInst_ppc.hpp"
      74 # include "vmreg_ppc.inline.hpp"
      75 #endif
      76 #if INCLUDE_ALL_GCS
      77 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
      78 #include "gc_implementation/shared/suspendibleThreadSet.hpp"
      79 #endif // INCLUDE_ALL_GCS
      80 #ifdef COMPILER1
      81 #include "c1/c1_globals.hpp"
      82 #endif
      83
      84 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
      85
      86 // --------------------------------------------------------------------------------------------------
      87 // Implementation of Safepoint begin/end
      88
      89 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
      90 volatile int  SafepointSynchronize::_waiting_to_block = 0;
      91 volatile int SafepointSynchronize::_safepoint_counter = 0;
      92 int SafepointSynchronize::_current_jni_active_count = 0;
      93 long  SafepointSynchronize::_end_of_last_safepoint = 0;
      94 static volatile int PageArmed = 0 ;        // safepoint polling page is RO|RW vs PROT_NONE
      95 static volatile int TryingToBlock = 0 ;    // proximate value -- for advisory use only
      96 static bool timeout_error_printed = false;
      97
      98 // Roll all threads forward to a safepoint and suspend them all
      99 void SafepointSynchronize::begin() {
     100
     101   Thread* myThread = Thread::current();
     102   assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint");
     103
     104   if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {
     105     _safepoint_begin_time = os::javaTimeNanos();
     106     _ts_of_current_safepoint = tty->time_stamp().seconds();
     107   }
     108
     109 #if INCLUDE_ALL_GCS
     110   if (UseConcMarkSweepGC) {
     111     // In the future we should investigate whether CMS can use the
     112     // more-general mechanism below.  DLD (01/05).
     113     ConcurrentMarkSweepThread::synchronize(false);
     114   } else if (UseG1GC) {
     115     SuspendibleThreadSet::synchronize();
     116   }
     117 #endif // INCLUDE_ALL_GCS
     118
     119   // By getting the Threads_lock, we assure that no threads are about to start or
     120   // exit. It is released again in SafepointSynchronize::end().
     121   Threads_lock->lock();
     122
     123   assert( _state == _not_synchronized, "trying to safepoint synchronize with wrong state");
     124
     125   int nof_threads = Threads::number_of_threads();
     126
     127   if (TraceSafepoint) {
     128     tty->print_cr("Safepoint synchronization initiated. (%d)", nof_threads);
     129   }
     130
     131   RuntimeService::record_safepoint_begin();
     132
     133   MutexLocker mu(Safepoint_lock);
     134
     135   // Reset the count of active JNI critical threads
     136   _current_jni_active_count = 0;
     137
     138   // Set number of threads to wait for, before we initiate the callbacks
     139   _waiting_to_block = nof_threads;
     140   TryingToBlock     = 0 ;
     141   int still_running = nof_threads;
     142
     143   // Save the starting time, so that it can be compared to see if this has taken
     144   // too long to complete.
     145   jlong safepoint_limit_time;
     146   timeout_error_printed = false;
     147
     148   // PrintSafepointStatisticsTimeout can be specified separately. When
     149   // specified, PrintSafepointStatistics will be set to true in
     150   // deferred_initialize_stat method. The initialization has to be done
     151   // early enough to avoid any races. See bug 6880029 for details.
     152   if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {
     153     deferred_initialize_stat();
     154   }
     155
     156   // Begin the process of bringing the system to a safepoint.
     157   // Java threads can be in several different states and are
     158   // stopped by different mechanisms:
     159   //
     160   //  1. Running interpreted
     161   //     The interpeter dispatch table is changed to force it to
     162   //     check for a safepoint condition between bytecodes.
     163   //  2. Running in native code
     164   //     When returning from the native code, a Java thread must check
     165   //     the safepoint _state to see if we must block.  If the
     166   //     VM thread sees a Java thread in native, it does
     167   //     not wait for this thread to block.  The order of the memory
     168   //     writes and reads of both the safepoint state and the Java
     169   //     threads state is critical.  In order to guarantee that the
     170   //     memory writes are serialized with respect to each other,
     171   //     the VM thread issues a memory barrier instruction
     172   //     (on MP systems).  In order to avoid the overhead of issuing
     173   //     a memory barrier for each Java thread making native calls, each Java
     174   //     thread performs a write to a single memory page after changing
     175   //     the thread state.  The VM thread performs a sequence of
     176   //     mprotect OS calls which forces all previous writes from all
     177   //     Java threads to be serialized.  This is done in the
     178   //     os::serialize_thread_states() call.  This has proven to be
     179   //     much more efficient than executing a membar instruction
     180   //     on every call to native code.
     181   //  3. Running compiled Code
     182   //     Compiled code reads a global (Safepoint Polling) page that
     183   //     is set to fault if we are trying to get to a safepoint.
     184   //  4. Blocked
     185   //     A thread which is blocked will not be allowed to return from the
     186   //     block condition until the safepoint operation is complete.
     187   //  5. In VM or Transitioning between states
     188   //     If a Java thread is currently running in the VM or transitioning
     189   //     between states, the safepointing code will wait for the thread to
     190   //     block itself when it attempts transitions to a new state.
     191   //
     192   _state            = _synchronizing;
     193   OrderAccess::fence();
     194
     195   // Flush all thread states to memory
     196   if (!UseMembar) {
     197     os::serialize_thread_states();
     198   }
     199
     200   // Make interpreter safepoint aware
     201   Interpreter::notice_safepoints();
     202
     203   if (UseCompilerSafepoints && DeferPollingPageLoopCount < 0) {
     204     // Make polling safepoint aware
     205     guarantee (PageArmed == 0, "invariant") ;
     206     PageArmed = 1 ;
     207     os::make_polling_page_unreadable();
     208   }
     209
     210   // Consider using active_processor_count() ... but that call is expensive.
     211   int ncpus = os::processor_count() ;
     212
     213 #ifdef ASSERT
     214   for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {
     215     assert(cur->safepoint_state()->is_running(), "Illegal initial state");
     216     // Clear the visited flag to ensure that the critical counts are collected properly.
     217     cur->set_visited_for_critical_count(false);
     218   }
     219 #endif // ASSERT
     220
     221   if (SafepointTimeout)
     222     safepoint_limit_time = os::javaTimeNanos() + (jlong)SafepointTimeoutDelay * MICROUNITS;
     223
     224   // Iterate through all threads until it have been determined how to stop them all at a safepoint
     225   unsigned int iterations = 0;
     226   int steps = 0 ;
     227   while(still_running > 0) {
     228     for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {
     229       assert(!cur->is_ConcurrentGC_thread(), "A concurrent GC thread is unexpectly being suspended");
     230       ThreadSafepointState *cur_state = cur->safepoint_state();
     231       if (cur_state->is_running()) {
     232         cur_state->examine_state_of_thread();
     233         if (!cur_state->is_running()) {
     234            still_running--;
     235            // consider adjusting steps downward:
     236            //   steps = 0
     237            //   steps -= NNN
     238            //   steps >>= 1
     239            //   steps = MIN(steps, 2000-100)
     240            //   if (iterations != 0) steps -= NNN
     241         }
     242         if (TraceSafepoint && Verbose) cur_state->print();
     243       }
     244     }
     245
     246     if (PrintSafepointStatistics && iterations == 0) {
     247       begin_statistics(nof_threads, still_running);
     248     }
     249
     250     if (still_running > 0) {
     251       // Check for if it takes to long
     252       if (SafepointTimeout && safepoint_limit_time < os::javaTimeNanos()) {
     253         print_safepoint_timeout(_spinning_timeout);
     254       }
     255
     256       // Spin to avoid context switching.
     257       // There's a tension between allowing the mutators to run (and rendezvous)
     258       // vs spinning.  As the VM thread spins, wasting cycles, it consumes CPU that
     259       // a mutator might otherwise use profitably to reach a safepoint.  Excessive
     260       // spinning by the VM thread on a saturated system can increase rendezvous latency.
     261       // Blocking or yielding incur their own penalties in the form of context switching
     262       // and the resultant loss of $ residency.
     263       //
     264       // Further complicating matters is that yield() does not work as naively expected
     265       // on many platforms -- yield() does not guarantee that any other ready threads
     266       // will run.   As such we revert yield_all() after some number of iterations.
     267       // Yield_all() is implemented as a short unconditional sleep on some platforms.
     268       // Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping
     269       // can actually increase the time it takes the VM thread to detect that a system-wide
     270       // stop-the-world safepoint has been reached.  In a pathological scenario such as that
     271       // described in CR6415670 the VMthread may sleep just before the mutator(s) become safe.
     272       // In that case the mutators will be stalled waiting for the safepoint to complete and the
     273       // the VMthread will be sleeping, waiting for the mutators to rendezvous.  The VMthread
     274       // will eventually wake up and detect that all mutators are safe, at which point
     275       // we'll again make progress.
     276       //
     277       // Beware too that that the VMThread typically runs at elevated priority.
     278       // Its default priority is higher than the default mutator priority.
     279       // Obviously, this complicates spinning.
     280       //
     281       // Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0).
     282       // Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will.
     283       //
     284       // See the comments in synchronizer.cpp for additional remarks on spinning.
     285       //
     286       // In the future we might:
     287       // 1. Modify the safepoint scheme to avoid potentally unbounded spinning.
     288       //    This is tricky as the path used by a thread exiting the JVM (say on
     289       //    on JNI call-out) simply stores into its state field.  The burden
     290       //    is placed on the VM thread, which must poll (spin).
     291       // 2. Find something useful to do while spinning.  If the safepoint is GC-related
     292       //    we might aggressively scan the stacks of threads that are already safe.
     293       // 3. Use Solaris schedctl to examine the state of the still-running mutators.
     294       //    If all the mutators are ONPROC there's no reason to sleep or yield.
     295       // 4. YieldTo() any still-running mutators that are ready but OFFPROC.
     296       // 5. Check system saturation.  If the system is not fully saturated then
     297       //    simply spin and avoid sleep/yield.
     298       // 6. As still-running mutators rendezvous they could unpark the sleeping
     299       //    VMthread.  This works well for still-running mutators that become
     300       //    safe.  The VMthread must still poll for mutators that call-out.
     301       // 7. Drive the policy on time-since-begin instead of iterations.
     302       // 8. Consider making the spin duration a function of the # of CPUs:
     303       //    Spin = (((ncpus-1) * M) + K) + F(still_running)
     304       //    Alternately, instead of counting iterations of the outer loop
     305       //    we could count the # of threads visited in the inner loop, above.
     306       // 9. On windows consider using the return value from SwitchThreadTo()
     307       //    to drive subsequent spin/SwitchThreadTo()/Sleep(N) decisions.
     308
     309       if (UseCompilerSafepoints && int(iterations) == DeferPollingPageLoopCount) {
     310          guarantee (PageArmed == 0, "invariant") ;
     311          PageArmed = 1 ;
     312          os::make_polling_page_unreadable();
     313       }
     314
     315       // Instead of (ncpus > 1) consider either (still_running < (ncpus + EPSILON)) or
     316       // ((still_running + _waiting_to_block - TryingToBlock)) < ncpus)
     317       ++steps ;
     318       if (ncpus > 1 && steps < SafepointSpinBeforeYield) {
     319         SpinPause() ;     // MP-Polite spin
     320       } else
     321       if (steps < DeferThrSuspendLoopCount) {
     322         os::NakedYield() ;
     323       } else {
     324         os::yield_all(steps) ;
     325         // Alternately, the VM thread could transiently depress its scheduling priority or
     326         // transiently increase the priority of the tardy mutator(s).
     327       }
     328
     329       iterations ++ ;
     330     }
     331     assert(iterations < (uint)max_jint, "We have been iterating in the safepoint loop too long");
     332   }
     333   assert(still_running == 0, "sanity check");
     334
     335   if (PrintSafepointStatistics) {
     336     update_statistics_on_spin_end();
     337   }
     338
     339   // wait until all threads are stopped
     340   while (_waiting_to_block > 0) {
     341     if (TraceSafepoint) tty->print_cr("Waiting for %d thread(s) to block", _waiting_to_block);
     342     if (!SafepointTimeout || timeout_error_printed) {
     343       Safepoint_lock->wait(true);  // true, means with no safepoint checks
     344     } else {
     345       // Compute remaining time
     346       jlong remaining_time = safepoint_limit_time - os::javaTimeNanos();
     347
     348       // If there is no remaining time, then there is an error
     349       if (remaining_time < 0 || Safepoint_lock->wait(true, remaining_time / MICROUNITS)) {
     350         print_safepoint_timeout(_blocking_timeout);
     351       }
     352     }
     353   }
     354   assert(_waiting_to_block == 0, "sanity check");
     355
     356 #ifndef PRODUCT
     357   if (SafepointTimeout) {
     358     jlong current_time = os::javaTimeNanos();
     359     if (safepoint_limit_time < current_time) {
     360       tty->print_cr("# SafepointSynchronize: Finished after "
     361                     INT64_FORMAT_W(6) " ms",
     362                     ((current_time - safepoint_limit_time) / MICROUNITS +
     363                      SafepointTimeoutDelay));
     364     }
     365   }
     366 #endif
     367
     368   assert((_safepoint_counter & 0x1) == 0, "must be even");
     369   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
     370   _safepoint_counter ++;
     371
     372   // Record state
     373   _state = _synchronized;
     374
     375   OrderAccess::fence();
     376
     377 #ifdef ASSERT
     378   for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {
     379     // make sure all the threads were visited
     380     assert(cur->was_visited_for_critical_count(), "missed a thread");
     381   }
     382 #endif // ASSERT
     383
     384   // Update the count of active JNI critical regions
     385   GC_locker::set_jni_lock_count(_current_jni_active_count);
     386
     387   if (TraceSafepoint) {
     388     VM_Operation *op = VMThread::vm_operation();
     389     tty->print_cr("Entering safepoint region: %s", (op != NULL) ? op->name() : "no vm operation");
     390   }
     391
     392   RuntimeService::record_safepoint_synchronized();
     393   if (PrintSafepointStatistics) {
     394     update_statistics_on_sync_end(os::javaTimeNanos());
     395   }
     396
     397   // Call stuff that needs to be run when a safepoint is just about to be completed
     398   do_cleanup_tasks();
     399
     400   if (PrintSafepointStatistics) {
     401     // Record how much time spend on the above cleanup tasks
     402     update_statistics_on_cleanup_end(os::javaTimeNanos());
     403   }
     404 }
     405
     406 // Wake up all threads, so they are ready to resume execution after the safepoint
     407 // operation has been carried out
     408 void SafepointSynchronize::end() {
     409
     410   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
     411   assert((_safepoint_counter & 0x1) == 1, "must be odd");
     412   _safepoint_counter ++;
     413   // memory fence isn't required here since an odd _safepoint_counter
     414   // value can do no harm and a fence is issued below anyway.
     415
     416   DEBUG_ONLY(Thread* myThread = Thread::current();)
     417   assert(myThread->is_VM_thread(), "Only VM thread can execute a safepoint");
     418
     419   if (PrintSafepointStatistics) {
     420     end_statistics(os::javaTimeNanos());
     421   }
     422
     423 #ifdef ASSERT
     424   // A pending_exception cannot be installed during a safepoint.  The threads
     425   // may install an async exception after they come back from a safepoint into
     426   // pending_exception after they unblock.  But that should happen later.
     427   for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) {
     428     assert (!(cur->has_pending_exception() &&
     429               cur->safepoint_state()->is_at_poll_safepoint()),
     430             "safepoint installed a pending exception");
     431   }
     432 #endif // ASSERT
     433
     434   if (PageArmed) {
     435     // Make polling safepoint aware
     436     os::make_polling_page_readable();
     437     PageArmed = 0 ;
     438   }
     439
     440   // Remove safepoint check from interpreter
     441   Interpreter::ignore_safepoints();
     442
     443   {
     444     MutexLocker mu(Safepoint_lock);
     445
     446     assert(_state == _synchronized, "must be synchronized before ending safepoint synchronization");
     447
     448     // Set to not synchronized, so the threads will not go into the signal_thread_blocked method
     449     // when they get restarted.
     450     _state = _not_synchronized;
     451     OrderAccess::fence();
     452
     453     if (TraceSafepoint) {
     454        tty->print_cr("Leaving safepoint region");
     455     }
     456
     457     // Start suspended threads
     458     for(JavaThread *current = Threads::first(); current; current = current->next()) {
     459       // A problem occurring on Solaris is when attempting to restart threads
     460       // the first #cpus - 1 go well, but then the VMThread is preempted when we get
     461       // to the next one (since it has been running the longest).  We then have
     462       // to wait for a cpu to become available before we can continue restarting
     463       // threads.
     464       // FIXME: This causes the performance of the VM to degrade when active and with
     465       // large numbers of threads.  Apparently this is due to the synchronous nature
     466       // of suspending threads.
     467       //
     468       // TODO-FIXME: the comments above are vestigial and no longer apply.
     469       // Furthermore, using solaris' schedctl in this particular context confers no benefit
     470       if (VMThreadHintNoPreempt) {
     471         os::hint_no_preempt();
     472       }
     473       ThreadSafepointState* cur_state = current->safepoint_state();
     474       assert(cur_state->type() != ThreadSafepointState::_running, "Thread not suspended at safepoint");
     475       cur_state->restart();
     476       assert(cur_state->is_running(), "safepoint state has not been reset");
     477     }
     478
     479     RuntimeService::record_safepoint_end();
     480
     481     // Release threads lock, so threads can be created/destroyed again. It will also starts all threads
     482     // blocked in signal_thread_blocked
     483     Threads_lock->unlock();
     484
     485   }
     486 #if INCLUDE_ALL_GCS
     487   // If there are any concurrent GC threads resume them.
     488   if (UseConcMarkSweepGC) {
     489     ConcurrentMarkSweepThread::desynchronize(false);
     490   } else if (UseG1GC) {
     491     SuspendibleThreadSet::desynchronize();
     492   }
     493 #endif // INCLUDE_ALL_GCS
     494   // record this time so VMThread can keep track how much time has elasped
     495   // since last safepoint.
     496   _end_of_last_safepoint = os::javaTimeMillis();
     497 }
     498
     499 bool SafepointSynchronize::is_cleanup_needed() {
     500   // Need a safepoint if some inline cache buffers is non-empty
     501   if (!InlineCacheBuffer::is_empty()) return true;
     502   return false;
     503 }
     504
     505
     506
     507 // Various cleaning tasks that should be done periodically at safepoints
     508 void SafepointSynchronize::do_cleanup_tasks() {
     509   {
     510     TraceTime t1("deflating idle monitors", TraceSafepointCleanupTime);
     511     ObjectSynchronizer::deflate_idle_monitors();
     512   }
     513
     514   {
     515     TraceTime t2("updating inline caches", TraceSafepointCleanupTime);
     516     InlineCacheBuffer::update_inline_caches();
     517   }
     518   {
     519     TraceTime t3("compilation policy safepoint handler", TraceSafepointCleanupTime);
     520     CompilationPolicy::policy()->do_safepoint_work();
     521   }
     522
     523   {
     524     TraceTime t4("mark nmethods", TraceSafepointCleanupTime);
     525     NMethodSweeper::mark_active_nmethods();
     526   }
     527
     528   if (SymbolTable::needs_rehashing()) {
     529     TraceTime t5("rehashing symbol table", TraceSafepointCleanupTime);
     530     SymbolTable::rehash_table();
     531   }
     532
     533   if (StringTable::needs_rehashing()) {
     534     TraceTime t6("rehashing string table", TraceSafepointCleanupTime);
     535     StringTable::rehash_table();
     536   }
     537
     538   // rotate log files?
     539   if (UseGCLogFileRotation) {
     540     gclog_or_tty->rotate_log(false);
     541   }
     542
     543   {
     544     // CMS delays purging the CLDG until the beginning of the next safepoint and to
     545     // make sure concurrent sweep is done
     546     TraceTime t7("purging class loader data graph", TraceSafepointCleanupTime);
     547     ClassLoaderDataGraph::purge_if_needed();
     548   }
     549 }
     550
     551
     552 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
     553   switch(state) {
     554   case _thread_in_native:
     555     // native threads are safe if they have no java stack or have walkable stack
     556     return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
     557
     558    // blocked threads should have already have walkable stack
     559   case _thread_blocked:
     560     assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
     561     return true;
     562
     563   default:
     564     return false;
     565   }
     566 }
     567
     568
     569 // See if the thread is running inside a lazy critical native and
     570 // update the thread critical count if so.  Also set a suspend flag to
     571 // cause the native wrapper to return into the JVM to do the unlock
     572 // once the native finishes.
     573 void SafepointSynchronize::check_for_lazy_critical_native(JavaThread *thread, JavaThreadState state) {
     574   if (state == _thread_in_native &&
     575       thread->has_last_Java_frame() &&
     576       thread->frame_anchor()->walkable()) {
     577     // This thread might be in a critical native nmethod so look at
     578     // the top of the stack and increment the critical count if it
     579     // is.
     580     frame wrapper_frame = thread->last_frame();
     581     CodeBlob* stub_cb = wrapper_frame.cb();
     582     if (stub_cb != NULL &&
     583         stub_cb->is_nmethod() &&
     584         stub_cb->as_nmethod_or_null()->is_lazy_critical_native()) {
     585       // A thread could potentially be in a critical native across
     586       // more than one safepoint, so only update the critical state on
     587       // the first one.  When it returns it will perform the unlock.
     588       if (!thread->do_critical_native_unlock()) {
     589 #ifdef ASSERT
     590         if (!thread->in_critical()) {
     591           GC_locker::increment_debug_jni_lock_count();
     592         }
     593 #endif
     594         thread->enter_critical();
     595         // Make sure the native wrapper calls back on return to
     596         // perform the needed critical unlock.
     597         thread->set_critical_native_unlock();
     598       }
     599     }
     600   }
     601 }
     602
     603
     604
     605 // -------------------------------------------------------------------------------------------------------
     606 // Implementation of Safepoint callback point
     607
     608 void SafepointSynchronize::block(JavaThread *thread) {
     609   assert(thread != NULL, "thread must be set");
     610   assert(thread->is_Java_thread(), "not a Java thread");
     611
     612   // Threads shouldn't block if they are in the middle of printing, but...
     613   ttyLocker::break_tty_lock_for_safepoint(os::current_thread_id());
     614
     615   // Only bail from the block() call if the thread is gone from the
     616   // thread list; starting to exit should still block.
     617   if (thread->is_terminated()) {
     618      // block current thread if we come here from native code when VM is gone
     619      thread->block_if_vm_exited();
     620
     621      // otherwise do nothing
     622      return;
     623   }
     624
     625   JavaThreadState state = thread->thread_state();
     626   thread->frame_anchor()->make_walkable(thread);
     627
     628   // Check that we have a valid thread_state at this point
     629   switch(state) {
     630     case _thread_in_vm_trans:
     631     case _thread_in_Java:        // From compiled code
     632
     633       // We are highly likely to block on the Safepoint_lock. In order to avoid blocking in this case,
     634       // we pretend we are still in the VM.
     635       thread->set_thread_state(_thread_in_vm);
     636
     637       if (is_synchronizing()) {
     638          Atomic::inc (&TryingToBlock) ;
     639       }
     640
     641       // We will always be holding the Safepoint_lock when we are examine the state
     642       // of a thread. Hence, the instructions between the Safepoint_lock->lock() and
     643       // Safepoint_lock->unlock() are happening atomic with regards to the safepoint code
     644       Safepoint_lock->lock_without_safepoint_check();
     645       if (is_synchronizing()) {
     646         // Decrement the number of threads to wait for and signal vm thread
     647         assert(_waiting_to_block > 0, "sanity check");
     648         _waiting_to_block--;
     649         thread->safepoint_state()->set_has_called_back(true);
     650
     651         DEBUG_ONLY(thread->set_visited_for_critical_count(true));
     652         if (thread->in_critical()) {
     653           // Notice that this thread is in a critical section
     654           increment_jni_active_count();
     655         }
     656
     657         // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread
     658         if (_waiting_to_block == 0) {
     659           Safepoint_lock->notify_all();
     660         }
     661       }
     662
     663       // We transition the thread to state _thread_blocked here, but
     664       // we can't do our usual check for external suspension and then
     665       // self-suspend after the lock_without_safepoint_check() call
     666       // below because we are often called during transitions while
     667       // we hold different locks. That would leave us suspended while
     668       // holding a resource which results in deadlocks.
     669       thread->set_thread_state(_thread_blocked);
     670       Safepoint_lock->unlock();
     671
     672       // We now try to acquire the threads lock. Since this lock is hold by the VM thread during
     673       // the entire safepoint, the threads will all line up here during the safepoint.
     674       Threads_lock->lock_without_safepoint_check();
     675       // restore original state. This is important if the thread comes from compiled code, so it
     676       // will continue to execute with the _thread_in_Java state.
     677       thread->set_thread_state(state);
     678       Threads_lock->unlock();
     679       break;
     680
     681     case _thread_in_native_trans:
     682     case _thread_blocked_trans:
     683     case _thread_new_trans:
     684       if (thread->safepoint_state()->type() == ThreadSafepointState::_call_back) {
     685         thread->print_thread_state();
     686         fatal("Deadlock in safepoint code.  "
     687               "Should have called back to the VM before blocking.");
     688       }
     689
     690       // We transition the thread to state _thread_blocked here, but
     691       // we can't do our usual check for external suspension and then
     692       // self-suspend after the lock_without_safepoint_check() call
     693       // below because we are often called during transitions while
     694       // we hold different locks. That would leave us suspended while
     695       // holding a resource which results in deadlocks.
     696       thread->set_thread_state(_thread_blocked);
     697
     698       // It is not safe to suspend a thread if we discover it is in _thread_in_native_trans. Hence,
     699       // the safepoint code might still be waiting for it to block. We need to change the state here,
     700       // so it can see that it is at a safepoint.
     701
     702       // Block until the safepoint operation is completed.
     703       Threads_lock->lock_without_safepoint_check();
     704
     705       // Restore state
     706       thread->set_thread_state(state);
     707
     708       Threads_lock->unlock();
     709       break;
     710
     711     default:
     712      fatal(err_msg("Illegal threadstate encountered: %d", state));
     713   }
     714
     715   // Check for pending. async. exceptions or suspends - except if the
     716   // thread was blocked inside the VM. has_special_runtime_exit_condition()
     717   // is called last since it grabs a lock and we only want to do that when
     718   // we must.
     719   //
     720   // Note: we never deliver an async exception at a polling point as the
     721   // compiler may not have an exception handler for it. The polling
     722   // code will notice the async and deoptimize and the exception will
     723   // be delivered. (Polling at a return point is ok though). Sure is
     724   // a lot of bother for a deprecated feature...
     725   //
     726   // We don't deliver an async exception if the thread state is
     727   // _thread_in_native_trans so JNI functions won't be called with
     728   // a surprising pending exception. If the thread state is going back to java,
     729   // async exception is checked in check_special_condition_for_native_trans().
     730
     731   if (state != _thread_blocked_trans &&
     732       state != _thread_in_vm_trans &&
     733       thread->has_special_runtime_exit_condition()) {
     734     thread->handle_special_runtime_exit_condition(
     735       !thread->is_at_poll_safepoint() && (state != _thread_in_native_trans));
     736   }
     737 }
     738
     739 // ------------------------------------------------------------------------------------------------------
     740 // Exception handlers
     741
     742 #ifndef PRODUCT
     743
     744 #ifdef SPARC
     745
     746 #ifdef _LP64
     747 #define PTR_PAD ""
     748 #else
     749 #define PTR_PAD "        "
     750 #endif
     751
     752 static void print_ptrs(intptr_t oldptr, intptr_t newptr, bool wasoop) {
     753   bool is_oop = newptr ? (cast_to_oop(newptr))->is_oop() : false;
     754   tty->print_cr(PTR_FORMAT PTR_PAD " %s %c " PTR_FORMAT PTR_PAD " %s %s",
     755                 oldptr, wasoop?"oop":"   ", oldptr == newptr ? ' ' : '!',
     756                 newptr, is_oop?"oop":"   ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":"     "));
     757 }
     758
     759 static void print_longs(jlong oldptr, jlong newptr, bool wasoop) {
     760   bool is_oop = newptr ? (cast_to_oop(newptr))->is_oop() : false;
     761   tty->print_cr(PTR64_FORMAT " %s %c " PTR64_FORMAT " %s %s",
     762                 oldptr, wasoop?"oop":"   ", oldptr == newptr ? ' ' : '!',
     763                 newptr, is_oop?"oop":"   ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":"     "));
     764 }
     765
     766 static void print_me(intptr_t *new_sp, intptr_t *old_sp, bool *was_oops) {
     767 #ifdef _LP64
     768   tty->print_cr("--------+------address-----+------before-----------+-------after----------+");
     769   const int incr = 1;           // Increment to skip a long, in units of intptr_t
     770 #else
     771   tty->print_cr("--------+--address-+------before-----------+-------after----------+");
     772   const int incr = 2;           // Increment to skip a long, in units of intptr_t
     773 #endif
     774   tty->print_cr("---SP---|");
     775   for( int i=0; i<16; i++ ) {
     776     tty->print("blob %c%d |"PTR_FORMAT" ","LO"[i>>3],i&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); }
     777   tty->print_cr("--------|");
     778   for( int i1=0; i1<frame::memory_parameter_word_sp_offset-16; i1++ ) {
     779     tty->print("argv pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); }
     780   tty->print("     pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++);
     781   tty->print_cr("--------|");
     782   tty->print(" G1     |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr;
     783   tty->print(" G3     |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr;
     784   tty->print(" G4     |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr;
     785   tty->print(" G5     |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr;
     786   tty->print_cr(" FSR    |"PTR_FORMAT" "PTR64_FORMAT"       "PTR64_FORMAT,new_sp,*(jlong*)old_sp,*(jlong*)new_sp);
     787   old_sp += incr; new_sp += incr; was_oops += incr;
     788   // Skip the floats
     789   tty->print_cr("--Float-|"PTR_FORMAT,new_sp);
     790   tty->print_cr("---FP---|");
     791   old_sp += incr*32;  new_sp += incr*32;  was_oops += incr*32;
     792   for( int i2=0; i2<16; i2++ ) {
     793     tty->print("call %c%d |"PTR_FORMAT" ","LI"[i2>>3],i2&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); }
     794   tty->cr();
     795 }
     796 #endif  // SPARC
     797 #endif  // PRODUCT
     798
     799
     800 void SafepointSynchronize::handle_polling_page_exception(JavaThread *thread) {
     801   assert(thread->is_Java_thread(), "polling reference encountered by VM thread");
     802   assert(thread->thread_state() == _thread_in_Java, "should come from Java code");
     803   assert(SafepointSynchronize::is_synchronizing(), "polling encountered outside safepoint synchronization");
     804
     805   // Uncomment this to get some serious before/after printing of the
     806   // Sparc safepoint-blob frame structure.
     807   /*
     808   intptr_t* sp = thread->last_Java_sp();
     809   intptr_t stack_copy[150];
     810   for( int i=0; i<150; i++ ) stack_copy[i] = sp[i];
     811   bool was_oops[150];
     812   for( int i=0; i<150; i++ )
     813     was_oops[i] = stack_copy[i] ? ((oop)stack_copy[i])->is_oop() : false;
     814   */
     815
     816   if (ShowSafepointMsgs) {
     817     tty->print("handle_polling_page_exception: ");
     818   }
     819
     820   if (PrintSafepointStatistics) {
     821     inc_page_trap_count();
     822   }
     823
     824   ThreadSafepointState* state = thread->safepoint_state();
     825
     826   state->handle_polling_page_exception();
     827   // print_me(sp,stack_copy,was_oops);
     828 }
     829
     830
     831 void SafepointSynchronize::print_safepoint_timeout(SafepointTimeoutReason reason) {
     832   if (!timeout_error_printed) {
     833     timeout_error_printed = true;
     834     // Print out the thread infor which didn't reach the safepoint for debugging
     835     // purposes (useful when there are lots of threads in the debugger).
     836     tty->cr();
     837     tty->print_cr("# SafepointSynchronize::begin: Timeout detected:");
     838     if (reason ==  _spinning_timeout) {
     839       tty->print_cr("# SafepointSynchronize::begin: Timed out while spinning to reach a safepoint.");
     840     } else if (reason == _blocking_timeout) {
     841       tty->print_cr("# SafepointSynchronize::begin: Timed out while waiting for threads to stop.");
     842     }
     843
     844     tty->print_cr("# SafepointSynchronize::begin: Threads which did not reach the safepoint:");
     845     ThreadSafepointState *cur_state;
     846     ResourceMark rm;
     847     for(JavaThread *cur_thread = Threads::first(); cur_thread;
     848         cur_thread = cur_thread->next()) {
     849       cur_state = cur_thread->safepoint_state();
     850
     851       if (cur_thread->thread_state() != _thread_blocked &&
     852           ((reason == _spinning_timeout && cur_state->is_running()) ||
     853            (reason == _blocking_timeout && !cur_state->has_called_back()))) {
     854         tty->print("# ");
     855         cur_thread->print();
     856         tty->cr();
     857       }
     858     }
     859     tty->print_cr("# SafepointSynchronize::begin: (End of list)");
     860   }
     861
     862   // To debug the long safepoint, specify both DieOnSafepointTimeout &
     863   // ShowMessageBoxOnError.
     864   if (DieOnSafepointTimeout) {
     865     char msg[1024];
     866     VM_Operation *op = VMThread::vm_operation();
     867     sprintf(msg, "Safepoint sync time longer than " INTX_FORMAT "ms detected when executing %s.",
     868             SafepointTimeoutDelay,
     869             op != NULL ? op->name() : "no vm operation");
     870     fatal(msg);
     871   }
     872 }
     873
     874
     875 // -------------------------------------------------------------------------------------------------------
     876 // Implementation of ThreadSafepointState
     877
     878 ThreadSafepointState::ThreadSafepointState(JavaThread *thread) {
     879   _thread = thread;
     880   _type   = _running;
     881   _has_called_back = false;
     882   _at_poll_safepoint = false;
     883 }
     884
     885 void ThreadSafepointState::create(JavaThread *thread) {
     886   ThreadSafepointState *state = new ThreadSafepointState(thread);
     887   thread->set_safepoint_state(state);
     888 }
     889
     890 void ThreadSafepointState::destroy(JavaThread *thread) {
     891   if (thread->safepoint_state()) {
     892     delete(thread->safepoint_state());
     893     thread->set_safepoint_state(NULL);
     894   }
     895 }
     896
     897 void ThreadSafepointState::examine_state_of_thread() {
     898   assert(is_running(), "better be running or just have hit safepoint poll");
     899
     900   JavaThreadState state = _thread->thread_state();
     901
     902   // Save the state at the start of safepoint processing.
     903   _orig_thread_state = state;
     904
     905   // Check for a thread that is suspended. Note that thread resume tries
     906   // to grab the Threads_lock which we own here, so a thread cannot be
     907   // resumed during safepoint synchronization.
     908
     909   // We check to see if this thread is suspended without locking to
     910   // avoid deadlocking with a third thread that is waiting for this
     911   // thread to be suspended. The third thread can notice the safepoint
     912   // that we're trying to start at the beginning of its SR_lock->wait()
     913   // call. If that happens, then the third thread will block on the
     914   // safepoint while still holding the underlying SR_lock. We won't be
     915   // able to get the SR_lock and we'll deadlock.
     916   //
     917   // We don't need to grab the SR_lock here for two reasons:
     918   // 1) The suspend flags are both volatile and are set with an
     919   //    Atomic::cmpxchg() call so we should see the suspended
     920   //    state right away.
     921   // 2) We're being called from the safepoint polling loop; if
     922   //    we don't see the suspended state on this iteration, then
     923   //    we'll come around again.
     924   //
     925   bool is_suspended = _thread->is_ext_suspended();
     926   if (is_suspended) {
     927     roll_forward(_at_safepoint);
     928     return;
     929   }
     930
     931   // Some JavaThread states have an initial safepoint state of
     932   // running, but are actually at a safepoint. We will happily
     933   // agree and update the safepoint state here.
     934   if (SafepointSynchronize::safepoint_safe(_thread, state)) {
     935     SafepointSynchronize::check_for_lazy_critical_native(_thread, state);
     936     roll_forward(_at_safepoint);
     937     return;
     938   }
     939
     940   if (state == _thread_in_vm) {
     941     roll_forward(_call_back);
     942     return;
     943   }
     944
     945   // All other thread states will continue to run until they
     946   // transition and self-block in state _blocked
     947   // Safepoint polling in compiled code causes the Java threads to do the same.
     948   // Note: new threads may require a malloc so they must be allowed to finish
     949
     950   assert(is_running(), "examine_state_of_thread on non-running thread");
     951   return;
     952 }
     953
     954 // Returns true is thread could not be rolled forward at present position.
     955 void ThreadSafepointState::roll_forward(suspend_type type) {
     956   _type = type;
     957
     958   switch(_type) {
     959     case _at_safepoint:
     960       SafepointSynchronize::signal_thread_at_safepoint();
     961       DEBUG_ONLY(_thread->set_visited_for_critical_count(true));
     962       if (_thread->in_critical()) {
     963         // Notice that this thread is in a critical section
     964         SafepointSynchronize::increment_jni_active_count();
     965       }
     966       break;
     967
     968     case _call_back:
     969       set_has_called_back(false);
     970       break;
     971
     972     case _running:
     973     default:
     974       ShouldNotReachHere();
     975   }
     976 }
     977
     978 void ThreadSafepointState::restart() {
     979   switch(type()) {
     980     case _at_safepoint:
     981     case _call_back:
     982       break;
     983
     984     case _running:
     985     default:
     986        tty->print_cr("restart thread "INTPTR_FORMAT" with state %d",
     987                       _thread, _type);
     988        _thread->print();
     989       ShouldNotReachHere();
     990   }
     991   _type = _running;
     992   set_has_called_back(false);
     993 }
     994
     995
     996 void ThreadSafepointState::print_on(outputStream *st) const {
     997   const char *s;
     998
     999   switch(_type) {
    1000     case _running                : s = "_running";              break;
    1001     case _at_safepoint           : s = "_at_safepoint";         break;
    1002     case _call_back              : s = "_call_back";            break;
    1003     default:
    1004       ShouldNotReachHere();
    1005   }
    1006
    1007   st->print_cr("Thread: " INTPTR_FORMAT
    1008               "  [0x%2x] State: %s _has_called_back %d _at_poll_safepoint %d",
    1009                _thread, _thread->osthread()->thread_id(), s, _has_called_back,
    1010                _at_poll_safepoint);
    1011
    1012   _thread->print_thread_state_on(st);
    1013 }
    1014
    1015
    1016 // ---------------------------------------------------------------------------------------------------------------------
    1017
    1018 // Block the thread at the safepoint poll or poll return.
    1019 void ThreadSafepointState::handle_polling_page_exception() {
    1020
    1021   // Check state.  block() will set thread state to thread_in_vm which will
    1022   // cause the safepoint state _type to become _call_back.
    1023   assert(type() == ThreadSafepointState::_running,
    1024          "polling page exception on thread not running state");
    1025
    1026   // Step 1: Find the nmethod from the return address
    1027   if (ShowSafepointMsgs && Verbose) {
    1028     tty->print_cr("Polling page exception at " INTPTR_FORMAT, thread()->saved_exception_pc());
    1029   }
    1030   address real_return_addr = thread()->saved_exception_pc();
    1031
    1032   CodeBlob *cb = CodeCache::find_blob(real_return_addr);
    1033   assert(cb != NULL && cb->is_nmethod(), "return address should be in nmethod");
    1034   nmethod* nm = (nmethod*)cb;
    1035
    1036   // Find frame of caller
    1037   frame stub_fr = thread()->last_frame();
    1038   CodeBlob* stub_cb = stub_fr.cb();
    1039   assert(stub_cb->is_safepoint_stub(), "must be a safepoint stub");
    1040   RegisterMap map(thread(), true);
    1041   frame caller_fr = stub_fr.sender(&map);
    1042
    1043   // Should only be poll_return or poll
    1044   assert( nm->is_at_poll_or_poll_return(real_return_addr), "should not be at call" );
    1045
    1046   // This is a poll immediately before a return. The exception handling code
    1047   // has already had the effect of causing the return to occur, so the execution
    1048   // will continue immediately after the call. In addition, the oopmap at the
    1049   // return point does not mark the return value as an oop (if it is), so
    1050   // it needs a handle here to be updated.
    1051   if( nm->is_at_poll_return(real_return_addr) ) {
    1052     // See if return type is an oop.
    1053     bool return_oop = nm->method()->is_returning_oop();
    1054     Handle return_value;
    1055     if (return_oop) {
    1056       // The oop result has been saved on the stack together with all
    1057       // the other registers. In order to preserve it over GCs we need
    1058       // to keep it in a handle.
    1059       oop result = caller_fr.saved_oop_result(&map);
    1060       assert(result == NULL || result->is_oop(), "must be oop");
    1061       return_value = Handle(thread(), result);
    1062       assert(Universe::heap()->is_in_or_null(result), "must be heap pointer");
    1063     }
    1064
    1065     // Block the thread
    1066     SafepointSynchronize::block(thread());
    1067
    1068     // restore oop result, if any
    1069     if (return_oop) {
    1070       caller_fr.set_saved_oop_result(&map, return_value());
    1071     }
    1072   }
    1073
    1074   // This is a safepoint poll. Verify the return address and block.
    1075   else {
    1076     set_at_poll_safepoint(true);
    1077
    1078     // verify the blob built the "return address" correctly
    1079     assert(real_return_addr == caller_fr.pc(), "must match");
    1080
    1081     // Block the thread
    1082     SafepointSynchronize::block(thread());
    1083     set_at_poll_safepoint(false);
    1084
    1085     // If we have a pending async exception deoptimize the frame
    1086     // as otherwise we may never deliver it.
    1087     if (thread()->has_async_condition()) {
    1088       ThreadInVMfromJavaNoAsyncException __tiv(thread());
    1089       Deoptimization::deoptimize_frame(thread(), caller_fr.id());
    1090     }
    1091
    1092     // If an exception has been installed we must check for a pending deoptimization
    1093     // Deoptimize frame if exception has been thrown.
    1094
    1095     if (thread()->has_pending_exception() ) {
    1096       RegisterMap map(thread(), true);
    1097       frame caller_fr = stub_fr.sender(&map);
    1098       if (caller_fr.is_deoptimized_frame()) {
    1099         // The exception patch will destroy registers that are still
    1100         // live and will be needed during deoptimization. Defer the
    1101         // Async exception should have defered the exception until the
    1102         // next safepoint which will be detected when we get into
    1103         // the interpreter so if we have an exception now things
    1104         // are messed up.
    1105
    1106         fatal("Exception installed and deoptimization is pending");
    1107       }
    1108     }
    1109   }
    1110 }
    1111
    1112
    1113 //
    1114 //                     Statistics & Instrumentations
    1115 //
    1116 SafepointSynchronize::SafepointStats*  SafepointSynchronize::_safepoint_stats = NULL;
    1117 jlong  SafepointSynchronize::_safepoint_begin_time = 0;
    1118 int    SafepointSynchronize::_cur_stat_index = 0;
    1119 julong SafepointSynchronize::_safepoint_reasons[VM_Operation::VMOp_Terminating];
    1120 julong SafepointSynchronize::_coalesced_vmop_count = 0;
    1121 jlong  SafepointSynchronize::_max_sync_time = 0;
    1122 jlong  SafepointSynchronize::_max_vmop_time = 0;
    1123 float  SafepointSynchronize::_ts_of_current_safepoint = 0.0f;
    1124
    1125 static jlong  cleanup_end_time = 0;
    1126 static bool   need_to_track_page_armed_status = false;
    1127 static bool   init_done = false;
    1128
    1129 // Helper method to print the header.
    1130 static void print_header() {
    1131   tty->print("         vmop                    "
    1132              "[threads: total initially_running wait_to_block]    ");
    1133   tty->print("[time: spin block sync cleanup vmop] ");
    1134
    1135   // no page armed status printed out if it is always armed.
    1136   if (need_to_track_page_armed_status) {
    1137     tty->print("page_armed ");
    1138   }
    1139
    1140   tty->print_cr("page_trap_count");
    1141 }
    1142
    1143 void SafepointSynchronize::deferred_initialize_stat() {
    1144   if (init_done) return;
    1145
    1146   if (PrintSafepointStatisticsCount <= 0) {
    1147     fatal("Wrong PrintSafepointStatisticsCount");
    1148   }
    1149
    1150   // If PrintSafepointStatisticsTimeout is specified, the statistics data will
    1151   // be printed right away, in which case, _safepoint_stats will regress to
    1152   // a single element array. Otherwise, it is a circular ring buffer with default
    1153   // size of PrintSafepointStatisticsCount.
    1154   int stats_array_size;
    1155   if (PrintSafepointStatisticsTimeout > 0) {
    1156     stats_array_size = 1;
    1157     PrintSafepointStatistics = true;
    1158   } else {
    1159     stats_array_size = PrintSafepointStatisticsCount;
    1160   }
    1161   _safepoint_stats = (SafepointStats*)os::malloc(stats_array_size
    1162                                                  * sizeof(SafepointStats), mtInternal);
    1163   guarantee(_safepoint_stats != NULL,
    1164             "not enough memory for safepoint instrumentation data");
    1165
    1166   if (UseCompilerSafepoints && DeferPollingPageLoopCount >= 0) {
    1167     need_to_track_page_armed_status = true;
    1168   }
    1169   init_done = true;
    1170 }
    1171
    1172 void SafepointSynchronize::begin_statistics(int nof_threads, int nof_running) {
    1173   assert(init_done, "safepoint statistics array hasn't been initialized");
    1174   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1175
    1176   spstat->_time_stamp = _ts_of_current_safepoint;
    1177
    1178   VM_Operation *op = VMThread::vm_operation();
    1179   spstat->_vmop_type = (op != NULL ? op->type() : -1);
    1180   if (op != NULL) {
    1181     _safepoint_reasons[spstat->_vmop_type]++;
    1182   }
    1183
    1184   spstat->_nof_total_threads = nof_threads;
    1185   spstat->_nof_initial_running_threads = nof_running;
    1186   spstat->_nof_threads_hit_page_trap = 0;
    1187
    1188   // Records the start time of spinning. The real time spent on spinning
    1189   // will be adjusted when spin is done. Same trick is applied for time
    1190   // spent on waiting for threads to block.
    1191   if (nof_running != 0) {
    1192     spstat->_time_to_spin = os::javaTimeNanos();
    1193   }  else {
    1194     spstat->_time_to_spin = 0;
    1195   }
    1196 }
    1197
    1198 void SafepointSynchronize::update_statistics_on_spin_end() {
    1199   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1200
    1201   jlong cur_time = os::javaTimeNanos();
    1202
    1203   spstat->_nof_threads_wait_to_block = _waiting_to_block;
    1204   if (spstat->_nof_initial_running_threads != 0) {
    1205     spstat->_time_to_spin = cur_time - spstat->_time_to_spin;
    1206   }
    1207
    1208   if (need_to_track_page_armed_status) {
    1209     spstat->_page_armed = (PageArmed == 1);
    1210   }
    1211
    1212   // Records the start time of waiting for to block. Updated when block is done.
    1213   if (_waiting_to_block != 0) {
    1214     spstat->_time_to_wait_to_block = cur_time;
    1215   } else {
    1216     spstat->_time_to_wait_to_block = 0;
    1217   }
    1218 }
    1219
    1220 void SafepointSynchronize::update_statistics_on_sync_end(jlong end_time) {
    1221   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1222
    1223   if (spstat->_nof_threads_wait_to_block != 0) {
    1224     spstat->_time_to_wait_to_block = end_time -
    1225       spstat->_time_to_wait_to_block;
    1226   }
    1227
    1228   // Records the end time of sync which will be used to calculate the total
    1229   // vm operation time. Again, the real time spending in syncing will be deducted
    1230   // from the start of the sync time later when end_statistics is called.
    1231   spstat->_time_to_sync = end_time - _safepoint_begin_time;
    1232   if (spstat->_time_to_sync > _max_sync_time) {
    1233     _max_sync_time = spstat->_time_to_sync;
    1234   }
    1235
    1236   spstat->_time_to_do_cleanups = end_time;
    1237 }
    1238
    1239 void SafepointSynchronize::update_statistics_on_cleanup_end(jlong end_time) {
    1240   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1241
    1242   // Record how long spent in cleanup tasks.
    1243   spstat->_time_to_do_cleanups = end_time - spstat->_time_to_do_cleanups;
    1244
    1245   cleanup_end_time = end_time;
    1246 }
    1247
    1248 void SafepointSynchronize::end_statistics(jlong vmop_end_time) {
    1249   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1250
    1251   // Update the vm operation time.
    1252   spstat->_time_to_exec_vmop = vmop_end_time -  cleanup_end_time;
    1253   if (spstat->_time_to_exec_vmop > _max_vmop_time) {
    1254     _max_vmop_time = spstat->_time_to_exec_vmop;
    1255   }
    1256   // Only the sync time longer than the specified
    1257   // PrintSafepointStatisticsTimeout will be printed out right away.
    1258   // By default, it is -1 meaning all samples will be put into the list.
    1259   if ( PrintSafepointStatisticsTimeout > 0) {
    1260     if (spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) {
    1261       print_statistics();
    1262     }
    1263   } else {
    1264     // The safepoint statistics will be printed out when the _safepoin_stats
    1265     // array fills up.
    1266     if (_cur_stat_index == PrintSafepointStatisticsCount - 1) {
    1267       print_statistics();
    1268       _cur_stat_index = 0;
    1269     } else {
    1270       _cur_stat_index++;
    1271     }
    1272   }
    1273 }
    1274
    1275 void SafepointSynchronize::print_statistics() {
    1276   SafepointStats* sstats = _safepoint_stats;
    1277
    1278   for (int index = 0; index <= _cur_stat_index; index++) {
    1279     if (index % 30 == 0) {
    1280       print_header();
    1281     }
    1282     sstats = &_safepoint_stats[index];
    1283     tty->print("%.3f: ", sstats->_time_stamp);
    1284     tty->print("%-26s       ["
    1285                INT32_FORMAT_W(8)INT32_FORMAT_W(11)INT32_FORMAT_W(15)
    1286                "    ]    ",
    1287                sstats->_vmop_type == -1 ? "no vm operation" :
    1288                VM_Operation::name(sstats->_vmop_type),
    1289                sstats->_nof_total_threads,
    1290                sstats->_nof_initial_running_threads,
    1291                sstats->_nof_threads_wait_to_block);
    1292     // "/ MICROUNITS " is to convert the unit from nanos to millis.
    1293     tty->print("  ["
    1294                INT64_FORMAT_W(6)INT64_FORMAT_W(6)
    1295                INT64_FORMAT_W(6)INT64_FORMAT_W(6)
    1296                INT64_FORMAT_W(6)"    ]  ",
    1297                sstats->_time_to_spin / MICROUNITS,
    1298                sstats->_time_to_wait_to_block / MICROUNITS,
    1299                sstats->_time_to_sync / MICROUNITS,
    1300                sstats->_time_to_do_cleanups / MICROUNITS,
    1301                sstats->_time_to_exec_vmop / MICROUNITS);
    1302
    1303     if (need_to_track_page_armed_status) {
    1304       tty->print(INT32_FORMAT"         ", sstats->_page_armed);
    1305     }
    1306     tty->print_cr(INT32_FORMAT"   ", sstats->_nof_threads_hit_page_trap);
    1307   }
    1308 }
    1309
    1310 // This method will be called when VM exits. It will first call
    1311 // print_statistics to print out the rest of the sampling.  Then
    1312 // it tries to summarize the sampling.
    1313 void SafepointSynchronize::print_stat_on_exit() {
    1314   if (_safepoint_stats == NULL) return;
    1315
    1316   SafepointStats *spstat = &_safepoint_stats[_cur_stat_index];
    1317
    1318   // During VM exit, end_statistics may not get called and in that
    1319   // case, if the sync time is less than PrintSafepointStatisticsTimeout,
    1320   // don't print it out.
    1321   // Approximate the vm op time.
    1322   _safepoint_stats[_cur_stat_index]._time_to_exec_vmop =
    1323     os::javaTimeNanos() - cleanup_end_time;
    1324
    1325   if ( PrintSafepointStatisticsTimeout < 0 ||
    1326        spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) {
    1327     print_statistics();
    1328   }
    1329   tty->cr();
    1330
    1331   // Print out polling page sampling status.
    1332   if (!need_to_track_page_armed_status) {
    1333     if (UseCompilerSafepoints) {
    1334       tty->print_cr("Polling page always armed");
    1335     }
    1336   } else {
    1337     tty->print_cr("Defer polling page loop count = %d\n",
    1338                  DeferPollingPageLoopCount);
    1339   }
    1340
    1341   for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) {
    1342     if (_safepoint_reasons[index] != 0) {
    1343       tty->print_cr("%-26s"UINT64_FORMAT_W(10), VM_Operation::name(index),
    1344                     _safepoint_reasons[index]);
    1345     }
    1346   }
    1347
    1348   tty->print_cr(UINT64_FORMAT_W(5)" VM operations coalesced during safepoint",
    1349                 _coalesced_vmop_count);
    1350   tty->print_cr("Maximum sync time  "INT64_FORMAT_W(5)" ms",
    1351                 _max_sync_time / MICROUNITS);
    1352   tty->print_cr("Maximum vm operation time (except for Exit VM operation)  "
    1353                 INT64_FORMAT_W(5)" ms",
    1354                 _max_vmop_time / MICROUNITS);
    1355 }
    1356
    1357 // ------------------------------------------------------------------------------------------------
    1358 // Non-product code
    1359
    1360 #ifndef PRODUCT
    1361
    1362 void SafepointSynchronize::print_state() {
    1363   if (_state == _not_synchronized) {
    1364     tty->print_cr("not synchronized");
    1365   } else if (_state == _synchronizing || _state == _synchronized) {
    1366     tty->print_cr("State: %s", (_state == _synchronizing) ? "synchronizing" :
    1367                   "synchronized");
    1368
    1369     for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) {
    1370        cur->safepoint_state()->print();
    1371     }
    1372   }
    1373 }
    1374
    1375 void SafepointSynchronize::safepoint_msg(const char* format, ...) {
    1376   if (ShowSafepointMsgs) {
    1377     va_list ap;
    1378     va_start(ap, format);
    1379     tty->vprint_cr(format, ap);
    1380     va_end(ap);
    1381   }
    1382 }
    1383
    1384 #endif // !PRODUCT