src/share/vm/runtime/safepoint.cpp

@@ -30,11 +30,13 @@
 #include "code/nmethod.hpp"
 #include "code/pcDesc.hpp"
 #include "code/scopeDesc.hpp"
 #include "gc_interface/collectedHeap.hpp"
 #include "interpreter/interpreter.hpp"
+#if INCLUDE_JFR
 #include "jfr/jfrEvents.hpp"
+#endif
 #include "memory/resourceArea.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "runtime/compilationPolicy.hpp"

@@ -88,10 +90,11 @@
 static void set_current_safepoint_id(E* event, int adjustment = 0) {
   assert(event != NULL, "invariant");
   event->set_safepointId(SafepointSynchronize::safepoint_counter() + adjustment);
 }
 
+#if INCLUDE_JFR
 static void post_safepoint_begin_event(EventSafepointBegin* event,
                                        int thread_count,
                                        int critical_thread_count) {
   assert(event != NULL, "invariant");
   assert(event->should_commit(), "invariant");

@@ -148,10 +151,11 @@
     // Group this event together with the ones committed before the counter increased
     set_current_safepoint_id(event, -1);
     event->commit();
   }
 }
+#endif
 
 // --------------------------------------------------------------------------------------------------
 // Implementation of Safepoint begin/end
 
 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;

@@ -163,11 +167,13 @@
 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() {
+#if INCLUDE_JFR
   EventSafepointBegin begin_event;
+#endif
   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();

@@ -255,11 +261,13 @@
   //  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.
   //
+#if INCLUDE_JFR
   EventSafepointStateSynchronization sync_event;
+#endif
   int initial_running = 0;
 
   _state            = _synchronizing;
   OrderAccess::fence();
 

@@ -408,17 +416,21 @@
 
   if (PrintSafepointStatistics) {
     update_statistics_on_spin_end();
   }
 
+#if INCLUDE_JFR
   if (sync_event.should_commit()) {
     post_safepoint_synchronize_event(&sync_event, initial_running, _waiting_to_block, iterations);
   }
+#endif
 
   // wait until all threads are stopped
   {
+#if INCLUDE_JFR
     EventSafepointWaitBlocked wait_blocked_event;
+#endif
     int initial_waiting_to_block = _waiting_to_block;
 
     while (_waiting_to_block > 0) {
       if (TraceSafepoint) tty->print_cr("Waiting for %d thread(s) to block", _waiting_to_block);
       if (!SafepointTimeout || timeout_error_printed) {

@@ -454,13 +466,15 @@
     // Record state
     _state = _synchronized;
 
     OrderAccess::fence();
 
+#if INCLUDE_JFR
     if (wait_blocked_event.should_commit()) {
       post_safepoint_wait_blocked_event(&wait_blocked_event, initial_waiting_to_block);
     }
+#endif
   }
 
 #ifdef ASSERT
   for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) {
     // make sure all the threads were visited

@@ -481,34 +495,42 @@
     update_statistics_on_sync_end(os::javaTimeNanos());
   }
 
   // Call stuff that needs to be run when a safepoint is just about to be completed
   {
+#if INCLUDE_JFR
     EventSafepointCleanup cleanup_event;
+#endif
     do_cleanup_tasks();
+#if INCLUDE_JFR
     if (cleanup_event.should_commit()) {
       post_safepoint_cleanup_event(&cleanup_event);
     }
+#endif
   }
 
   if (PrintSafepointStatistics) {
     // Record how much time spend on the above cleanup tasks
     update_statistics_on_cleanup_end(os::javaTimeNanos());
   }
 
+#if INCLUDE_JFR
   if (begin_event.should_commit()) {
     post_safepoint_begin_event(&begin_event, nof_threads, _current_jni_active_count);
   }
+#endif
 }
 
 // Wake up all threads, so they are ready to resume execution after the safepoint
 // operation has been carried out
 void SafepointSynchronize::end() {
 
   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
   assert((_safepoint_counter & 0x1) == 1, "must be odd");
+#if INCLUDE_JFR
   EventSafepointEnd event;
+#endif
   _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();)

@@ -590,13 +612,15 @@
   }
 #endif // INCLUDE_ALL_GCS
   // record this time so VMThread can keep track how much time has elasped
   // since last safepoint.
   _end_of_last_safepoint = os::javaTimeMillis();
+#if INCLUDE_JFR
   if (event.should_commit()) {
     post_safepoint_end_event(&event);
   }
+#endif
 }
 
 bool SafepointSynchronize::is_cleanup_needed() {
   // Need a safepoint if some inline cache buffers is non-empty
   if (!InlineCacheBuffer::is_empty()) return true;

@@ -607,65 +631,89 @@
 
 // Various cleaning tasks that should be done periodically at safepoints
 void SafepointSynchronize::do_cleanup_tasks() {
   {
     const char* name = "deflating idle monitors";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t1(name, TraceSafepointCleanupTime);
     ObjectSynchronizer::deflate_idle_monitors();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
 
   {
     const char* name = "updating inline caches";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t2(name, TraceSafepointCleanupTime);
     InlineCacheBuffer::update_inline_caches();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
   {
     const char* name = "compilation policy safepoint handler";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t3(name, TraceSafepointCleanupTime);
     CompilationPolicy::policy()->do_safepoint_work();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
 
   {
     const char* name = "mark nmethods";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t4(name, TraceSafepointCleanupTime);
     NMethodSweeper::mark_active_nmethods();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
 
   if (SymbolTable::needs_rehashing()) {
     const char* name = "rehashing symbol table";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t5(name, TraceSafepointCleanupTime);
     SymbolTable::rehash_table();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
 
   if (StringTable::needs_rehashing()) {
     const char* name = "rehashing string table";
+#if INCLUDE_JFR
     EventSafepointCleanupTask event;
+#endif
     TraceTime t6(name, TraceSafepointCleanupTime);
     StringTable::rehash_table();
+#if INCLUDE_JFR
     if (event.should_commit()) {
       post_safepoint_cleanup_task_event(&event, name);
     }
+#endif
   }
 
   // rotate log files?
   if (UseGCLogFileRotation) {
     gclog_or_tty->rotate_log(false);