--- a/src/hotspot/share/runtime/safepoint.cpp Thu Oct 17 20:27:44 2019 +0100
+++ b/src/hotspot/share/runtime/safepoint.cpp Thu Oct 17 20:53:35 2019 +0100
@@ -33,8 +33,10 @@
#include "code/nmethod.hpp"
#include "code/pcDesc.hpp"
#include "code/scopeDesc.hpp"
+#include "compiler/compilationPolicy.hpp"
#include "gc/shared/collectedHeap.hpp"
#include "gc/shared/gcLocker.hpp"
+#include "gc/shared/oopStorage.hpp"
#include "gc/shared/strongRootsScope.hpp"
#include "gc/shared/workgroup.hpp"
#include "interpreter/interpreter.hpp"
@@ -46,7 +48,6 @@
#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/handles.inline.hpp"
@@ -118,12 +119,22 @@
}
}
+// SafepointCheck
+SafepointStateTracker::SafepointStateTracker(uint64_t safepoint_id, bool at_safepoint)
+ : _safepoint_id(safepoint_id), _at_safepoint(at_safepoint) {}
+
+bool SafepointStateTracker::safepoint_state_changed() {
+ return _safepoint_id != SafepointSynchronize::safepoint_id() ||
+ _at_safepoint != SafepointSynchronize::is_at_safepoint();
+}
+
// --------------------------------------------------------------------------------------------------
// Implementation of Safepoint begin/end
SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
int SafepointSynchronize::_waiting_to_block = 0;
volatile uint64_t SafepointSynchronize::_safepoint_counter = 0;
+uint64_t SafepointSynchronize::_safepoint_id = 0;
const uint64_t SafepointSynchronize::InactiveSafepointCounter = 0;
int SafepointSynchronize::_current_jni_active_count = 0;
@@ -154,7 +165,7 @@
--_waiting_to_block;
}
-static bool thread_not_running(ThreadSafepointState *cur_state) {
+bool SafepointSynchronize::thread_not_running(ThreadSafepointState *cur_state) {
if (!cur_state->is_running()) {
return true;
}
@@ -408,6 +419,9 @@
OrderAccess::fence();
+ // Set the new id
+ ++_safepoint_id;
+
#ifdef ASSERT
// Make sure all the threads were visited.
for (JavaThreadIteratorWithHandle jtiwh; JavaThread *cur = jtiwh.next(); ) {
@@ -419,7 +433,7 @@
GCLocker::set_jni_lock_count(_current_jni_active_count);
post_safepoint_synchronize_event(sync_event,
- _safepoint_counter,
+ _safepoint_id,
initial_running,
_waiting_to_block, iterations);
@@ -429,14 +443,14 @@
// 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_cleanup_event(cleanup_event, _safepoint_id);
- post_safepoint_begin_event(begin_event, _safepoint_counter, nof_threads, _current_jni_active_count);
+ post_safepoint_begin_event(begin_event, _safepoint_id, nof_threads, _current_jni_active_count);
SafepointTracing::cleanup();
}
void SafepointSynchronize::disarm_safepoint() {
- uint64_t safepoint_id = _safepoint_counter;
+ uint64_t active_safepoint_counter = _safepoint_counter;
{
JavaThreadIteratorWithHandle jtiwh;
#ifdef ASSERT
@@ -475,7 +489,7 @@
jtiwh.rewind();
for (; JavaThread *current = jtiwh.next(); ) {
// Clear the visited flag to ensure that the critical counts are collected properly.
- DEBUG_ONLY(current->reset_visited_for_critical_count(safepoint_id);)
+ DEBUG_ONLY(current->reset_visited_for_critical_count(active_safepoint_counter);)
ThreadSafepointState* cur_state = current->safepoint_state();
assert(!cur_state->is_running(), "Thread not suspended at safepoint");
cur_state->restart(); // TSS _running
@@ -497,7 +511,6 @@
void SafepointSynchronize::end() {
assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
EventSafepointEnd event;
- uint64_t safepoint_id = _safepoint_counter;
assert(Thread::current()->is_VM_thread(), "Only VM thread can execute a safepoint");
disarm_safepoint();
@@ -506,7 +519,7 @@
SafepointTracing::end();
- post_safepoint_end_event(event, safepoint_id);
+ post_safepoint_end_event(event, safepoint_id());
}
bool SafepointSynchronize::is_cleanup_needed() {
@@ -554,7 +567,7 @@
_counters(counters) {}
void work(uint worker_id) {
- uint64_t safepoint_id = SafepointSynchronize::safepoint_counter();
+ uint64_t safepoint_id = SafepointSynchronize::safepoint_id();
// All threads deflate monitors and mark nmethods (if necessary).
Threads::possibly_parallel_threads_do(true, &_cleanup_threads_cl);
@@ -631,6 +644,12 @@
}
}
+ if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_REQUEST_OOPSTORAGE_CLEANUP)) {
+ // Don't bother reporting event or time for this very short operation.
+ // To have any utility we'd also want to report whether needed.
+ OopStorage::trigger_cleanup_if_needed();
+ }
+
_subtasks.all_tasks_completed(_num_workers);
}
};
@@ -920,7 +939,7 @@
break; // Could not send signal. Report fatal error.
}
// Give cur_thread a chance to report the error and terminate the VM.
- os::sleep(Thread::current(), 3000, false);
+ os::naked_sleep(3000);
}
}
fatal("Safepoint sync time longer than " INTX_FORMAT "ms detected when executing %s.",
@@ -933,8 +952,7 @@
ThreadSafepointState::ThreadSafepointState(JavaThread *thread)
: _at_poll_safepoint(false), _thread(thread), _safepoint_safe(false),
- _safepoint_id(SafepointSynchronize::InactiveSafepointCounter),
- _orig_thread_state(_thread_uninitialized), _next(NULL) {
+ _safepoint_id(SafepointSynchronize::InactiveSafepointCounter), _next(NULL) {
}
void ThreadSafepointState::create(JavaThread *thread) {
@@ -971,9 +989,6 @@
return;
}
- // Save the state at the start of safepoint processing.
- _orig_thread_state = stable_state;
-
// Check for a thread that is suspended. Note that thread resume tries
// to grab the Threads_lock which we own here, so a thread cannot be
// resumed during safepoint synchronization.
@@ -1041,8 +1056,6 @@
_thread->print_thread_state_on(st);
}
-void ThreadSafepointState::print() const { print_on(tty); }
-
// ---------------------------------------------------------------------------------------------------------------------
// Block the thread at poll or poll return for safepoint/handshake.