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

equal deleted inserted replaced

-:6523fa019ffa
+:785a8d56024c
 if (THREAD != _owner) {
 if (THREAD->is_lock_owned ((address)_owner)) {
 assert(_recursions == 0, "internal state error");
 _owner = THREAD;
 _recursions = 1;
-OwnerIsThread = 1;
 return true;
 }
 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
 return false;
 }
 void * cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL);
 if (cur == NULL) {
 // Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
 assert(_recursions == 0, "invariant");
 assert(_owner == Self, "invariant");
-// CONSIDER: set or assert OwnerIsThread == 1
 return;
 }
 if (cur == Self) {
 // TODO-FIXME: check for integer overflow!  BUGID 6557169.
 assert(_recursions == 0, "internal state error");
 _recursions = 1;
 // Commute owner from a thread-specific on-stack BasicLockObject address to
 // a full-fledged "Thread *".
 _owner = Self;
-OwnerIsThread = 1;
 return;
 }
 // We've encountered genuine contention.
 assert(Self->_Stalled == 0, "invariant");
 assert(this->object() != NULL, "invariant");
 assert(_count >= 0, "invariant");
 // Prevent deflation at STW-time.  See deflate_idle_monitors() and is_busy().
 // Ensure the object-monitor relationship remains stable while there's contention.
-Atomic::inc_ptr(&_count);
+Atomic::inc(&_count);
 EventJavaMonitorEnter event;
 { // Change java thread status to indicate blocked on monitor enter.
 JavaThreadBlockedOnMonitorEnterState jtbmes(jt, this);
 // as having "-locked" the monitor, but the OS and java.lang.Thread
 // states will still report that the thread is blocked trying to
 // acquire it.
 }
-Atomic::dec_ptr(&_count);
+Atomic::dec(&_count);
 assert(_count >= 0, "invariant");
 Self->_Stalled = 0;
 // Must either set _recursions = 0 or ASSERT _recursions == 0.
 assert(_recursions == 0, "invariant");
 if (own != NULL) return 0;
 if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
 // Either guarantee _recursions == 0 or set _recursions = 0.
 assert(_recursions == 0, "invariant");
 assert(_owner == Self, "invariant");
-// CONSIDER: set or assert that OwnerIsThread == 1
 return 1;
 }
 // The lock had been free momentarily, but we lost the race to the lock.
 // Interference -- the CAS failed.
 // We can either return -1 or retry.
 // Non-null to Non-null is safe as long as all readers can
 // tolerate either flavor.
 assert(_recursions == 0, "invariant");
 _owner = THREAD;
 _recursions = 0;
-OwnerIsThread = 1;
 } else {
 // Apparent unbalanced locking ...
 // Naively we'd like to throw IllegalMonitorStateException.
 // As a practical matter we can neither allocate nor throw an
 // exception as ::exit() can be called from leaf routines.
 if (THREAD != _owner) {
 if (THREAD->is_lock_owned ((address)_owner)) {
 assert(_recursions == 0, "internal state error");
 _owner = THREAD;   // Convert from basiclock addr to Thread addr
 _recursions = 0;
-OwnerIsThread = 1;
 }
 }
 guarantee(Self == _owner, "complete_exit not owner");
 intptr_t save = _recursions; // record the old recursion count
 do {                                                                      \
 if (THREAD != _owner) {                                                 \
 if (THREAD->is_lock_owned((address) _owner)) {                        \
 _owner = THREAD;  /* Convert from basiclock addr to Thread addr */  \
 _recursions = 0;                                                    \
-OwnerIsThread = 1;                                                  \
 } else {                                                              \
 TEVENT(Throw IMSX);                                                 \
 THROW(vmSymbols::java_lang_IllegalMonitorStateException());         \
 }                                                                     \
 }                                                                       \
 // algorithm.  On high order SMP systems it would be better to start with
 // a brief global spin and then revert to spinning locally.  In the spirit of MCS/CLH,
 // a contending thread could enqueue itself on the cxq and then spin locally
 // on a thread-specific variable such as its ParkEvent._Event flag.
 // That's left as an exercise for the reader.  Note that global spinning is
-// not problematic on Niagara, as the L2$ serves the interconnect and has both
+// not problematic on Niagara, as the L2 cache serves the interconnect and
-// low latency and massive bandwidth.
+// has both low latency and massive bandwidth.
 //
 // Broadly, we can fix the spin frequency -- that is, the % of contended lock
 // acquisition attempts where we opt to spin --  at 100% and vary the spin count
 // (duration) or we can fix the count at approximately the duration of
 // a context switch and vary the frequency.   Of course we could also
 // observed by NotRunnable() might be garbage.  NotRunnable must
 // tolerate this and consider the observed _thread_state value
 // as advisory.
 //
 // Beware too, that _owner is sometimes a BasicLock address and sometimes
-// a thread pointer.  We differentiate the two cases with OwnerIsThread.
+// a thread pointer.
 // Alternately, we might tag the type (thread pointer vs basiclock pointer)
 // with the LSB of _owner.  Another option would be to probablistically probe
 // the putative _owner->TypeTag value.
 //
 // Checking _thread_state isn't perfect.  Even if the thread is
 // The caller must tolerate false-negative and false-positive errors.
 // Spinning, in general, is probabilistic anyway.
 int ObjectMonitor::NotRunnable(Thread * Self, Thread * ox) {
-// Check either OwnerIsThread or ox->TypeTag == 2BAD.
+// Check ox->TypeTag == 2BAD.
-if (!OwnerIsThread) return 0;
 if (ox == NULL) return 0;
 // Avoid transitive spinning ...
 // Say T1 spins or blocks trying to acquire L.  T1._Stalled is set to L.
 // Immediately after T1 acquires L it's possible that T2, also
 NEWPERFVARIABLE(_sync_MonExtant);
 #undef NEWPERFCOUNTER
 #undef NEWPERFVARIABLE
 }
 }
-// Compile-time asserts
-// When possible, it's better to catch errors deterministically at
-// compile-time than at runtime.  The down-side to using compile-time
-// asserts is that error message -- often something about negative array
-// indices -- is opaque.
-#define CTASSERT(x) { int tag[1-(2*!(x))]; printf ("Tag @" INTPTR_FORMAT "\n", (intptr_t)tag); }
-void ObjectMonitor::ctAsserts() {
-CTASSERT(offset_of (ObjectMonitor, _header) == 0);
-}
 static char * kvGet(char * kvList, const char * Key) {
 if (kvList == NULL) return NULL;
 size_t n = strlen(Key);
 char * Search;
 bool verbose = Knob_Verbose != 0 NOT_PRODUCT(|| VerboseInternalVMTests);
 if (verbose) {
 tty->print_cr("INFO: sizeof(ObjectMonitor)=" SIZE_FORMAT,
 sizeof(ObjectMonitor));
+tty->print_cr("INFO: sizeof(PaddedEnd<ObjectMonitor>)=" SIZE_FORMAT,
+sizeof(PaddedEnd<ObjectMonitor>));
 }
 uint cache_line_size = VM_Version::L1_data_cache_line_size();
 if (verbose) {
 tty->print_cr("INFO: L1_data_cache_line_size=%u", cache_line_size);
 tty->print_cr("WARNING: the _header and _owner fields are closer "
 "than a cache line which permits false sharing.");
 warning_cnt++;
 }
-if ((sizeof(ObjectMonitor) % cache_line_size) != 0) {
+if ((sizeof(PaddedEnd<ObjectMonitor>) % cache_line_size) != 0) {
-tty->print_cr("WARNING: ObjectMonitor size is not a multiple of "
+tty->print_cr("WARNING: PaddedEnd<ObjectMonitor> size is not a "
-"a cache line which permits false sharing.");
+"multiple of a cache line which permits false sharing.");
 warning_cnt++;
 }
 }
 ObjectSynchronizer::sanity_checks(verbose, cache_line_size, &error_cnt,

changeset 27165	785a8d56024c
parent 26684	d1221849ea3d
child 31782	b23b74f8ae8d