jdk-sandbox: comparison hotspot/src/share/vm/runtime/safepoint.cpp

equal deleted inserted replaced

-:ac6850d71f72
+:663bdc7d0b86
 #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"
 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();
 //  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.
 //
-_state            = _synchronizing;
+{
-OrderAccess::fence();
+EventSafepointStateSync sync_event;
+int initial_running = 0;
-// Flush all thread states to memory
-if (!UseMembar) {
+_state            = _synchronizing;
-os::serialize_thread_states();
+OrderAccess::fence();
-}
+// Flush all thread states to memory
-// Make interpreter safepoint aware
+if (!UseMembar) {
-Interpreter::notice_safepoints();
+os::serialize_thread_states();
+}
-if (DeferPollingPageLoopCount < 0) {
-// Make polling safepoint aware
+// Make interpreter safepoint aware
-guarantee (PageArmed == 0, "invariant") ;
+Interpreter::notice_safepoints();
-PageArmed = 1 ;
-os::make_polling_page_unreadable();
+if (DeferPollingPageLoopCount < 0) {
-}
+// Make polling safepoint aware
+guarantee (PageArmed == 0, "invariant") ;
-// Consider using active_processor_count() ... but that call is expensive.
+PageArmed = 1 ;
-int ncpus = os::processor_count() ;
+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
 }
 if (log_is_enabled(Trace, safepoint)) {
 ResourceMark rm;
 cur_state->print_on(LogHandle(safepoint)::trace_stream());
+}
 }
 }
-}
+if (iterations == 0) {
-if (PrintSafepointStatistics && iterations == 0) {
+initial_running = still_running;
-begin_statistics(nof_threads, 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.
+if (still_running > 0) {
-// There's a tension between allowing the mutators to run (and rendezvous)
+// Check for if it takes to long
-// vs spinning.  As the VM thread spins, wasting cycles, it consumes CPU that
+if (SafepointTimeout && safepoint_limit_time < os::javaTimeNanos()) {
-// a mutator might otherwise use profitably to reach a safepoint.  Excessive
+print_safepoint_timeout(_spinning_timeout);
-// 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.
+// Spin to avoid context switching.
-//
+// There's a tension between allowing the mutators to run (and rendezvous)
-// Further complicating matters is that yield() does not work as naively expected
+// vs spinning.  As the VM thread spins, wasting cycles, it consumes CPU that
-// on many platforms -- yield() does not guarantee that any other ready threads
+// a mutator might otherwise use profitably to reach a safepoint.  Excessive
-// will run.   As such we revert to naked_short_sleep() after some number of iterations.
+// spinning by the VM thread on a saturated system can increase rendezvous latency.
-// nakes_short_sleep() is implemented as a short unconditional sleep.
+// Blocking or yielding incur their own penalties in the form of context switching
-// Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping
+// and the resultant loss of $ residency.
-// 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
+// Further complicating matters is that yield() does not work as naively expected
-// described in CR6415670 the VMthread may sleep just before the mutator(s) become safe.
+// on many platforms -- yield() does not guarantee that any other ready threads
-// In that case the mutators will be stalled waiting for the safepoint to complete and the
+// will run.   As such we revert to naked_short_sleep() after some number of iterations.
-// the VMthread will be sleeping, waiting for the mutators to rendezvous.  The VMthread
+// nakes_short_sleep() is implemented as a short unconditional sleep.
-// will eventually wake up and detect that all mutators are safe, at which point
+// Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping
-// we'll again make progress.
+// 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
-// Beware too that that the VMThread typically runs at elevated priority.
+// described in CR6415670 the VMthread may sleep just before the mutator(s) become safe.
-// Its default priority is higher than the default mutator priority.
+// In that case the mutators will be stalled waiting for the safepoint to complete and the
-// Obviously, this complicates spinning.
+// 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
-// Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0).
+// we'll again make progress.
-// Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will.
+//
-//
+// Beware too that that the VMThread typically runs at elevated priority.
-// See the comments in synchronizer.cpp for additional remarks on spinning.
+// Its default priority is higher than the default mutator priority.
-//
+// Obviously, this complicates spinning.
-// In the future we might:
+//
-// 1. Modify the safepoint scheme to avoid potentially unbounded spinning.
+// Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0).
-//    This is tricky as the path used by a thread exiting the JVM (say on
+// Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will.
-//    on JNI call-out) simply stores into its state field.  The burden
+//
-//    is placed on the VM thread, which must poll (spin).
+// See the comments in synchronizer.cpp for additional remarks on spinning.
-// 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.
+// In the future we might:
-// 3. Use Solaris schedctl to examine the state of the still-running mutators.
+// 1. Modify the safepoint scheme to avoid potentially unbounded spinning.
-//    If all the mutators are ONPROC there's no reason to sleep or yield.
+//    This is tricky as the path used by a thread exiting the JVM (say on
-// 4. YieldTo() any still-running mutators that are ready but OFFPROC.
+//    on JNI call-out) simply stores into its state field.  The burden
-// 5. Check system saturation.  If the system is not fully saturated then
+//    is placed on the VM thread, which must poll (spin).
-//    simply spin and avoid sleep/yield.
+// 2. Find something useful to do while spinning.  If the safepoint is GC-related
-// 6. As still-running mutators rendezvous they could unpark the sleeping
+//    we might aggressively scan the stacks of threads that are already safe.
-//    VMthread.  This works well for still-running mutators that become
+// 3. Use Solaris schedctl to examine the state of the still-running mutators.
-//    safe.  The VMthread must still poll for mutators that call-out.
+//    If all the mutators are ONPROC there's no reason to sleep or yield.
-// 7. Drive the policy on time-since-begin instead of iterations.
+// 4. YieldTo() any still-running mutators that are ready but OFFPROC.
-// 8. Consider making the spin duration a function of the # of CPUs:
+// 5. Check system saturation.  If the system is not fully saturated then
-//    Spin = (((ncpus-1) * M) + K) + F(still_running)
+//    simply spin and avoid sleep/yield.
-//    Alternately, instead of counting iterations of the outer loop
+// 6. As still-running mutators rendezvous they could unpark the sleeping
-//    we could count the # of threads visited in the inner loop, above.
+//    VMthread.  This works well for still-running mutators that become
-// 9. On windows consider using the return value from SwitchThreadTo()
+//    safe.  The VMthread must still poll for mutators that call-out.
-//    to drive subsequent spin/SwitchThreadTo()/Sleep(N) decisions.
+// 7. Drive the policy on time-since-begin instead of iterations.
+// 8. Consider making the spin duration a function of the # of CPUs:
-if (int(iterations) == DeferPollingPageLoopCount) {
+//    Spin = (((ncpus-1) * M) + K) + F(still_running)
-guarantee (PageArmed == 0, "invariant") ;
+//    Alternately, instead of counting iterations of the outer loop
-PageArmed = 1 ;
+//    we could count the # of threads visited in the inner loop, above.
-os::make_polling_page_unreadable();
+// 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");
-// Instead of (ncpus > 1) consider either (still_running < (ncpus + EPSILON)) or
+}
-// ((still_running + _waiting_to_block - TryingToBlock)) < ncpus)
+assert(still_running == 0, "sanity check");
-++steps ;
-if (ncpus > 1 && steps < SafepointSpinBeforeYield) {
+if (PrintSafepointStatistics) {
-SpinPause() ;     // MP-Polite spin
+update_statistics_on_spin_end();
-} else
+}
-if (steps < DeferThrSuspendLoopCount) {
-os::naked_yield() ;
+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 {
-os::naked_short_sleep(1);
+// 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);
+}
 }
+}
-iterations ++ ;
+assert(_waiting_to_block == 0, "sanity check");
-}
-assert(iterations < (uint)max_jint, "We have been iterating in the safepoint loop too long");
+#ifndef PRODUCT
-}
+if (SafepointTimeout) {
-assert(still_running == 0, "sanity check");
+jlong current_time = os::javaTimeNanos();
+if (safepoint_limit_time < current_time) {
-if (PrintSafepointStatistics) {
+tty->print_cr("# SafepointSynchronize: Finished after "
-update_statistics_on_spin_end();
+INT64_FORMAT_W(6) " ms",
-}
+((current_time - safepoint_limit_time) / MICROUNITS +
+(jlong)SafepointTimeoutDelay));
-// wait until all threads are stopped
-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",
-((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");
 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
-do_cleanup_tasks();
+{
+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
 }
 #endif // INCLUDE_ALL_GCS
 // record this time so VMThread can keep track how much time has elapsed
 // since last safepoint.
 _end_of_last_safepoint = os::javaTimeMillis();
+if (event.should_commit()) {
+event.set_safepointId(safepoint_id);
+event.commit();
+}
 }
 bool SafepointSynchronize::is_cleanup_needed() {
 // Need a safepoint if some inline cache buffers is non-empty
 if (!InlineCacheBuffer::is_empty()) return true;
 return false;
 }
+static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {
+if (event.should_commit()) {
+event.set_safepointId(SafepointSynchronize::safepoint_counter());
+event.set_name(name);
+event.commit();
+}
+}
 // Various cleaning tasks that should be done periodically at safepoints
 void SafepointSynchronize::do_cleanup_tasks() {
 {
-TraceTime timer("deflating idle monitors", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "deflating idle monitors";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 ObjectSynchronizer::deflate_idle_monitors();
+event_safepoint_cleanup_task_commit(event, name);
 }
 {
-TraceTime timer("updating inline caches", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "updating inline caches";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 InlineCacheBuffer::update_inline_caches();
+event_safepoint_cleanup_task_commit(event, name);
 }
 {
+const char* name = "compilation policy safepoint handler";
+EventSafepointCleanupTask event;
 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepointcleanup));
 CompilationPolicy::policy()->do_safepoint_work();
+event_safepoint_cleanup_task_commit(event, name);
 }
 {
-TraceTime timer("mark nmethods", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "mark nmethods";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 NMethodSweeper::mark_active_nmethods();
+event_safepoint_cleanup_task_commit(event, name);
 }
 if (SymbolTable::needs_rehashing()) {
-TraceTime timer("rehashing symbol table", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "rehashing symbol table";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 SymbolTable::rehash_table();
+event_safepoint_cleanup_task_commit(event, name);
 }
 if (StringTable::needs_rehashing()) {
-TraceTime timer("rehashing string table", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "rehashing string table";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 StringTable::rehash_table();
+event_safepoint_cleanup_task_commit(event, name);
 }
 {
 // CMS delays purging the CLDG until the beginning of the next safepoint and to
 // make sure concurrent sweep is done
-TraceTime timer("purging class loader data graph", TRACETIME_LOG(Info, safepointcleanup));
+const char* name = "purging class loader data graph";
+EventSafepointCleanupTask event;
+TraceTime timer(name, TRACETIME_LOG(Info, safepointcleanup));
 ClassLoaderDataGraph::purge_if_needed();
+event_safepoint_cleanup_task_commit(event, name);
 }
 }
 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {

changeset 37176	663bdc7d0b86
parent 37161	e881f320966e
child 37242	91e5f98fff6f