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

equal deleted inserted replaced

-:7a2a740815b7
+:caf115bb98ad
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/gcLocker.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 #include "gc/shared/workgroup.hpp"
 #include "interpreter/interpreter.hpp"
+#include "jfr/jfrEvents.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/synchronizer.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/threadSMR.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"
 #ifdef COMPILER1
 #include "c1/c1_globals.hpp"
 #endif
+template <typename E>
+static void set_current_safepoint_id(E* event, int adjustment = 0) {
+assert(event != NULL, "invariant");
+event->set_safepointId(SafepointSynchronize::safepoint_counter() + adjustment);
+}
+static void post_safepoint_begin_event(EventSafepointBegin* event,
+int thread_count,
+int critical_thread_count) {
+assert(event != NULL, "invariant");
+assert(event->should_commit(), "invariant");
+set_current_safepoint_id(event);
+event->set_totalThreadCount(thread_count);
+event->set_jniCriticalThreadCount(critical_thread_count);
+event->commit();
+}
+static void post_safepoint_cleanup_event(EventSafepointCleanup* event) {
+assert(event != NULL, "invariant");
+assert(event->should_commit(), "invariant");
+set_current_safepoint_id(event);
+event->commit();
+}
+static void post_safepoint_synchronize_event(EventSafepointStateSynchronization* event,
+int initial_number_of_threads,
+int threads_waiting_to_block,
+unsigned int iterations) {
+assert(event != NULL, "invariant");
+if (event->should_commit()) {
+// Group this event together with the ones committed after the counter is increased
+set_current_safepoint_id(event, 1);
+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,
+int initial_threads_waiting_to_block) {
+assert(event != NULL, "invariant");
+assert(event->should_commit(), "invariant");
+set_current_safepoint_id(event);
+event->set_runningThreadCount(initial_threads_waiting_to_block);
+event->commit();
+}
+static void post_safepoint_cleanup_task_event(EventSafepointCleanupTask* event,
+const char* name) {
+assert(event != NULL, "invariant");
+if (event->should_commit()) {
+set_current_safepoint_id(event);
+event->set_name(name);
+event->commit();
+}
+}
+static void post_safepoint_end_event(EventSafepointEnd* event) {
+assert(event != NULL, "invariant");
+if (event->should_commit()) {
+// Group this event together with the ones committed before the counter increased
+set_current_safepoint_id(event, -1);
+event->commit();
+}
+}
 // --------------------------------------------------------------------------------------------------
 // Implementation of Safepoint begin/end
 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
 assert(still_running == 0, "sanity check");
 if (PrintSafepointStatistics) {
 update_statistics_on_spin_end();
 }
 if (sync_event.should_commit()) {
-// Group this event together with the ones committed after the counter is increased
+post_safepoint_synchronize_event(&sync_event, initial_running, _waiting_to_block, iterations);
-sync_event.set_safepointId(safepoint_counter() + 1);
+}
-sync_event.set_initialThreadCount(initial_running);
+}
-sync_event.set_runningThreadCount(_waiting_to_block);
-sync_event.set_iterations(iterations);
-sync_event.commit();
-}
-} // EventSafepointStateSynchronization destroyed here.
 // wait until all threads are stopped
 {
 EventSafepointWaitBlocked wait_blocked_event;
 int initial_waiting_to_block = _waiting_to_block;
 // Record state
 _state = _synchronized;
 OrderAccess::fence();
 if (wait_blocked_event.should_commit()) {
-wait_blocked_event.set_safepointId(safepoint_counter());
+post_safepoint_wait_blocked_event(&wait_blocked_event, initial_waiting_to_block);
-wait_blocked_event.set_runningThreadCount(initial_waiting_to_block);
+}
-wait_blocked_event.commit();
+}
-}
-} // EventSafepointWaitBlocked
 #ifdef ASSERT
 // Make sure all the threads were visited.
 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *cur = jtiwh.next(); ) {
 assert(cur->was_visited_for_critical_count(), "missed a thread");
 // 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());
+post_safepoint_cleanup_event(&cleanup_event);
-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());
+post_safepoint_begin_event(&begin_event, nof_threads, _current_jni_active_count);
-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");
+EventSafepointEnd event;
 _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();)
 Universe::heap()->safepoint_synchronize_end();
 // 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);
+post_safepoint_end_event(&event);
-event.commit();
 }
 }
 bool SafepointSynchronize::is_cleanup_needed() {
 // Need a safepoint if there are many monitors to deflate.
 if (ObjectSynchronizer::is_cleanup_needed()) return true;
 // 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();
-}
 }
 class ParallelSPCleanupThreadClosure : public ThreadClosure {
 private:
 CodeBlobClosure* _nmethod_cl;
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
 const char* name = "deflating idle monitors";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 ObjectSynchronizer::deflate_idle_monitors(_counters);
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
 const char* name = "updating inline caches";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 InlineCacheBuffer::update_inline_caches();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
 const char* name = "compilation policy safepoint handler";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 CompilationPolicy::policy()->do_safepoint_work();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {
 if (SymbolTable::needs_rehashing()) {
 const char* name = "rehashing symbol table";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 SymbolTable::rehash_table();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {
 if (StringTable::needs_rehashing()) {
 const char* name = "rehashing string table";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 StringTable::rehash_table();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {
 // CMS delays purging the CLDG until the beginning of the next safepoint and to
 // make sure concurrent sweep is done
 const char* name = "purging class loader data graph";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 ClassLoaderDataGraph::purge_if_needed();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYSTEM_DICTIONARY_RESIZE)) {
 const char* name = "resizing system dictionaries";
 EventSafepointCleanupTask event;
 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 ClassLoaderDataGraph::resize_if_needed();
-event_safepoint_cleanup_task_commit(event, name);
+if (event.should_commit()) {
+post_safepoint_cleanup_task_event(&event, name);
+}
 }
 _subtasks.all_tasks_completed(_num_workers);
 }
 };

changeset 50113	caf115bb98ad
parent 49594	898ef81cbc0e
child 50429	83aec1d357d4