stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8237756: Backout: JDK-8230594: Allow direct handshakes without VMThread intervention

Browse Source 
Backout JDK-8230594

Reviewed-by: coleenp, dcubed
This commit is contained in:
Patricio Chilano Mateo 2020-01-23 17:26:52 +00:00
parent 94bb505c94
commit 5e9d3fdc9c
9 changed files with 161 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/hotspot/share/runtime/biasedLocking.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -622,7 +622,7 @@ BiasedLocking::Condition BiasedLocking::single_revoke_with_handshake(Handle obj,
p2i(biaser), p2i(obj()));
RevokeOneBias revoke(obj, requester, biaser);
bool executed = Handshake::execute_direct(&revoke, biaser);
bool executed = Handshake::execute(&revoke, biaser);
if (revoke.status_code() == NOT_REVOKED) {
return NOT_REVOKED;
}
@ -668,8 +668,7 @@ BiasedLocking::Condition BiasedLocking::single_revoke_with_handshake(Handle obj,
void BiasedLocking::walk_stack_and_revoke(oop obj, JavaThread* biased_locker) {
assert(!SafepointSynchronize::is_at_safepoint() || !SafepointMechanism::uses_thread_local_poll(),
"if SafepointMechanism::uses_thread_local_poll() is enabled this should always be executed outside safepoints");
Thread* cur = Thread::current();
assert(cur == biased_locker || cur == biased_locker->get_active_handshaker() || cur->is_VM_thread(), "wrong thread");
assert(Thread::current() == biased_locker || Thread::current()->is_VM_thread(), "wrong thread");
markWord mark = obj->mark();
assert(mark.biased_locker() == biased_locker &&
@ -678,14 +677,14 @@ void BiasedLocking::walk_stack_and_revoke(oop obj, JavaThread* biased_locker) {
log_trace(biasedlocking)("%s(" INTPTR_FORMAT ") revoking object " INTPTR_FORMAT ", mark "
INTPTR_FORMAT ", type %s, prototype header " INTPTR_FORMAT
", biaser " INTPTR_FORMAT " %s",
cur->is_VM_thread() ? "VMThread" : "JavaThread",
p2i(cur),
Thread::current()->is_VM_thread() ? "VMThread" : "JavaThread",
p2i(Thread::current()),
p2i(obj),
mark.value(),
obj->klass()->external_name(),
obj->klass()->prototype_header().value(),
p2i(biased_locker),
cur->is_VM_thread() ? "" : "(walking own stack)");
Thread::current()->is_VM_thread() ? "" : "(walking own stack)");
markWord unbiased_prototype = markWord::prototype().set_age(obj->mark().age());

265
src/hotspot/share/runtime/handshake.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -37,49 +37,51 @@
#include "utilities/formatBuffer.hpp"
#include "utilities/preserveException.hpp"
class HandshakeOperation: public StackObj {
HandshakeClosure* _handshake_cl;
int32_t _pending_threads;
bool _executed;
bool _is_direct;
public:
HandshakeOperation(HandshakeClosure* cl, bool is_direct = false) :
_handshake_cl(cl),
_pending_threads(1),
_executed(false),
_is_direct(is_direct) {}
virtual void do_handshake(JavaThread* thread) = 0;
};
class HandshakeThreadsOperation: public HandshakeOperation {
static Semaphore _done;
HandshakeClosure* _handshake_cl;
bool _executed;
public:
HandshakeThreadsOperation(HandshakeClosure* cl) : _handshake_cl(cl), _executed(false) {}
void do_handshake(JavaThread* thread);
bool is_completed() {
int64_t val = Atomic::load(&_pending_threads);
assert(val >= 0, "_pending_threads cannot be negative");
return val == 0;
}
void add_target_count(int count) { Atomic::add(&_pending_threads, count); }
bool thread_has_completed() { return _done.trywait(); }
bool executed() const { return _executed; }
const char* name() { return _handshake_cl->name(); }
bool is_direct() { return _is_direct; }
#ifdef ASSERT
void check_state() {
assert(_pending_threads == 0, "Must be zero");
assert(!_done.trywait(), "Must be zero");
}
#endif
};
Semaphore HandshakeThreadsOperation::_done(0);
class VM_Handshake: public VM_Operation {
const jlong _handshake_timeout;
public:
bool evaluate_at_safepoint() const { return false; }
protected:
HandshakeOperation* const _op;
HandshakeThreadsOperation* const _op;
VM_Handshake(HandshakeOperation* op) :
VM_Handshake(HandshakeThreadsOperation* op) :
_handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
void set_handshake(JavaThread* target) {
target->set_handshake_operation(_op);
}
// This method returns true for threads completed their operation
// and true for threads canceled their operation.
// A cancellation can happen if the thread is exiting.
bool poll_for_completed_thread() { return _op->thread_has_completed(); }
bool handshake_has_timed_out(jlong start_time);
static void handle_timeout();
};
@ -119,10 +121,12 @@ static void log_handshake_info(jlong start_time_ns, const char* name, int target
class VM_HandshakeOneThread: public VM_Handshake {
JavaThread* _target;
public:
VM_HandshakeOneThread(HandshakeOperation* op, JavaThread* target) :
VM_HandshakeOneThread(HandshakeThreadsOperation* op, JavaThread* target) :
VM_Handshake(op), _target(target) {}
void doit() {
DEBUG_ONLY(_op->check_state();)
jlong start_time_ns = 0;
if (log_is_enabled(Info, handshake)) {
start_time_ns = os::javaTimeNanos();
@ -130,7 +134,7 @@ class VM_HandshakeOneThread: public VM_Handshake {
ThreadsListHandle tlh;
if (tlh.includes(_target)) {
_target->set_handshake_operation(_op);
set_handshake(_target);
} else {
log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
return;
@ -143,8 +147,8 @@ class VM_HandshakeOneThread: public VM_Handshake {
if (handshake_has_timed_out(timeout_start_time)) {
handle_timeout();
}
by_vm_thread = _target->handshake_try_process(_op);
} while (!_op->is_completed());
by_vm_thread = _target->handshake_try_process_by_vmThread();
} while (!poll_for_completed_thread());
DEBUG_ONLY(_op->check_state();)
log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
}
@ -156,9 +160,11 @@ class VM_HandshakeOneThread: public VM_Handshake {
class VM_HandshakeAllThreads: public VM_Handshake {
public:
VM_HandshakeAllThreads(HandshakeOperation* op) : VM_Handshake(op) {}
VM_HandshakeAllThreads(HandshakeThreadsOperation* op) : VM_Handshake(op) {}
void doit() {
DEBUG_ONLY(_op->check_state();)
jlong start_time_ns = 0;
if (log_is_enabled(Info, handshake)) {
start_time_ns = os::javaTimeNanos();
@ -168,7 +174,7 @@ class VM_HandshakeAllThreads: public VM_Handshake {
JavaThreadIteratorWithHandle jtiwh;
int number_of_threads_issued = 0;
for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
thr->set_handshake_operation(_op);
set_handshake(thr);
number_of_threads_issued++;
}
@ -176,11 +182,10 @@ class VM_HandshakeAllThreads: public VM_Handshake {
log_handshake_info(start_time_ns, _op->name(), 0, 0);
return;
}
// _op was created with a count == 1 so don't double count.
_op->add_target_count(number_of_threads_issued - 1);
log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
const jlong start_time = os::elapsed_counter();
int number_of_threads_completed = 0;
do {
// Check if handshake operation has timed out
if (handshake_has_timed_out(start_time)) {
@ -193,12 +198,18 @@ class VM_HandshakeAllThreads: public VM_Handshake {
jtiwh.rewind();
for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
// A new thread on the ThreadsList will not have an operation,
// hence it is skipped in handshake_try_process.
if (thr->handshake_try_process(_op)) {
// hence it is skipped in handshake_process_by_vmthread.
if (thr->handshake_try_process_by_vmThread()) {
handshake_executed_by_vm_thread++;
}
}
} while (!_op->is_completed());
while (poll_for_completed_thread()) {
// Includes canceled operations by exiting threads.
number_of_threads_completed++;
}
} while (number_of_threads_issued > number_of_threads_completed);
assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
DEBUG_ONLY(_op->check_state();)
log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
@ -234,7 +245,7 @@ public:
bool executed() const { return _executed; }
};
void HandshakeOperation::do_handshake(JavaThread* thread) {
void HandshakeThreadsOperation::do_handshake(JavaThread* thread) {
jlong start_time_ns = 0;
if (log_is_enabled(Debug, handshake, task)) {
start_time_ns = os::javaTimeNanos();
@ -252,16 +263,16 @@ void HandshakeOperation::do_handshake(JavaThread* thread) {
name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
}
// Inform VMThread/Handshaker that we have completed the operation
Atomic::dec(&_pending_threads);
// Use the semaphore to inform the VM thread that we have completed the operation
_done.signal();
// It is no longer safe to refer to 'this' as the VMThread/Handshaker may have destroyed this operation
// It is no longer safe to refer to 'this' as the VMThread may have destroyed this operation
}
void Handshake::execute(HandshakeClosure* thread_cl) {
if (SafepointMechanism::uses_thread_local_poll()) {
HandshakeOperation ho(thread_cl);
VM_HandshakeAllThreads handshake(&ho);
HandshakeThreadsOperation cto(thread_cl);
VM_HandshakeAllThreads handshake(&cto);
VMThread::execute(&handshake);
} else {
VM_HandshakeFallbackOperation op(thread_cl);
@ -271,8 +282,8 @@ void Handshake::execute(HandshakeClosure* thread_cl) {
bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
if (SafepointMechanism::uses_thread_local_poll()) {
HandshakeOperation ho(thread_cl);
VM_HandshakeOneThread handshake(&ho, target);
HandshakeThreadsOperation cto(thread_cl);
VM_HandshakeOneThread handshake(&cto, target);
VMThread::execute(&handshake);
return handshake.executed();
} else {
@ -282,125 +293,61 @@ bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
}
}
bool Handshake::execute_direct(HandshakeClosure* thread_cl, JavaThread* target) {
if (!SafepointMechanism::uses_thread_local_poll()) {
VM_HandshakeFallbackOperation op(thread_cl, target);
VMThread::execute(&op);
return op.executed();
}
JavaThread* self = JavaThread::current();
HandshakeOperation op(thread_cl, /*is_direct*/ true);
jlong start_time_ns = 0;
if (log_is_enabled(Info, handshake)) {
start_time_ns = os::javaTimeNanos();
}
ThreadsListHandle tlh;
if (tlh.includes(target)) {
target->set_handshake_operation(&op);
} else {
log_handshake_info(start_time_ns, op.name(), 0, 0, "(thread dead)");
return false;
}
bool by_handshaker = false;
while (!op.is_completed()) {
by_handshaker = target->handshake_try_process(&op);
// Check for pending handshakes to avoid possible deadlocks where our
// target is trying to handshake us.
if (SafepointMechanism::should_block(self)) {
ThreadBlockInVM tbivm(self);
}
}
DEBUG_ONLY(op.check_state();)
log_handshake_info(start_time_ns, op.name(), 1, by_handshaker ? 1 : 0);
return op.executed();
HandshakeState::HandshakeState() : _operation(NULL), _semaphore(1), _thread_in_process_handshake(false) {
DEBUG_ONLY(_vmthread_processing_handshake = false;)
}
HandshakeState::HandshakeState() :
_operation(NULL),
_operation_direct(NULL),
_handshake_turn_sem(1),
_processing_sem(1),
_thread_in_process_handshake(false)
{
DEBUG_ONLY(_active_handshaker = NULL;)
void HandshakeState::set_operation(JavaThread* target, HandshakeOperation* op) {
_operation = op;
SafepointMechanism::arm_local_poll_release(target);
}
void HandshakeState::set_operation(HandshakeOperation* op) {
if (!op->is_direct()) {
assert(Thread::current()->is_VM_thread(), "should be the VMThread");
_operation = op;
} else {
assert(Thread::current()->is_Java_thread(), "should be a JavaThread");
// Serialize direct handshakes so that only one proceeds at a time for a given target
_handshake_turn_sem.wait_with_safepoint_check(JavaThread::current());
_operation_direct = op;
}
SafepointMechanism::arm_local_poll_release(_handshakee);
void HandshakeState::clear_handshake(JavaThread* target) {
_operation = NULL;
SafepointMechanism::disarm_if_needed(target, true /* release */);
}
void HandshakeState::clear_handshake(bool is_direct) {
if (!is_direct) {
_operation = NULL;
} else {
_operation_direct = NULL;
_handshake_turn_sem.signal();
}
}
void HandshakeState::process_self_inner() {
assert(Thread::current() == _handshakee, "should call from _handshakee");
assert(!_handshakee->is_terminated(), "should not be a terminated thread");
assert(_handshakee->thread_state() != _thread_blocked, "should not be in a blocked state");
assert(_handshakee->thread_state() != _thread_in_native, "should not be in native");
JavaThread* self = _handshakee;
void HandshakeState::process_self_inner(JavaThread* thread) {
assert(Thread::current() == thread, "should call from thread");
assert(!thread->is_terminated(), "should not be a terminated thread");
assert(thread->thread_state() != _thread_blocked, "should not be in a blocked state");
assert(thread->thread_state() != _thread_in_native, "should not be in native");
do {
ThreadInVMForHandshake tivm(self);
if (!_processing_sem.trywait()) {
_processing_sem.wait_with_safepoint_check(self);
ThreadInVMForHandshake tivm(thread);
if (!_semaphore.trywait()) {
_semaphore.wait_with_safepoint_check(thread);
}
if (has_operation()) {
HandleMark hm(self);
CautiouslyPreserveExceptionMark pem(self);
HandshakeOperation * op = _operation;
if (op != NULL) {
// Disarm before executing the operation
clear_handshake(/*is_direct*/ false);
op->do_handshake(self);
}
op = _operation_direct;
if (op != NULL) {
// Disarm before executing the operation
clear_handshake(/*is_direct*/ true);
op->do_handshake(self);
}
HandshakeOperation* op = Atomic::load_acquire(&_operation);
if (op != NULL) {
HandleMark hm(thread);
CautiouslyPreserveExceptionMark pem(thread);
// Disarm before execute the operation
clear_handshake(thread);
op->do_handshake(thread);
}
_processing_sem.signal();
_semaphore.signal();
} while (has_operation());
}
bool HandshakeState::can_process_handshake() {
bool HandshakeState::vmthread_can_process_handshake(JavaThread* target) {
// handshake_safe may only be called with polls armed.
// Handshaker controls this by first claiming the handshake via claim_handshake().
return SafepointSynchronize::handshake_safe(_handshakee);
// VM thread controls this by first claiming the handshake via claim_handshake_for_vmthread.
return SafepointSynchronize::handshake_safe(target);
}
bool HandshakeState::possibly_can_process_handshake() {
static bool possibly_vmthread_can_process_handshake(JavaThread* target) {
// Note that this method is allowed to produce false positives.
if (_handshakee->is_ext_suspended()) {
if (target->is_ext_suspended()) {
return true;
}
if (_handshakee->is_terminated()) {
if (target->is_terminated()) {
return true;
}
switch (_handshakee->thread_state()) {
switch (target->thread_state()) {
case _thread_in_native:
// native threads are safe if they have no java stack or have walkable stack
return !_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable();
return !target->has_last_Java_frame() || target->frame_anchor()->walkable();
case _thread_blocked:
return true;
@ -410,40 +357,32 @@ bool HandshakeState::possibly_can_process_handshake() {
}
}
bool HandshakeState::claim_handshake(bool is_direct) {
if (!_processing_sem.trywait()) {
bool HandshakeState::claim_handshake_for_vmthread() {
if (!_semaphore.trywait()) {
return false;
}
if (has_specific_operation(is_direct)){
if (has_operation()) {
return true;
}
_processing_sem.signal();
_semaphore.signal();
return false;
}
bool HandshakeState::try_process(HandshakeOperation* op) {
bool is_direct = op->is_direct();
bool HandshakeState::try_process_by_vmThread(JavaThread* target) {
assert(Thread::current()->is_VM_thread(), "should call from vm thread");
if (!has_specific_operation(is_direct)){
if (!has_operation()) {
// JT has already cleared its handshake
return false;
}
if (!possibly_can_process_handshake()) {
if (!possibly_vmthread_can_process_handshake(target)) {
// JT is observed in an unsafe state, it must notice the handshake itself
return false;
}
// Claim the semaphore if there still an operation to be executed.
if (!claim_handshake(is_direct)) {
return false;
}
// Check if the handshake operation is the same as the one we meant to execute. The
// handshake could have been already processed by the handshakee and a new handshake
// by another JavaThread might be in progress.
if ( (is_direct && op != _operation_direct)) {
_processing_sem.signal();
if (!claim_handshake_for_vmthread()) {
return false;
}
@ -451,19 +390,19 @@ bool HandshakeState::try_process(HandshakeOperation* op) {
// can observe a safe state the thread cannot possibly continue without
// getting caught by the semaphore.
bool executed = false;
if (can_process_handshake()) {
guarantee(!_processing_sem.trywait(), "we should already own the semaphore");
log_trace(handshake)("Processing handshake by %s", Thread::current()->is_VM_thread() ? "VMThread" : "Handshaker");
DEBUG_ONLY(_active_handshaker = Thread::current();)
op->do_handshake(_handshakee);
DEBUG_ONLY(_active_handshaker = NULL;)
// Disarm after we have executed the operation.
clear_handshake(is_direct);
if (vmthread_can_process_handshake(target)) {
guarantee(!_semaphore.trywait(), "we should already own the semaphore");
log_trace(handshake)("Processing handshake by VMThtread");
DEBUG_ONLY(_vmthread_processing_handshake = true;)
_operation->do_handshake(target);
DEBUG_ONLY(_vmthread_processing_handshake = false;)
// Disarm after VM thread have executed the operation.
clear_handshake(target);
executed = true;
}
// Release the thread
_processing_sem.signal();
_semaphore.signal();
return executed;
}

60
src/hotspot/share/runtime/handshake.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -30,17 +30,13 @@
#include "runtime/flags/flagSetting.hpp"
#include "runtime/semaphore.hpp"
class HandshakeOperation;
class JavaThread;
// A handshake closure is a callback that is executed for each JavaThread
// while that thread is in a safepoint safe state. The callback is executed
// either by the target JavaThread itself or by the VMThread while keeping
// the target thread in a blocked state. A handshake can be performed with a
// single JavaThread as well. In that case, the callback is executed either
// by the target JavaThread itself or, depending on whether the operation is
// a direct handshake or not, by the JavaThread that requested the handshake
// or the VMThread respectively.
// either by the thread itself or by the VM thread while keeping the thread
// in a blocked state. A handshake can be performed with a single
// JavaThread as well.
class HandshakeClosure : public ThreadClosure {
const char* const _name;
public:
@ -56,51 +52,47 @@ class Handshake : public AllStatic {
// Execution of handshake operation
static void execute(HandshakeClosure* hs_cl);
static bool execute(HandshakeClosure* hs_cl, JavaThread* target);
static bool execute_direct(HandshakeClosure* hs_cl, JavaThread* target);
};
// The HandshakeState keeps track of an ongoing handshake for this JavaThread.
// VMThread/Handshaker and JavaThread are serialized with semaphore _processing_sem
// making sure the operation is only done by either VMThread/Handshaker on behalf
// of the JavaThread or by the target JavaThread itself.
class HandshakeState {
JavaThread* _handshakee;
HandshakeOperation* volatile _operation;
HandshakeOperation* volatile _operation_direct;
class HandshakeOperation;
Semaphore _handshake_turn_sem; // Used to serialize direct handshakes for this JavaThread.
Semaphore _processing_sem;
// The HandshakeState keep tracks of an ongoing handshake for one JavaThread.
// VM thread and JavaThread are serialized with the semaphore making sure
// the operation is only done by either VM thread on behalf of the JavaThread
// or the JavaThread itself.
class HandshakeState {
HandshakeOperation* volatile _operation;
Semaphore _semaphore;
bool _thread_in_process_handshake;
bool claim_handshake(bool is_direct);
bool possibly_can_process_handshake();
bool can_process_handshake();
void clear_handshake(bool is_direct);
bool claim_handshake_for_vmthread();
bool vmthread_can_process_handshake(JavaThread* target);
void process_self_inner();
void clear_handshake(JavaThread* thread);
void process_self_inner(JavaThread* thread);
public:
HandshakeState();
void set_thread(JavaThread* thread) { _handshakee = thread; }
void set_operation(JavaThread* thread, HandshakeOperation* op);
void set_operation(HandshakeOperation* op);
bool has_operation() const { return _operation != NULL || _operation_direct != NULL; }
bool has_specific_operation(bool is_direct) const {
return is_direct ? _operation_direct != NULL : _operation != NULL;
bool has_operation() const {
return _operation != NULL;
}
void process_by_self() {
void process_by_self(JavaThread* thread) {
if (!_thread_in_process_handshake) {
FlagSetting fs(_thread_in_process_handshake, true);
process_self_inner();
process_self_inner(thread);
}
}
bool try_process(HandshakeOperation* op);
bool try_process_by_vmThread(JavaThread* target);
#ifdef ASSERT
Thread* _active_handshaker;
Thread* get_active_handshaker() const { return _active_handshaker; }
bool _vmthread_processing_handshake;
bool is_vmthread_processing_handshake() const { return _vmthread_processing_handshake; }
#endif
};

4
src/hotspot/share/runtime/mutexLocker.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -189,7 +189,7 @@ void assert_lock_strong(const Mutex* lock) {
}
void assert_locked_or_safepoint_or_handshake(const Mutex* lock, const JavaThread* thread) {
if (Thread::current() == thread->get_active_handshaker()) return;
if (Thread::current()->is_VM_thread() && thread->is_vmthread_processing_handshake()) return;
assert_locked_or_safepoint(lock);
}
#endif

5
src/hotspot/share/runtime/safepoint.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -494,6 +494,8 @@ void SafepointSynchronize::disarm_safepoint() {
assert(!cur_state->is_running(), "Thread not suspended at safepoint");
cur_state->restart(); // TSS _running
assert(cur_state->is_running(), "safepoint state has not been reset");
SafepointMechanism::disarm_if_needed(current, false /* NO release */);
}
} // ~JavaThreadIteratorWithHandle
@ -734,6 +736,7 @@ static bool safepoint_safe_with(JavaThread *thread, JavaThreadState state) {
}
bool SafepointSynchronize::handshake_safe(JavaThread *thread) {
assert(Thread::current()->is_VM_thread(), "Must be VMThread");
if (thread->is_ext_suspended() || thread->is_terminated()) {
return true;
}

15
src/hotspot/share/runtime/safepointMechanism.inline.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -70,6 +70,19 @@ void SafepointMechanism::disarm_local_poll(JavaThread* thread) {
thread->set_polling_page(poll_disarmed_value());
}
void SafepointMechanism::disarm_if_needed(JavaThread* thread, bool memory_order_release) {
JavaThreadState jts = thread->thread_state();
if (jts == _thread_in_native || jts == _thread_in_native_trans) {
// JavaThread will disarm itself and execute cross_modify_fence() before continuing
return;
}
if (memory_order_release) {
thread->set_polling_page_release(poll_disarmed_value());
} else {
thread->set_polling_page(poll_disarmed_value());
}
}
void SafepointMechanism::arm_local_poll_release(JavaThread* thread) {
thread->set_polling_page_release(poll_armed_value());
}

1
src/hotspot/share/runtime/thread.cpp
View File

@ -1706,7 +1706,6 @@ void JavaThread::initialize() {
_SleepEvent = ParkEvent::Allocate(this);
// Setup safepoint state info for this thread
ThreadSafepointState::create(this);
_handshake.set_thread(this);
debug_only(_java_call_counter = 0);

14
src/hotspot/share/runtime/thread.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -1318,7 +1318,7 @@ class JavaThread: public Thread {
HandshakeState _handshake;
public:
void set_handshake_operation(HandshakeOperation* op) {
_handshake.set_operation(op);
_handshake.set_operation(this, op);
}
bool has_handshake() const {
@ -1326,16 +1326,16 @@ class JavaThread: public Thread {
}
void handshake_process_by_self() {
_handshake.process_by_self();
_handshake.process_by_self(this);
}
bool handshake_try_process(HandshakeOperation* op) {
return _handshake.try_process(op);
bool handshake_try_process_by_vmThread() {
return _handshake.try_process_by_vmThread(this);
}
#ifdef ASSERT
Thread* get_active_handshaker() const {
return _handshake.get_active_handshaker();
bool is_vmthread_processing_handshake() const {
return _handshake.is_vmthread_processing_handshake();
}
#endif

130
test/hotspot/jtreg/runtime/handshake/HandshakeDirectTest.java
View File

@ -1,130 +0,0 @@
/*
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
/*
* @test HandshakeDirectTest
* @summary This test tries to stress direct handshakes between threads while suspending them.
* @library /testlibrary /test/lib
* @build HandshakeDirectTest
* @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+SafepointALot -XX:BiasedLockingDecayTime=100000000 -XX:BiasedLockingBulkRebiasThreshold=1000000 -XX:BiasedLockingBulkRevokeThreshold=1000000 HandshakeDirectTest
* @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:GuaranteedSafepointInterval=10 -XX:+HandshakeALot -XX:+SafepointALot -XX:BiasedLockingDecayTime=100000000 -XX:BiasedLockingBulkRebiasThreshold=1000000 -XX:BiasedLockingBulkRevokeThreshold=1000000 HandshakeDirectTest
*/
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.Semaphore;
import java.io.*;
public class HandshakeDirectTest implements Runnable {
static final int WORKING_THREADS = 32;
static final int DIRECT_HANDSHAKES_MARK = 50000;
static Thread[] workingThreads = new Thread[WORKING_THREADS];
static Semaphore[] handshakeSem = new Semaphore[WORKING_THREADS];
static Object[] locks = new Object[WORKING_THREADS];
static boolean[] isBiased = new boolean[WORKING_THREADS];
static AtomicInteger handshakeCount = new AtomicInteger(0);
@Override
public void run() {
int me = Integer.parseInt(Thread.currentThread().getName());
while (true) {
try {
if (!isBiased[me]) {
handshakeSem[me].acquire();
synchronized(locks[me]) {
isBiased[me] = true;
}
handshakeSem[me].release();
}
// Handshake directly some other worker
int handshakee = ThreadLocalRandom.current().nextInt(0, WORKING_THREADS-1);
if (handshakee == me) {
handshakee = handshakee != 0 ? handshakee - 1 : handshakee + 1;
}
handshakeSem[handshakee].acquire();
if (isBiased[handshakee]) {
// Revoke biased lock
synchronized(locks[handshakee]) {
handshakeCount.incrementAndGet();
}
// Create new lock to be biased
locks[handshakee] = new Object();
isBiased[handshakee] = false;
}
handshakeSem[handshakee].release();
if (handshakeCount.get() >= DIRECT_HANDSHAKES_MARK) {
break;
}
} catch(InterruptedException ie) {
throw new Error("Unexpected interrupt");
}
}
}
public static void main(String... args) throws Exception {
HandshakeDirectTest test = new HandshakeDirectTest();
// Initialize semaphores
for (int i = 0; i < WORKING_THREADS; i++) {
handshakeSem[i] = new Semaphore(1);
}
// Initialize locks
for (int i = 0; i < WORKING_THREADS; i++) {
locks[i] = new Object();
}
// Fire-up working threads.
for (int i = 0; i < WORKING_THREADS; i++) {
workingThreads[i] = new Thread(test, Integer.toString(i));
workingThreads[i].start();
}
// Fire-up suspend-resume thread
Thread suspendResumeThread = new Thread() {
@Override
public void run() {
while (true) {
int i = ThreadLocalRandom.current().nextInt(0, WORKING_THREADS-1);
workingThreads[i].suspend();
try {
Thread.sleep(1); // sleep for 1 ms
} catch(InterruptedException ie) {
}
workingThreads[i].resume();
}
}
};
suspendResumeThread.setDaemon(true);
suspendResumeThread.start();
// Wait until the desired number of direct handshakes is reached
// and check that all workers exited
for (int i = 0; i < WORKING_THREADS; i++) {
workingThreads[i].join();
}
}
}