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

equal deleted inserted replaced

-:3ab9867d7786
+:381638db28e6
 #include "utilities/events.hpp"
 #include "utilities/preserveException.hpp"
 #if defined(__GNUC__) && !defined(PPC64)
 // Need to inhibit inlining for older versions of GCC to avoid build-time failures
-#define ATTR __attribute__((noinline))
+#define NOINLINE __attribute__((noinline))
 #else
-#define ATTR
+#define NOINLINE
 #endif
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 // The "core" versions of monitor enter and exit reside in this file.
 assert(lock != mark->locker(), "must not re-lock the same lock");
 assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
 lock->set_displaced_header(NULL);
 return;
 }
-#if 0
-// The following optimization isn't particularly useful.
-if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
-lock->set_displaced_header(NULL);
-return;
-}
-#endif
 // The object header will never be displaced to this lock,
 // so it does not matter what the value is, except that it
 // must be non-zero to avoid looking like a re-entrant lock,
 // and must not look locked either.
 // the call sites of identity_hash that might revoke biases have
 // been checked to make sure they can handle a safepoint. The
 // added check of the bias pattern is to avoid useless calls to
 // thread-local storage.
 if (obj->mark()->has_bias_pattern()) {
-// Box and unbox the raw reference just in case we cause a STW safepoint.
+// Handle for oop obj in case of STW safepoint
 Handle hobj(Self, obj);
 // Relaxing assertion for bug 6320749.
 assert(Universe::verify_in_progress() ||
 !SafepointSynchronize::is_at_safepoint(),
 "biases should not be seen by VM thread here");
 ::printf ("Monitor scavenge - STW posted @%s (%d)\n", Whence, ForceMonitorScavenge) ;
 ::fflush(stdout);
 }
 }
 }
-/* Too slow for general assert or debug
 void ObjectSynchronizer::verifyInUse (Thread *Self) {
 ObjectMonitor* mid;
 int inusetally = 0;
 for (mid = Self->omInUseList; mid != NULL; mid = mid->FreeNext) {
-inusetally ++;
+inusetally++;
 }
 assert(inusetally == Self->omInUseCount, "inuse count off");
 int freetally = 0;
 for (mid = Self->omFreeList; mid != NULL; mid = mid->FreeNext) {
-freetally ++;
+freetally++;
 }
 assert(freetally == Self->omFreeCount, "free count off");
 }
-*/
-ObjectMonitor * ATTR ObjectSynchronizer::omAlloc (Thread * Self) {
+ObjectMonitor * NOINLINE ObjectSynchronizer::omAlloc (Thread * Self) {
 // A large MAXPRIVATE value reduces both list lock contention
 // and list coherency traffic, but also tends to increase the
 // number of objectMonitors in circulation as well as the STW
 // scavenge costs.  As usual, we lean toward time in space-time
 // tradeoffs.
 guarantee(m->object() == NULL, "invariant");
 if (MonitorInUseLists) {
 m->FreeNext = Self->omInUseList;
 Self->omInUseList = m;
 Self->omInUseCount++;
-// verifyInUse(Self);
+if (ObjectMonitor::Knob_VerifyInUse) {
+verifyInUse(Self);
+}
 } else {
 m->FreeNext = NULL;
 }
 return m;
 }
 Self->omInUseList = mid->FreeNext;
 } else if (curmidinuse != NULL) {
 curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist
 }
 Self->omInUseCount--;
-// verifyInUse(Self);
+if (ObjectMonitor::Knob_VerifyInUse) {
+verifyInUse(Self);
+}
 break;
 } else {
 curmidinuse = mid;
 mid = mid->FreeNext;
 }
 }
 }
-// FreeNext is used for both onInUseList and omFreeList, so clear old before setting new
+// FreeNext is used for both omInUseList and omFreeList, so clear old before setting new
 m->FreeNext = Self->omFreeList;
 Self->omFreeList = m;
 Self->omFreeCount++;
 }
 // it's dying.  We could also consider having the VM thread steal
 // monitors from threads that have not run java code over a few
 // consecutive STW safepoints.  Relatedly, we might decay
 // omFreeProvision at STW safepoints.
 //
-// Also return the monitors of a moribund thread"s omInUseList to
+// Also return the monitors of a moribund thread's omInUseList to
 // a global gOmInUseList under the global list lock so these
 // will continue to be scanned.
 //
 // We currently call omFlush() from the Thread:: dtor _after the thread
 // has been excised from the thread list and is no longer a mutator.
 ObjectMonitor *curom;
 for (curom = InUseList; curom != NULL; curom = curom->FreeNext) {
 InUseTail = curom;
 InUseTally++;
 }
-// TODO debug
 assert(Self->omInUseCount == InUseTally, "inuse count off");
 Self->omInUseCount = 0;
 guarantee(InUseTail != NULL && InUseList != NULL, "invariant");
 }
 // Note that we could encounter some performance loss through false-sharing as
 // multiple locks occupy the same $ line.  Padding might be appropriate.
-ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
+ObjectMonitor * NOINLINE ObjectSynchronizer::inflate (Thread * Self, oop object) {
 // Inflate mutates the heap ...
 // Relaxing assertion for bug 6320749.
 assert(Universe::verify_in_progress() ||
 !SafepointSynchronize::is_at_safepoint(), "invariant");
 };
 // Deflate a single monitor if not in use
 // Return true if deflated, false if in use
 bool ObjectSynchronizer::deflate_monitor(ObjectMonitor* mid, oop obj,
-ObjectMonitor** FreeHeadp, ObjectMonitor** FreeTailp) {
+ObjectMonitor** freeHeadp, ObjectMonitor** freeTailp) {
 bool deflated;
 // Normal case ... The monitor is associated with obj.
 guarantee(obj->mark() == markOopDesc::encode(mid), "invariant");
 guarantee(mid == obj->mark()->monitor(), "invariant");
 guarantee(mid->header()->is_neutral(), "invariant");
 mid->clear();
 assert(mid->object() == NULL, "invariant");
 // Move the object to the working free list defined by FreeHead,FreeTail.
-if (*FreeHeadp == NULL) *FreeHeadp = mid;
+if (*freeHeadp == NULL) *freeHeadp = mid;
-if (*FreeTailp != NULL) {
+if (*freeTailp != NULL) {
-ObjectMonitor * prevtail = *FreeTailp;
+ObjectMonitor * prevtail = *freeTailp;
 assert(prevtail->FreeNext == NULL, "cleaned up deflated?"); // TODO KK
 prevtail->FreeNext = mid;
 }
-*FreeTailp = mid;
+*freeTailp = mid;
 deflated = true;
 }
 return deflated;
 }
 // Caller acquires ListLock
 int ObjectSynchronizer::walk_monitor_list(ObjectMonitor** listheadp,
-ObjectMonitor** FreeHeadp, ObjectMonitor** FreeTailp) {
+ObjectMonitor** freeHeadp, ObjectMonitor** freeTailp) {
 ObjectMonitor* mid;
 ObjectMonitor* next;
 ObjectMonitor* curmidinuse = NULL;
 int deflatedcount = 0;
 for (mid = *listheadp; mid != NULL;) {
 oop obj = (oop) mid->object();
 bool deflated = false;
 if (obj != NULL) {
-deflated = deflate_monitor(mid, obj, FreeHeadp, FreeTailp);
+deflated = deflate_monitor(mid, obj, freeHeadp, freeTailp);
 }
 if (deflated) {
 // extract from per-thread in-use-list
 if (mid == *listheadp) {
 *listheadp = mid->FreeNext;
 int inUse = 0;
 for (JavaThread* cur = Threads::first(); cur != NULL; cur = cur->next()) {
 nInCirculation+= cur->omInUseCount;
 int deflatedcount = walk_monitor_list(cur->omInUseList_addr(), &FreeHead, &FreeTail);
 cur->omInUseCount-= deflatedcount;
-// verifyInUse(cur);
+if (ObjectMonitor::Knob_VerifyInUse) {
+verifyInUse(cur);
+}
 nScavenged += deflatedcount;
 nInuse += cur->omInUseCount;
 }
 // For moribund threads, scan gOmInUseList

changeset 25472	381638db28e6
parent 25468	5331df506290
child 25477	7dad9f95fd31