static void post_safepoint_begin_event(EventSafepointBegin& event,

                                       uint64_t safepoint_id,

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.set_totalThreadCount(thread_count);

    event.set_jniCriticalThreadCount(critical_thread_count);

    event.commit();

  }

static void post_safepoint_cleanup_event(EventSafepointCleanup& event, uint64_t safepoint_id) {

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.commit();

static void post_safepoint_synchronize_event(EventSafepointStateSynchronization& event,

                                             uint64_t safepoint_id,

                                             int initial_number_of_threads,

                                             int threads_waiting_to_block,

                                             uint64_t iterations) {

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.set_initialThreadCount(initial_number_of_threads);

    event.set_runningThreadCount(threads_waiting_to_block);

    event.set_iterations(iterations);

    event.commit();

static void post_safepoint_wait_blocked_event(EventSafepointWaitBlocked& event,

                                              uint64_t safepoint_id,

                                              int initial_threads_waiting_to_block) {

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.set_runningThreadCount(initial_threads_waiting_to_block);

    event.commit();

  }

}

static void post_safepoint_cleanup_task_event(EventSafepointCleanupTask& event,

                                              uint64_t safepoint_id,

                                              const char* name) {

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.set_name(name);

    event.commit();

  }

}

static void post_safepoint_end_event(EventSafepointEnd& event, uint64_t safepoint_id) {

  if (event.should_commit()) {

    event.set_safepointId(safepoint_id);

    event.commit();

int SafepointSynchronize::_waiting_to_block = 0;

const uint64_t SafepointSynchronize::InactiveSafepointCounter = 0;

long SafepointSynchronize::_end_of_last_safepoint = 0;

WaitBarrier* SafepointSynchronize::_wait_barrier;

// We need a place to save the desc since it is released before we need it.

static char stopped_description[64] = "";

static bool _vm_is_waiting = false;

static volatile bool PageArmed = false;        // safepoint polling page is RO|RW vs PROT_NONE

// Statistic related

void SafepointSynchronize::init(Thread* vmthread) {

  // WaitBarrier should never be destroyed since we will have

  // threads waiting on it while exiting.

  _wait_barrier = new WaitBarrier(vmthread);

}

void SafepointSynchronize::increment_jni_active_count() {

  assert(Thread::current()->is_VM_thread(), "Only VM thread may increment");

  ++_current_jni_active_count;

}

void SafepointSynchronize::decrement_waiting_to_block() {

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

  assert(Thread::current()->is_VM_thread(), "Only VM thread may decrement");

  --_waiting_to_block;

}

static bool thread_not_running(ThreadSafepointState *cur_state) {

  if (!cur_state->is_running()) {

    return true;

  }

  cur_state->examine_state_of_thread(SafepointSynchronize::safepoint_counter());

  if (!cur_state->is_running()) {

    return true;

  }

  LogTarget(Trace, safepoint) lt;

  if (lt.is_enabled()) {

    ResourceMark rm;

    LogStream ls(lt);

    cur_state->print_on(&ls);

  }

  return false;

}

#ifdef ASSERT

static void assert_list_is_valid(const ThreadSafepointState* tss_head, int still_running) {

  int a = 0;

  const ThreadSafepointState *tmp_tss = tss_head;

  while (tmp_tss != NULL) {

    ++a;

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

    tmp_tss = tmp_tss->get_next();

  }

  assert(a == still_running, "Must be the same");

}

#endif // ASSERT

static void back_off(int iteration) {

  // iteration will be 1 the first time we enter this spin back-off.

  // naked_short_nanosleep takes tenths of micros which means that

  // number of nanoseconds is irrelevant if it's below that. We do

  // 20 1 ns sleeps with a total cost of ~1 ms, then we do 1 ms sleeps.

  jlong sleep_ns = 1;

  if (iteration > 20) {

    sleep_ns = NANOUNITS / MILLIUNITS;  // 1 ms

  }

  os::naked_short_nanosleep(sleep_ns);

}

int SafepointSynchronize::synchronize_threads(jlong safepoint_limit_time, int nof_threads, int* initial_running)

{

  JavaThreadIteratorWithHandle jtiwh;

#ifdef ASSERT

  for (; JavaThread *cur = jtiwh.next(); ) {

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

  }

  jtiwh.rewind();

#endif // ASSERT

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

  int still_running = nof_threads;

  ThreadSafepointState *tss_head = NULL;

  ThreadSafepointState **p_prev = &tss_head;

  for (; JavaThread *cur = jtiwh.next(); ) {

    ThreadSafepointState *cur_tss = cur->safepoint_state();

    assert(cur_tss->get_next() == NULL, "Must be NULL");

    if (thread_not_running(cur_tss)) {

      --still_running;

    } else {

      *p_prev = cur_tss;

      p_prev = cur_tss->next_ptr();

    }

  }

  *p_prev = NULL;

  DEBUG_ONLY(assert_list_is_valid(tss_head, still_running);)

  *initial_running = still_running;

    begin_statistics(nof_threads, still_running);

  int iterations = 1; // The first iteration is above.

  while (still_running > 0) {

    // Check if this has taken too long:

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

      print_safepoint_timeout(_spinning_timeout);

    }

    if (int(iterations) == -1) { // overflow - something is wrong.

      // We can only overflow here when we are using global

      // polling pages. We keep this guarantee in its original

      // form so that searches of the bug database for this

      // failure mode find the right bugs.

      guarantee (!PageArmed, "invariant");

    }

    p_prev = &tss_head;

    ThreadSafepointState *cur_tss = tss_head;

    while (cur_tss != NULL) {

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

      if (thread_not_running(cur_tss)) {

        --still_running;

        *p_prev = NULL;

        ThreadSafepointState *tmp = cur_tss;

        cur_tss = cur_tss->get_next();

        tmp->set_next(NULL);

      } else {

        *p_prev = cur_tss;

        p_prev = cur_tss->next_ptr();

        cur_tss = cur_tss->get_next();

      }

    }

    DEBUG_ONLY(assert_list_is_valid(tss_head, still_running);)

    if (still_running > 0) {

      back_off(iterations);

    }

    iterations++;

  }

  assert(tss_head == NULL, "Must be empty");

  if (log_is_enabled(Debug, safepoint, stats)) {

    update_statistics_on_spin_end();

  }

  return iterations;

}

void SafepointSynchronize::arm_safepoint() {

  //     Compiled code reads the local polling page that

  // We must never miss a thread with correct safepoint id, so we must make sure we arm

  // the wait barrier for the next safepoint id/counter.

  // Arming must be done after resetting _current_jni_active_count, _waiting_to_block.

  _wait_barrier->arm(static_cast<int>(_safepoint_counter + 1));

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

  // The store to _safepoint_counter must happen after any stores in arming.

  OrderAccess::release_store(&_safepoint_counter, _safepoint_counter + 1);

  // We are synchronizing

  OrderAccess::storestore(); // Ordered with _safepoint_counter

  _state = _synchronizing;

  if (SafepointMechanism::uses_thread_local_poll()) {

    // Arming the per thread poll while having _state != _not_synchronized means safepointing

    log_trace(safepoint)("Setting thread local yield flag for threads");

    OrderAccess::storestore(); // storestore, global state -> local state

    for (JavaThreadIteratorWithHandle jtiwh; JavaThread *cur = jtiwh.next(); ) {

      // Make sure the threads start polling, it is time to yield.

      SafepointMechanism::arm_local_poll(cur);

  OrderAccess::fence(); // storestore|storeload, global state -> local state

  if (SafepointMechanism::uses_global_page_poll()) {

    // Make interpreter safepoint aware

    Interpreter::notice_safepoints();

    // Make polling safepoint aware

    guarantee (!PageArmed, "invariant") ;

    PageArmed = true;

    os::make_polling_page_unreadable();

  }

}

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

void SafepointSynchronize::begin() {

  EventSafepointBegin begin_event;

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

  strncpy(stopped_description, VMThread::vm_safepoint_description(), sizeof(stopped_description) - 1);

  stopped_description[sizeof(stopped_description) - 1] = '\0';

  if (log_is_enabled(Debug, safepoint, stats)) {

    _safepoint_begin_time = os::javaTimeNanos();

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

    _nof_threads_hit_polling_page = 0;

  }

  Universe::heap()->safepoint_synchronize_begin();

  // 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 using %s wait barrier. (%d threads)", _wait_barrier->description(), nof_threads);

  RuntimeService::record_safepoint_begin();

  // Reset the count of active JNI critical threads

  _current_jni_active_count = 0;

  // Set number of threads to wait for

  _waiting_to_block = nof_threads;

  jlong safepoint_limit_time = 0;

  if (SafepointTimeout) {

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

    // too long to complete.

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

  }

  timeout_error_printed = false;

  EventSafepointStateSynchronization sync_event;

  int initial_running = 0;

  // Arms the safepoint, _current_jni_active_count and _waiting_to_block must be set before.

  arm_safepoint();

  // Will spin until all threads are safe.

  int iterations = synchronize_threads(safepoint_limit_time, nof_threads, &initial_running);

  assert(_waiting_to_block == 0, "No thread should be running");

  post_safepoint_synchronize_event(sync_event, _safepoint_counter, initial_running,

                                   _waiting_to_block, iterations);

  // Keep event from now.

  EventSafepointWaitBlocked wait_blocked_event;

  if (SafepointTimeout) {

    jlong current_time = os::javaTimeNanos();

    if (safepoint_limit_time < current_time) {

      log_warning(safepoint)("# SafepointSynchronize: Finished after "

                    INT64_FORMAT_W(6) " ms",

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

                              (jlong)SafepointTimeoutDelay));

  }

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

  // Record state

  _state = _synchronized;

  OrderAccess::fence();

  post_safepoint_wait_blocked_event(wait_blocked_event, _safepoint_counter, 0);

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

  log_info(safepoint)("Entering safepoint region: %s", stopped_description);

  // We do the safepoint cleanup first since a GC related safepoint

  // needs cleanup to be completed before running the GC op.

  EventSafepointCleanup cleanup_event;

  do_cleanup_tasks();

  post_safepoint_cleanup_event(cleanup_event, _safepoint_counter);

  post_safepoint_begin_event(begin_event, _safepoint_counter, nof_threads, _current_jni_active_count);

void SafepointSynchronize::disarm_safepoint() {

  uint64_t safepoint_id = _safepoint_counter;

    if (SafepointMechanism::uses_global_page_poll()) {

      guarantee (PageArmed, "invariant");