jdk-sandbox: comparison src/hotspot/share/prims/jvmtiRawMonitor.cpp

equal deleted inserted replaced

-:d6058bd73982
+:7b41c88f8432
 #include "runtime/orderAccess.hpp"
 #include "runtime/thread.inline.hpp"
 JvmtiRawMonitor::QNode::QNode(Thread* thread) : _next(NULL), _prev(NULL),
 _event(thread->_ParkEvent),
-_notified(0), TState(TS_RUN) {
+_notified(0), _t_state(TS_RUN) {
 }
-GrowableArray<JvmtiRawMonitor*> *JvmtiPendingMonitors::_monitors =
+GrowableArray<JvmtiRawMonitor*>* JvmtiPendingMonitors::_monitors =
 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiRawMonitor*>(1, true);
 void JvmtiPendingMonitors::transition_raw_monitors() {
 assert((Threads::number_of_threads()==1),
-"Java thread has not been created yet or more than one java thread \
+"Java thread has not been created yet or more than one java thread "
-is running. Raw monitor transition will not work");
+"is running. Raw monitor transition will not work");
-JavaThread *current_java_thread = JavaThread::current();
+JavaThread* current_java_thread = JavaThread::current();
 assert(current_java_thread->thread_state() == _thread_in_vm, "Must be in vm");
-for(int i=0; i< count(); i++) {
+for (int i = 0; i < count(); i++) {
-JvmtiRawMonitor *rmonitor = monitors()->at(i);
+JvmtiRawMonitor* rmonitor = monitors()->at(i);
 rmonitor->raw_enter(current_java_thread);
 }
 // pending monitors are converted to real monitor so delete them all.
 dispose();
 }
 //
 // class JvmtiRawMonitor
 //
-JvmtiRawMonitor::JvmtiRawMonitor(const char *name) : _owner(NULL),
+JvmtiRawMonitor::JvmtiRawMonitor(const char* name) : _owner(NULL),
 _recursions(0),
-_EntryList(NULL),
+_entry_list(NULL),
-_WaitSet(NULL),
+_wait_set(NULL),
 _waiters(0),
 _magic(JVMTI_RM_MAGIC),
 _name(NULL) {
 #ifdef ASSERT
 _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtInternal), name);
 // is fairly rare, this is not of concern.  The RawMonitor_lock can not
 // be held indefinitely.  The critical sections must be short and bounded.
 //
 // -------------------------------------------------------------------------
-void JvmtiRawMonitor::SimpleEnter (Thread * Self) {
+void JvmtiRawMonitor::simple_enter(Thread* self) {
 for (;;) {
-if (Atomic::replace_if_null(Self, &_owner)) {
+if (Atomic::replace_if_null(self, &_owner)) {
-return ;
+return;
 }
-QNode Node (Self) ;
+QNode node(self);
-Self->_ParkEvent->reset() ;     // strictly optional
+self->_ParkEvent->reset();     // strictly optional
-Node.TState = QNode::TS_ENTER ;
+node._t_state = QNode::TS_ENTER;
-RawMonitor_lock->lock_without_safepoint_check() ;
+RawMonitor_lock->lock_without_safepoint_check();
-Node._next  = _EntryList ;
+node._next = _entry_list;
-_EntryList  = &Node ;
+_entry_list = &node;
-OrderAccess::fence() ;
+OrderAccess::fence();
-if (_owner == NULL && Atomic::replace_if_null(Self, &_owner)) {
+if (_owner == NULL && Atomic::replace_if_null(self, &_owner)) {
-_EntryList = Node._next ;
+_entry_list = node._next;
-RawMonitor_lock->unlock() ;
+RawMonitor_lock->unlock();
-return ;
+return;
 }
-RawMonitor_lock->unlock() ;
+RawMonitor_lock->unlock();
-while (Node.TState == QNode::TS_ENTER) {
+while (node._t_state == QNode::TS_ENTER) {
-Self->_ParkEvent->park() ;
+self->_ParkEvent->park();
 }
 }
 }
-void JvmtiRawMonitor::SimpleExit (Thread * Self) {
+void JvmtiRawMonitor::simple_exit(Thread* self) {
-guarantee (_owner == Self, "invariant") ;
+guarantee(_owner == self, "invariant");
-OrderAccess::release_store(&_owner, (Thread*)NULL) ;
+OrderAccess::release_store(&_owner, (Thread*)NULL);
-OrderAccess::fence() ;
+OrderAccess::fence();
-if (_EntryList == NULL) return ;
+if (_entry_list == NULL) {
-QNode * w ;
+return;
+}
-RawMonitor_lock->lock_without_safepoint_check() ;
-w = _EntryList ;
+RawMonitor_lock->lock_without_safepoint_check();
+QNode* w = _entry_list;
 if (w != NULL) {
-_EntryList = w->_next ;
+_entry_list = w->_next;
 }
-RawMonitor_lock->unlock() ;
+RawMonitor_lock->unlock();
 if (w != NULL) {
-guarantee (w ->TState == QNode::TS_ENTER, "invariant") ;
+guarantee(w ->_t_state == QNode::TS_ENTER, "invariant");
-// Once we set TState to TS_RUN the waiting thread can complete
+// Once we set _t_state to TS_RUN the waiting thread can complete
-// SimpleEnter and 'w' is pointing into random stack space. So we have
+// simple_enter and 'w' is pointing into random stack space. So we have
 // to ensure we extract the ParkEvent (which is in type-stable memory)
 // before we set the state, and then don't access 'w'.
-ParkEvent * ev = w->_event ;
+ParkEvent* ev = w->_event;
 OrderAccess::loadstore();
-w->TState = QNode::TS_RUN ;
+w->_t_state = QNode::TS_RUN;
-OrderAccess::fence() ;
+OrderAccess::fence();
-ev->unpark() ;
+ev->unpark();
 }
-return ;
+return;
 }
-int JvmtiRawMonitor::SimpleWait (Thread * Self, jlong millis) {
+int JvmtiRawMonitor::simple_wait(Thread* self, jlong millis) {
-guarantee (_owner == Self  , "invariant") ;
+guarantee(_owner == self  , "invariant");
-guarantee (_recursions == 0, "invariant") ;
+guarantee(_recursions == 0, "invariant");
-QNode Node (Self) ;
+QNode node(self);
-Node._notified = 0 ;
+node._notified = 0;
-Node.TState    = QNode::TS_WAIT ;
+node._t_state = QNode::TS_WAIT;
-RawMonitor_lock->lock_without_safepoint_check() ;
+RawMonitor_lock->lock_without_safepoint_check();
-Node._next     = _WaitSet ;
+node._next = _wait_set;
-_WaitSet       = &Node ;
+_wait_set = &node;
-RawMonitor_lock->unlock() ;
+RawMonitor_lock->unlock();
-SimpleExit (Self) ;
+simple_exit(self);
-guarantee (_owner != Self, "invariant") ;
+guarantee(_owner != self, "invariant");
-int ret = OS_OK ;
+int ret = OS_OK;
 if (millis <= 0) {
-Self->_ParkEvent->park();
+self->_ParkEvent->park();
 } else {
-ret = Self->_ParkEvent->park(millis);
+ret = self->_ParkEvent->park(millis);
 }
 // If thread still resides on the waitset then unlink it.
 // Double-checked locking -- the usage is safe in this context
-// as TState is volatile and the lock-unlock operators are
+// as _t_state is volatile and the lock-unlock operators are
 // serializing (barrier-equivalent).
-if (Node.TState == QNode::TS_WAIT) {
+if (node._t_state == QNode::TS_WAIT) {
-RawMonitor_lock->lock_without_safepoint_check() ;
+RawMonitor_lock->lock_without_safepoint_check();
-if (Node.TState == QNode::TS_WAIT) {
+if (node._t_state == QNode::TS_WAIT) {
 // Simple O(n) unlink, but performance isn't critical here.
-QNode * p ;
+QNode* p;
-QNode * q = NULL ;
+QNode* q = NULL;
-for (p = _WaitSet ; p != &Node; p = p->_next) {
+for (p = _wait_set; p != &node; p = p->_next) {
-q = p ;
+q = p;
 }
-guarantee (p == &Node, "invariant") ;
+guarantee(p == &node, "invariant");
 if (q == NULL) {
-guarantee (p == _WaitSet, "invariant") ;
+guarantee (p == _wait_set, "invariant");
-_WaitSet = p->_next ;
+_wait_set = p->_next;
 } else {
-guarantee (p == q->_next, "invariant") ;
+guarantee(p == q->_next, "invariant");
-q->_next = p->_next ;
+q->_next = p->_next;
 }
-Node.TState = QNode::TS_RUN ;
+node._t_state = QNode::TS_RUN;
 }
-RawMonitor_lock->unlock() ;
+RawMonitor_lock->unlock();
 }
-guarantee (Node.TState == QNode::TS_RUN, "invariant") ;
+guarantee(node._t_state == QNode::TS_RUN, "invariant");
-SimpleEnter (Self) ;
+simple_enter(self);
-guarantee (_owner == Self, "invariant") ;
+guarantee(_owner == self, "invariant");
-guarantee (_recursions == 0, "invariant") ;
+guarantee(_recursions == 0, "invariant");
-return ret ;
+return ret;
 }
-void JvmtiRawMonitor::SimpleNotify (Thread * Self, bool All) {
+void JvmtiRawMonitor::simple_notify(Thread* self, bool all) {
-guarantee (_owner == Self, "invariant") ;
+guarantee(_owner == self, "invariant");
-if (_WaitSet == NULL) return ;
+if (_wait_set == NULL) {
+return;
+}
 // We have two options:
-// A. Transfer the threads from the WaitSet to the EntryList
+// A. Transfer the threads from the _wait_set to the _entry_list
-// B. Remove the thread from the WaitSet and unpark() it.
+// B. Remove the thread from the _wait_set and unpark() it.
 //
 // We use (B), which is crude and results in lots of futile
 // context switching.  In particular (B) induces lots of contention.
-ParkEvent * ev = NULL ;       // consider using a small auto array ...
+ParkEvent* ev = NULL;       // consider using a small auto array ...
-RawMonitor_lock->lock_without_safepoint_check() ;
+RawMonitor_lock->lock_without_safepoint_check();
 for (;;) {
-QNode * w = _WaitSet ;
+QNode* w = _wait_set;
-if (w == NULL) break ;
+if (w == NULL) break;
-_WaitSet = w->_next ;
+_wait_set = w->_next;
-if (ev != NULL) { ev->unpark(); ev = NULL; }
+if (ev != NULL) {
-ev = w->_event ;
+ev->unpark();
-OrderAccess::loadstore() ;
+ev = NULL;
-w->TState = QNode::TS_RUN ;
+}
-OrderAccess::storeload();
+ev = w->_event;
-if (!All) break ;
+OrderAccess::loadstore();
-}
+w->_t_state = QNode::TS_RUN;
-RawMonitor_lock->unlock() ;
+OrderAccess::storeload();
-if (ev != NULL) ev->unpark();
+if (!all) {
-return ;
+break;
+}
+}
+RawMonitor_lock->unlock();
+if (ev != NULL) {
+ev->unpark();
+}
+return;
 }
 // Any JavaThread will enter here with state _thread_blocked
-void JvmtiRawMonitor::raw_enter(Thread * Self) {
+void JvmtiRawMonitor::raw_enter(Thread* self) {
-void * Contended ;
+void* contended;
-JavaThread * jt = NULL;
+JavaThread* jt = NULL;
 // don't enter raw monitor if thread is being externally suspended, it will
 // surprise the suspender if a "suspended" thread can still enter monitor
-if (Self->is_Java_thread()) {
+if (self->is_Java_thread()) {
-jt = (JavaThread*) Self;
+jt = (JavaThread*)self;
 jt->SR_lock()->lock_without_safepoint_check();
 while (jt->is_external_suspend()) {
 jt->SR_lock()->unlock();
 jt->java_suspend_self();
 jt->SR_lock()->lock_without_safepoint_check();
 }
 // guarded by SR_lock to avoid racing with new external suspend requests.
-Contended = Atomic::cmpxchg(jt, &_owner, (Thread*)NULL);
+contended = Atomic::cmpxchg(jt, &_owner, (Thread*)NULL);
 jt->SR_lock()->unlock();
 } else {
-Contended = Atomic::cmpxchg(Self, &_owner, (Thread*)NULL);
+contended = Atomic::cmpxchg(self, &_owner, (Thread*)NULL);
 }
-if (Contended == Self) {
+if (contended == self) {
-_recursions ++ ;
+_recursions++;
-return ;
+return;
 }
-if (Contended == NULL) {
+if (contended == NULL) {
-guarantee (_owner == Self, "invariant") ;
+guarantee(_owner == self, "invariant");
-guarantee (_recursions == 0, "invariant") ;
+guarantee(_recursions == 0, "invariant");
-return ;
+return;
 }
-Self->set_current_pending_raw_monitor(this);
+self->set_current_pending_raw_monitor(this);
-if (!Self->is_Java_thread()) {
+if (!self->is_Java_thread()) {
-SimpleEnter (Self) ;
+simple_enter(self);
 } else {
-guarantee (jt->thread_state() == _thread_blocked, "invariant") ;
+guarantee(jt->thread_state() == _thread_blocked, "invariant");
 for (;;) {
 jt->set_suspend_equivalent();
 // cleared by handle_special_suspend_equivalent_condition() or
 // java_suspend_self()
-SimpleEnter (jt) ;
+simple_enter(jt);
 // were we externally suspended while we were waiting?
-if (!jt->handle_special_suspend_equivalent_condition()) break ;
+if (!jt->handle_special_suspend_equivalent_condition()) {
+break;
+}
 // This thread was externally suspended
 // We have reentered the contended monitor, but while we were
 // waiting another thread suspended us. We don't want to reenter
 // the monitor while suspended because that would surprise the
 // thread that suspended us.
 //
 // Drop the lock
-SimpleExit (jt) ;
+simple_exit(jt);
 jt->java_suspend_self();
 }
 }
-Self->set_current_pending_raw_monitor(NULL);
+self->set_current_pending_raw_monitor(NULL);
-guarantee (_owner == Self, "invariant") ;
+guarantee(_owner == self, "invariant");
-guarantee (_recursions == 0, "invariant") ;
+guarantee(_recursions == 0, "invariant");
 }
-int JvmtiRawMonitor::raw_exit(Thread * Self) {
+int JvmtiRawMonitor::raw_exit(Thread* self) {
-if (Self != _owner) {
+if (self != _owner) {
 return M_ILLEGAL_MONITOR_STATE;
 }
 if (_recursions > 0) {
---_recursions ;
+_recursions--;
 } else {
-SimpleExit (Self) ;
+simple_exit(self);
 }
 return M_OK;
 }
 // All JavaThreads will enter here with state _thread_blocked
-int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, Thread * Self) {
+int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, Thread* self) {
-if (Self != _owner) {
+if (self != _owner) {
 return M_ILLEGAL_MONITOR_STATE;
 }
-// To avoid spurious wakeups we reset the parkevent -- This is strictly optional.
+// To avoid spurious wakeups we reset the parkevent. This is strictly optional.
 // The caller must be able to tolerate spurious returns from raw_wait().
-Self->_ParkEvent->reset() ;
+self->_ParkEvent->reset();
-OrderAccess::fence() ;
+OrderAccess::fence();
-JavaThread * jt = NULL;
+JavaThread* jt = NULL;
 // check interrupt event
 if (interruptible) {
-assert(Self->is_Java_thread(), "Only JavaThreads can be interruptible");
+assert(self->is_Java_thread(), "Only JavaThreads can be interruptible");
-jt = (JavaThread*) Self;
+jt = (JavaThread*)self;
 if (jt->is_interrupted(true)) {
 return M_INTERRUPTED;
 }
 } else {
-assert(!Self->is_Java_thread(), "JavaThreads must be interuptible");
+assert(!self->is_Java_thread(), "JavaThreads must be interuptible");
 }
-intptr_t save = _recursions ;
+intptr_t save = _recursions;
-_recursions = 0 ;
+_recursions = 0;
-_waiters ++ ;
+_waiters++;
-if (Self->is_Java_thread()) {
+if (self->is_Java_thread()) {
-guarantee (jt->thread_state() == _thread_blocked, "invariant") ;
+guarantee(jt->thread_state() == _thread_blocked, "invariant");
 jt->set_suspend_equivalent();
 }
-int rv = SimpleWait (Self, millis) ;
+int rv = simple_wait(self, millis);
-_recursions = save ;
+_recursions = save;
-_waiters -- ;
+_waiters--;
-guarantee (Self == _owner, "invariant") ;
+guarantee(self == _owner, "invariant");
-if (Self->is_Java_thread()) {
+if (self->is_Java_thread()) {
 for (;;) {
-if (!jt->handle_special_suspend_equivalent_condition()) break ;
+if (!jt->handle_special_suspend_equivalent_condition()) {
-SimpleExit (jt) ;
+break;
-jt->java_suspend_self();
+}
-SimpleEnter (jt) ;
+simple_exit(jt);
-jt->set_suspend_equivalent() ;
+jt->java_suspend_self();
-}
+simple_enter(jt);
-guarantee (jt == _owner, "invariant") ;
+jt->set_suspend_equivalent();
+}
+guarantee(jt == _owner, "invariant");
 }
 if (interruptible && jt->is_interrupted(true)) {
 return M_INTERRUPTED;
 }
-return M_OK ;
+return M_OK;
 }
-int JvmtiRawMonitor::raw_notify(Thread * Self) {
+int JvmtiRawMonitor::raw_notify(Thread* self) {
-if (Self != _owner) {
+if (self != _owner) {
 return M_ILLEGAL_MONITOR_STATE;
 }
-SimpleNotify (Self, false) ;
+simple_notify(self, false);
 return M_OK;
 }
-int JvmtiRawMonitor::raw_notifyAll(Thread * Self) {
+int JvmtiRawMonitor::raw_notifyAll(Thread* self) {
-if (Self != _owner) {
+if (self != _owner) {
 return M_ILLEGAL_MONITOR_STATE;
 }
-SimpleNotify (Self, true) ;
+simple_notify(self, true);
 return M_OK;
 }

changeset 58509	7b41c88f8432
parent 58488	165b193b30dd
child 58679	9c3209ff7550
child 59105	76ae9aa0e794