/*

 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "code/codeCache.hpp"

#include "code/icBuffer.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "code/scopeDesc.hpp"

#include "gc/shared/collectedHeap.hpp"

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

#include "gc/shared/strongRootsScope.hpp"

#include "gc/shared/workgroup.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "runtime/atomic.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/orderAccess.inline.hpp"

#include "runtime/osThread.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/sweeper.hpp"

#include "runtime/synchronizer.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/timerTrace.hpp"

#include "services/runtimeService.hpp"

#include "trace/tracing.hpp"

#include "trace/traceMacros.hpp"

#include "utilities/events.hpp"

#include "utilities/macros.hpp"

#if INCLUDE_ALL_GCS

#include "gc/cms/concurrentMarkSweepThread.hpp"

#include "gc/g1/suspendibleThreadSet.hpp"

#endif // INCLUDE_ALL_GCS

#ifdef COMPILER1

#include "c1/c1_globals.hpp"

#endif

// --------------------------------------------------------------------------------------------------

// Implementation of Safepoint begin/end

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

volatile int  SafepointSynchronize::_waiting_to_block = 0;

volatile int SafepointSynchronize::_safepoint_counter = 0;

int SafepointSynchronize::_current_jni_active_count = 0;

long  SafepointSynchronize::_end_of_last_safepoint = 0;

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

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

static bool timeout_error_printed = false;

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

void SafepointSynchronize::begin() {

  EventSafepointBegin begin_event;

  Thread* myThread = Thread::current();

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

  if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {

    _safepoint_begin_time = os::javaTimeNanos();

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

  }

#if INCLUDE_ALL_GCS

  if (UseConcMarkSweepGC) {

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

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

    ConcurrentMarkSweepThread::synchronize(false);

  } else if (UseG1GC) {

    SuspendibleThreadSet::synchronize();

  }

#endif // INCLUDE_ALL_GCS

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

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

  Threads_lock->lock();

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

  int nof_threads = Threads::number_of_threads();

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

  RuntimeService::record_safepoint_begin();

  MutexLocker mu(Safepoint_lock);

  // Reset the count of active JNI critical threads

  _current_jni_active_count = 0;

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

  _waiting_to_block = nof_threads;

  TryingToBlock     = 0 ;

  int still_running = nof_threads;

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

  // too long to complete.

  jlong safepoint_limit_time = 0;

  timeout_error_printed = false;

  // PrintSafepointStatisticsTimeout can be specified separately. When

  // specified, PrintSafepointStatistics will be set to true in

  // deferred_initialize_stat method. The initialization has to be done

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

  if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {

    deferred_initialize_stat();

  }

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

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

  // stopped by different mechanisms:

  //

  //  1. Running interpreted

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

  //     check for a safepoint condition between bytecodes.

  //  2. Running in native code

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

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

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

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

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

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

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

  //     the VM thread issues a memory barrier instruction

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

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

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

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

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

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

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

  //     much more efficient than executing a membar instruction

  //     on every call to native code.

  //  3. Running compiled Code

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

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

  //  4. Blocked

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

  //     block condition until the safepoint operation is complete.

  //  5. In VM or Transitioning between states

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

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

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

  //

  {

    EventSafepointStateSynchronization sync_event;

    int initial_running = 0;

    _state            = _synchronizing;

    OrderAccess::fence();

    // Flush all thread states to memory

    if (!UseMembar) {

      os::serialize_thread_states();

    }

    // Make interpreter safepoint aware

    Interpreter::notice_safepoints();

    if (DeferPollingPageLoopCount < 0) {

      // Make polling safepoint aware

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

      PageArmed = 1 ;

      os::make_polling_page_unreadable();

    }

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

    int ncpus = os::processor_count() ;

#ifdef ASSERT

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

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

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

      cur->set_visited_for_critical_count(false);

    }

#endif // ASSERT

    if (SafepointTimeout)

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

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

    unsigned int iterations = 0;

    int steps = 0 ;

    while(still_running > 0) {

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

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

        ThreadSafepointState *cur_state = cur->safepoint_state();

        if (cur_state->is_running()) {

          cur_state->examine_state_of_thread();

          if (!cur_state->is_running()) {

            still_running--;

            // consider adjusting steps downward:

            //   steps = 0

            //   steps -= NNN

            //   steps >>= 1

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

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

          }

          LogTarget(Trace, safepoint) lt;

          if (lt.is_enabled()) {

            ResourceMark rm;

            LogStream ls(lt);

            cur_state->print_on(&ls);

          }

        }

      }

      if (iterations == 0) {

        initial_running = still_running;

        if (PrintSafepointStatistics) {

          begin_statistics(nof_threads, still_running);

        }

      }

      if (still_running > 0) {

        // Check for if it takes to long

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

          print_safepoint_timeout(_spinning_timeout);

        }

        // Spin to avoid context switching.

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

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

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

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

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

        // and the resultant loss of $ residency.

        //

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

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

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

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

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

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

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

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

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

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

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

        // we'll again make progress.

        //

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

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

        // Obviously, this complicates spinning.

        //

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

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

        //

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

        //

        // In the future we might:

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

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

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

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

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

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

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

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

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

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

        //    simply spin and avoid sleep/yield.

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

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

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

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

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

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

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

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

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

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

        if (int(iterations) == DeferPollingPageLoopCount) {

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

          PageArmed = 1 ;

          os::make_polling_page_unreadable();

        }

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

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

        ++steps ;

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

          SpinPause() ;     // MP-Polite spin

        } else

          if (steps < DeferThrSuspendLoopCount) {

            os::naked_yield() ;

          } else {

            os::naked_short_sleep(1);

          }

        iterations ++ ;

      }

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

    }

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

    if (PrintSafepointStatistics) {

      update_statistics_on_spin_end();

    }

    if (sync_event.should_commit()) {

      sync_event.set_safepointId(safepoint_counter());

      sync_event.set_initialThreadCount(initial_running);

      sync_event.set_runningThreadCount(_waiting_to_block);

      sync_event.set_iterations(iterations);

      sync_event.commit();

    }

  } //EventSafepointStateSync

  // wait until all threads are stopped

  {

    EventSafepointWaitBlocked wait_blocked_event;

    int initial_waiting_to_block = _waiting_to_block;

    while (_waiting_to_block > 0) {

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

      if (!SafepointTimeout || timeout_error_printed) {

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

      } else {

        // Compute remaining time

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

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

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

          print_safepoint_timeout(_blocking_timeout);

        }

      }

    }

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

#ifndef PRODUCT

    if (SafepointTimeout) {

      jlong current_time = os::javaTimeNanos();

      if (safepoint_limit_time < current_time) {

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

                      INT64_FORMAT_W(6) " ms",

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

                                (jlong)SafepointTimeoutDelay));

      }

    }

#endif

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

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

    _safepoint_counter ++;

    // Record state

    _state = _synchronized;

    OrderAccess::fence();

    if (wait_blocked_event.should_commit()) {

      wait_blocked_event.set_safepointId(safepoint_counter());

      wait_blocked_event.set_runningThreadCount(initial_waiting_to_block);

      wait_blocked_event.commit();

    }

  } // EventSafepointWaitBlocked

#ifdef ASSERT

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

    // make sure all the threads were visited

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

  }

#endif // ASSERT

  // Update the count of active JNI critical regions

  GCLocker::set_jni_lock_count(_current_jni_active_count);

  if (log_is_enabled(Debug, safepoint)) {

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

  }

  RuntimeService::record_safepoint_synchronized();

  if (PrintSafepointStatistics) {

    update_statistics_on_sync_end(os::javaTimeNanos());

  }

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

  {

    EventSafepointCleanup cleanup_event;

    do_cleanup_tasks();

    if (cleanup_event.should_commit()) {

      cleanup_event.set_safepointId(safepoint_counter());

      cleanup_event.commit();

    }

  }

  if (PrintSafepointStatistics) {

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

    update_statistics_on_cleanup_end(os::javaTimeNanos());

  }

  if (begin_event.should_commit()) {

    begin_event.set_safepointId(safepoint_counter());

    begin_event.set_totalThreadCount(nof_threads);

    begin_event.set_jniCriticalThreadCount(_current_jni_active_count);

    begin_event.commit();

  }

}

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

// operation has been carried out

void SafepointSynchronize::end() {

  EventSafepointEnd event;

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

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

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

  _safepoint_counter ++;

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

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

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

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

  if (PrintSafepointStatistics) {

    end_statistics(os::javaTimeNanos());

  }

#ifdef ASSERT

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

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

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

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

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

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

            "safepoint installed a pending exception");

  }

#endif // ASSERT

  if (PageArmed) {

    // Make polling safepoint aware

    os::make_polling_page_readable();

    PageArmed = 0 ;

  }

  // Remove safepoint check from interpreter

  Interpreter::ignore_safepoints();

  {

    MutexLocker mu(Safepoint_lock);

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

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

    // when they get restarted.

    _state = _not_synchronized;

    OrderAccess::fence();

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

    // Start suspended threads

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

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

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

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

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

      // threads.

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

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

      // of suspending threads.

      //

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

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

      if (VMThreadHintNoPreempt) {

        os::hint_no_preempt();

      }

      ThreadSafepointState* cur_state = current->safepoint_state();