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

equal deleted inserted replaced

-:a7ba42fa1df6
+:d4e471395ff5
 DTRACE_MONITOR_PROBE(waited, monitor, obj(), thr);
 return 0;
 }
 #define NINFLATIONLOCKS 256
-static volatile intptr_t InflationLocks[NINFLATIONLOCKS];
+static volatile intptr_t gInflationLocks[NINFLATIONLOCKS];
+// global list of blocks of monitors
 // gBlockList is really PaddedEnd<ObjectMonitor> *, but we don't
 // want to expose the PaddedEnd template more than necessary.
 ObjectMonitor * ObjectSynchronizer::gBlockList = NULL;
+// global monitor free list
 ObjectMonitor * volatile ObjectSynchronizer::gFreeList  = NULL;
+// global monitor in-use list, for moribund threads,
+// monitors they inflated need to be scanned for deflation
 ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList  = NULL;
+// count of entries in gOmInUseList
 int ObjectSynchronizer::gOmInUseCount = 0;
-static volatile intptr_t ListLock = 0;      // protects global monitor free-list cache
-static volatile int MonitorFreeCount  = 0;  // # on gFreeList
+static volatile intptr_t gListLock = 0;      // protects global monitor lists
-static volatile int MonitorPopulation = 0;  // # Extant -- in circulation
+static volatile int gMonitorFreeCount  = 0;  // # on gFreeList
+static volatile int gMonitorPopulation = 0;  // # Extant -- in circulation
 #define CHAINMARKER (cast_to_oop<intptr_t>(-1))
 // =====================> Quick functions
 // wakes at most one thread whereas we need to wake the entire list.
 int ix = (cast_from_oop<intptr_t>(obj) >> 5) & (NINFLATIONLOCKS-1);
 int YieldThenBlock = 0;
 assert(ix >= 0 && ix < NINFLATIONLOCKS, "invariant");
 assert((NINFLATIONLOCKS & (NINFLATIONLOCKS-1)) == 0, "invariant");
-Thread::muxAcquire(InflationLocks + ix, "InflationLock");
+Thread::muxAcquire(gInflationLocks + ix, "gInflationLock");
 while (obj->mark() == markOopDesc::INFLATING()) {
 // Beware: NakedYield() is advisory and has almost no effect on some platforms
 // so we periodically call Self->_ParkEvent->park(1).
 // We use a mixed spin/yield/block mechanism.
 if ((YieldThenBlock++) >= 16) {
 Thread::current()->_ParkEvent->park(1);
 } else {
 os::naked_yield();
 }
 }
-Thread::muxRelease(InflationLocks + ix);
+Thread::muxRelease(gInflationLocks + ix);
 TEVENT(Inflate: INFLATING - yield/park);
 }
 } else {
 SpinPause();       // SMP-polite spinning
 }
 // Inflation unlinks monitors from the global gFreeList and
 // associates them with objects.  Deflation -- which occurs at
 // STW-time -- disassociates idle monitors from objects.  Such
 // scavenged monitors are returned to the gFreeList.
 //
-// The global list is protected by ListLock.  All the critical sections
+// The global list is protected by gListLock.  All the critical sections
 // are short and operate in constant-time.
 //
 // ObjectMonitors reside in type-stable memory (TSM) and are immortal.
 //
 // Lifecycle:
 }
 }
 void ObjectSynchronizer::verifyInUse(Thread *Self) {
 ObjectMonitor* mid;
-int inusetally = 0;
+int in_use_tally = 0;
 for (mid = Self->omInUseList; mid != NULL; mid = mid->FreeNext) {
-inusetally++;
+in_use_tally++;
 }
-assert(inusetally == Self->omInUseCount, "inuse count off");
+assert(in_use_tally == Self->omInUseCount, "in-use count off");
-int freetally = 0;
+int free_tally = 0;
 for (mid = Self->omFreeList; mid != NULL; mid = mid->FreeNext) {
-freetally++;
+free_tally++;
 }
-assert(freetally == Self->omFreeCount, "free count off");
+assert(free_tally == Self->omFreeCount, "free count off");
 }
 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
 // 1: try to allocate from the thread's local omFreeList.
 // Threads will attempt to allocate first from their local list, then
 // from the global list, and only after those attempts fail will the thread
 // attempt to instantiate new monitors.   Thread-local free lists take
-// heat off the ListLock and improve allocation latency, as well as reducing
+// heat off the gListLock and improve allocation latency, as well as reducing
 // coherency traffic on the shared global list.
 m = Self->omFreeList;
 if (m != NULL) {
 Self->omFreeList = m->FreeNext;
 Self->omFreeCount--;
 // to reprovision the caller's free list.
 if (gFreeList != NULL) {
 // Reprovision the thread's omFreeList.
 // Use bulk transfers to reduce the allocation rate and heat
 // on various locks.
-Thread::muxAcquire(&ListLock, "omAlloc");
+Thread::muxAcquire(&gListLock, "omAlloc");
 for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL;) {
-MonitorFreeCount--;
+gMonitorFreeCount--;
 ObjectMonitor * take = gFreeList;
 gFreeList = take->FreeNext;
 guarantee(take->object() == NULL, "invariant");
 guarantee(!take->is_busy(), "invariant");
 take->Recycle();
 omRelease(Self, take, false);
 }
-Thread::muxRelease(&ListLock);
+Thread::muxRelease(&gListLock);
 Self->omFreeProvision += 1 + (Self->omFreeProvision/2);
 if (Self->omFreeProvision > MAXPRIVATE) Self->omFreeProvision = MAXPRIVATE;
 TEVENT(omFirst - reprovision);
 const int mx = MonitorBound;
-if (mx > 0 && (MonitorPopulation-MonitorFreeCount) > mx) {
+if (mx > 0 && (gMonitorPopulation-gMonitorFreeCount) > mx) {
 // We can't safely induce a STW safepoint from omAlloc() as our thread
 // state may not be appropriate for such activities and callers may hold
 // naked oops, so instead we defer the action.
 InduceScavenge(Self, "omAlloc");
 }
 // Consider carving out this thread's current request from the
 // block in hand.  This avoids some lock traffic and redundant
 // list activity.
-// Acquire the ListLock to manipulate BlockList and FreeList.
+// Acquire the gListLock to manipulate gBlockList and gFreeList.
 // An Oyama-Taura-Yonezawa scheme might be more efficient.
-Thread::muxAcquire(&ListLock, "omAlloc [2]");
+Thread::muxAcquire(&gListLock, "omAlloc [2]");
-MonitorPopulation += _BLOCKSIZE-1;
+gMonitorPopulation += _BLOCKSIZE-1;
-MonitorFreeCount += _BLOCKSIZE-1;
+gMonitorFreeCount += _BLOCKSIZE-1;
 // Add the new block to the list of extant blocks (gBlockList).
 // The very first objectMonitor in a block is reserved and dedicated.
 // It serves as blocklist "next" linkage.
 temp[0].FreeNext = gBlockList;
 gBlockList = temp;
 // Add the new string of objectMonitors to the global free list
 temp[_BLOCKSIZE - 1].FreeNext = gFreeList;
 gFreeList = temp + 1;
-Thread::muxRelease(&ListLock);
+Thread::muxRelease(&gListLock);
 TEVENT(Allocate block of monitors);
 }
 }
 // Place "m" on the caller's private per-thread omFreeList.
 // In practice there's no need to clamp or limit the number of
 // monitors on a thread's omFreeList as the only time we'll call
 // omRelease is to return a monitor to the free list after a CAS
 // attempt failed.  This doesn't allow unbounded #s of monitors to
 // accumulate on a thread's free list.
+//
+// Key constraint: all ObjectMonitors on a thread's free list and the global
+// free list must have their object field set to null. This prevents the
+// scavenger -- deflate_idle_monitors -- from reclaiming them.
 void ObjectSynchronizer::omRelease(Thread * Self, ObjectMonitor * m,
 bool fromPerThreadAlloc) {
 guarantee(m->object() == NULL, "invariant");
+guarantee(((m->is_busy()|m->_recursions) == 0), "freeing in-use monitor");
 // Remove from omInUseList
 if (MonitorInUseLists && fromPerThreadAlloc) {
-ObjectMonitor* curmidinuse = NULL;
+ObjectMonitor* cur_mid_in_use = NULL;
-for (ObjectMonitor* mid = Self->omInUseList; mid != NULL;) {
+bool extracted = false;
+for (ObjectMonitor* mid = Self->omInUseList; mid != NULL; cur_mid_in_use = mid, mid = mid->FreeNext) {
 if (m == mid) {
-// extract from per-thread in-use-list
+// extract from per-thread in-use list
 if (mid == Self->omInUseList) {
 Self->omInUseList = mid->FreeNext;
-} else if (curmidinuse != NULL) {
+} else if (cur_mid_in_use != NULL) {
-curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist
+cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
 }
+extracted = true;
 Self->omInUseCount--;
 if (ObjectMonitor::Knob_VerifyInUse) {
 verifyInUse(Self);
 }
 break;
-} else {
-curmidinuse = mid;
-mid = mid->FreeNext;
 }
 }
+assert(extracted, "Should have extracted from in-use list");
 }
 // FreeNext is used for both omInUseList and omFreeList, so clear old before setting new
 m->FreeNext = Self->omFreeList;
 Self->omFreeList = m;
 // not at a safepoint at the time of the call, and thus there could
 // be not inopportune interleavings between omFlush() and the scavenge
 // operator.
 void ObjectSynchronizer::omFlush(Thread * Self) {
-ObjectMonitor * List = Self->omFreeList;  // Null-terminated SLL
+ObjectMonitor * list = Self->omFreeList;  // Null-terminated SLL
 Self->omFreeList = NULL;
-ObjectMonitor * Tail = NULL;
+ObjectMonitor * tail = NULL;
-int Tally = 0;
+int tally = 0;
-if (List != NULL) {
+if (list != NULL) {
 ObjectMonitor * s;
-for (s = List; s != NULL; s = s->FreeNext) {
+// The thread is going away, the per-thread free monitors
-Tally++;
+// are freed via set_owner(NULL)
-Tail = s;
+// Link them to tail, which will be linked into the global free list
+// gFreeList below, under the gListLock
+for (s = list; s != NULL; s = s->FreeNext) {
+tally++;
+tail = s;
 guarantee(s->object() == NULL, "invariant");
 guarantee(!s->is_busy(), "invariant");
 s->set_owner(NULL);   // redundant but good hygiene
 TEVENT(omFlush - Move one);
 }
-guarantee(Tail != NULL && List != NULL, "invariant");
+guarantee(tail != NULL && list != NULL, "invariant");
 }
-ObjectMonitor * InUseList = Self->omInUseList;
+ObjectMonitor * inUseList = Self->omInUseList;
-ObjectMonitor * InUseTail = NULL;
+ObjectMonitor * inUseTail = NULL;
-int InUseTally = 0;
+int inUseTally = 0;
-if (InUseList != NULL) {
+if (inUseList != NULL) {
 Self->omInUseList = NULL;
-ObjectMonitor *curom;
+ObjectMonitor *cur_om;
-for (curom = InUseList; curom != NULL; curom = curom->FreeNext) {
+// The thread is going away, however the omInUseList inflated
-InUseTail = curom;
+// monitors may still be in-use by other threads.
-InUseTally++;
+// Link them to inUseTail, which will be linked into the global in-use list
-}
+// gOmInUseList below, under the gListLock
-assert(Self->omInUseCount == InUseTally, "inuse count off");
+for (cur_om = inUseList; cur_om != NULL; cur_om = cur_om->FreeNext) {
+inUseTail = cur_om;
+inUseTally++;
+}
+assert(Self->omInUseCount == inUseTally, "in-use count off");
 Self->omInUseCount = 0;
-guarantee(InUseTail != NULL && InUseList != NULL, "invariant");
+guarantee(inUseTail != NULL && inUseList != NULL, "invariant");
 }
-Thread::muxAcquire(&ListLock, "omFlush");
+Thread::muxAcquire(&gListLock, "omFlush");
-if (Tail != NULL) {
+if (tail != NULL) {
-Tail->FreeNext = gFreeList;
+tail->FreeNext = gFreeList;
-gFreeList = List;
+gFreeList = list;
-MonitorFreeCount += Tally;
+gMonitorFreeCount += tally;
 }
-if (InUseTail != NULL) {
+if (inUseTail != NULL) {
-InUseTail->FreeNext = gOmInUseList;
+inUseTail->FreeNext = gOmInUseList;
-gOmInUseList = InUseList;
+gOmInUseList = inUseList;
-gOmInUseCount += InUseTally;
+gOmInUseCount += inUseTally;
 }
-Thread::muxRelease(&ListLock);
+Thread::muxRelease(&gListLock);
 TEVENT(omFlush);
 }
 // Fast path code shared by multiple functions
 ObjectMonitor* ObjectSynchronizer::inflate_helper(oop obj) {
 // impacts the performance of some applications (e.g., PointBase).
 // Broadly, we want to minimize the # of monitors in circulation.
 //
 // We have added a flag, MonitorInUseLists, which creates a list
 // of active monitors for each thread. deflate_idle_monitors()
-// only scans the per-thread inuse lists. omAlloc() puts all
+// only scans the per-thread in-use lists. omAlloc() puts all
 // assigned monitors on the per-thread list. deflate_idle_monitors()
 // returns the non-busy monitors to the global free list.
 // When a thread dies, omFlush() adds the list of active monitors for
 // that thread to a global gOmInUseList acquiring the
 // global list lock. deflate_idle_monitors() acquires the global
 // list lock to scan for non-busy monitors to the global free list.
-// An alternative could have used a single global inuse list. The
+// An alternative could have used a single global in-use list. The
 // downside would have been the additional cost of acquiring the global list lock
 // for every omAlloc().
 //
 // Perversely, the heap size -- and thus the STW safepoint rate --
 // typically drives the scavenge rate.  Large heaps can mean infrequent GC,
 enum ManifestConstants {
 ClearResponsibleAtSTW   = 0,
 MaximumRecheckInterval  = 1000
 };
-// Deflate a single monitor if not in use
+// Deflate a single monitor if not in-use
-// Return true if deflated, false if in use
+// Return true if deflated, false if in-use
 bool ObjectSynchronizer::deflate_monitor(ObjectMonitor* mid, oop obj,
 ObjectMonitor** freeHeadp,
 ObjectMonitor** freeTailp) {
 bool deflated;
 // Normal case ... The monitor is associated with obj.
 obj->release_set_mark(mid->header());
 mid->clear();
 assert(mid->object() == NULL, "invariant");
-// Move the object to the working free list defined by FreeHead,FreeTail.
+// Move the object to the working free list defined by freeHeadp, freeTailp
 if (*freeHeadp == NULL) *freeHeadp = mid;
 if (*freeTailp != NULL) {
 ObjectMonitor * prevtail = *freeTailp;
-assert(prevtail->FreeNext == NULL, "cleaned up deflated?"); // TODO KK
+assert(prevtail->FreeNext == NULL, "cleaned up deflated?");
 prevtail->FreeNext = mid;
 }
 *freeTailp = mid;
 deflated = true;
 }
 return deflated;
 }
-// Caller acquires ListLock
+// Walk a given monitor list, and deflate idle monitors
-int ObjectSynchronizer::walk_monitor_list(ObjectMonitor** listheadp,
+// The given list could be a per-thread list or a global list
-ObjectMonitor** freeHeadp,
+// Caller acquires gListLock
-ObjectMonitor** freeTailp) {
+int ObjectSynchronizer::deflate_monitor_list(ObjectMonitor** listHeadp,
+ObjectMonitor** freeHeadp,
+ObjectMonitor** freeTailp) {
 ObjectMonitor* mid;
 ObjectMonitor* next;
-ObjectMonitor* curmidinuse = NULL;
+ObjectMonitor* cur_mid_in_use = NULL;
-int deflatedcount = 0;
+int deflated_count = 0;
-for (mid = *listheadp; mid != NULL;) {
+for (mid = *listHeadp; mid != NULL;) {
 oop obj = (oop) mid->object();
-bool deflated = false;
+if (obj != NULL && deflate_monitor(mid, obj, freeHeadp, freeTailp)) {
-if (obj != NULL) {
+// if deflate_monitor succeeded,
-deflated = deflate_monitor(mid, obj, freeHeadp, freeTailp);
+// extract from per-thread in-use list
-}
+if (mid == *listHeadp) {
-if (deflated) {
+*listHeadp = mid->FreeNext;
-// extract from per-thread in-use-list
+} else if (cur_mid_in_use != NULL) {
-if (mid == *listheadp) {
+cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
-*listheadp = mid->FreeNext;
-} else if (curmidinuse != NULL) {
-curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist
 }
 next = mid->FreeNext;
-mid->FreeNext = NULL;  // This mid is current tail in the FreeHead list
+mid->FreeNext = NULL;  // This mid is current tail in the freeHeadp list
 mid = next;
-deflatedcount++;
+deflated_count++;
 } else {
-curmidinuse = mid;
+cur_mid_in_use = mid;
 mid = mid->FreeNext;
 }
 }
-return deflatedcount;
+return deflated_count;
 }
 void ObjectSynchronizer::deflate_idle_monitors() {
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 int nInuse = 0;              // currently associated with objects
 int nInCirculation = 0;      // extant
 int nScavenged = 0;          // reclaimed
 bool deflated = false;
-ObjectMonitor * FreeHead = NULL;  // Local SLL of scavenged monitors
+ObjectMonitor * freeHeadp = NULL;  // Local SLL of scavenged monitors
-ObjectMonitor * FreeTail = NULL;
+ObjectMonitor * freeTailp = NULL;
 TEVENT(deflate_idle_monitors);
 // Prevent omFlush from changing mids in Thread dtor's during deflation
 // And in case the vm thread is acquiring a lock during a safepoint
 // See e.g. 6320749
-Thread::muxAcquire(&ListLock, "scavenge - return");
+Thread::muxAcquire(&gListLock, "scavenge - return");
 if (MonitorInUseLists) {
 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);
+int deflated_count = deflate_monitor_list(cur->omInUseList_addr(), &freeHeadp, &freeTailp);
-cur->omInUseCount-= deflatedcount;
+cur->omInUseCount-= deflated_count;
 if (ObjectMonitor::Knob_VerifyInUse) {
 verifyInUse(cur);
 }
-nScavenged += deflatedcount;
+nScavenged += deflated_count;
 nInuse += cur->omInUseCount;
 }
 // For moribund threads, scan gOmInUseList
 if (gOmInUseList) {
 nInCirculation += gOmInUseCount;
-int deflatedcount = walk_monitor_list((ObjectMonitor **)&gOmInUseList, &FreeHead, &FreeTail);
+int deflated_count = deflate_monitor_list((ObjectMonitor **)&gOmInUseList, &freeHeadp, &freeTailp);
-gOmInUseCount-= deflatedcount;
+gOmInUseCount-= deflated_count;
-nScavenged += deflatedcount;
+nScavenged += deflated_count;
 nInuse += gOmInUseCount;
 }
 } else for (PaddedEnd<ObjectMonitor> * block =
 (PaddedEnd<ObjectMonitor> *)gBlockList; block != NULL;
 // free list or the global free list.
 // obj == NULL IMPLIES mid->is_busy() == 0
 guarantee(!mid->is_busy(), "invariant");
 continue;
 }
-deflated = deflate_monitor(mid, obj, &FreeHead, &FreeTail);
+deflated = deflate_monitor(mid, obj, &freeHeadp, &freeTailp);
 if (deflated) {
 mid->FreeNext = NULL;
 nScavenged++;
 } else {
 nInuse++;
 }
 }
 }
-MonitorFreeCount += nScavenged;
+gMonitorFreeCount += nScavenged;
-// Consider: audit gFreeList to ensure that MonitorFreeCount and list agree.
+// Consider: audit gFreeList to ensure that gMonitorFreeCount and list agree.
 if (ObjectMonitor::Knob_Verbose) {
 ::printf("Deflate: InCirc=%d InUse=%d Scavenged=%d ForceMonitorScavenge=%d : pop=%d free=%d\n",
 nInCirculation, nInuse, nScavenged, ForceMonitorScavenge,
-MonitorPopulation, MonitorFreeCount);
+gMonitorPopulation, gMonitorFreeCount);
 ::fflush(stdout);
 }
 ForceMonitorScavenge = 0;    // Reset
 // Move the scavenged monitors back to the global free list.
-if (FreeHead != NULL) {
+if (freeHeadp != NULL) {
-guarantee(FreeTail != NULL && nScavenged > 0, "invariant");
+guarantee(freeTailp != NULL && nScavenged > 0, "invariant");
-assert(FreeTail->FreeNext == NULL, "invariant");
+assert(freeTailp->FreeNext == NULL, "invariant");
 // constant-time list splice - prepend scavenged segment to gFreeList
-FreeTail->FreeNext = gFreeList;
+freeTailp->FreeNext = gFreeList;
-gFreeList = FreeHead;
+gFreeList = freeHeadp;
 }
-Thread::muxRelease(&ListLock);
+Thread::muxRelease(&gListLock);
 if (ObjectMonitor::_sync_Deflations != NULL) ObjectMonitor::_sync_Deflations->inc(nScavenged);
 if (ObjectMonitor::_sync_MonExtant  != NULL) ObjectMonitor::_sync_MonExtant ->set_value(nInCirculation);
 // TODO: Add objectMonitor leak detection.
 void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) {
 assert(THREAD == JavaThread::current(), "must be current Java thread");
 No_Safepoint_Verifier nsv;
 ReleaseJavaMonitorsClosure rjmc(THREAD);
-Thread::muxAcquire(&ListLock, "release_monitors_owned_by_thread");
+Thread::muxAcquire(&gListLock, "release_monitors_owned_by_thread");
 ObjectSynchronizer::monitors_iterate(&rjmc);
-Thread::muxRelease(&ListLock);
+Thread::muxRelease(&gListLock);
 THREAD->clear_pending_exception();
 }
 //------------------------------------------------------------------------------
 // Debugging code

changeset 30244	d4e471395ff5
parent 29070	b0a5fc9c59c8
child 31345	1bba15125d8d