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

equal deleted inserted replaced

-:874788e4c176
+:8fdbb85e62d3
 //    B.  After adding an objectmonitor to a free list.
 //
 ObjectMonitor * ObjectSynchronizer::gBlockList = NULL ;
 ObjectMonitor * volatile ObjectSynchronizer::gFreeList  = NULL ;
+ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList  = NULL ;
+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 int MonitorPopulation = 0 ;      // # Extant -- in circulation
 #define CHAINMARKER ((oop)-1)
 ::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 ++;
+}
+assert(inusetally == Self->omInUseCount, "inuse count off");
+int freetally = 0;
+for (mid = Self->omFreeList; mid != NULL; mid = mid->FreeNext) {
+freetally ++;
+}
+assert(freetally == Self->omFreeCount, "free count off");
+}
+*/
 ObjectMonitor * ATTR 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
 guarantee (m->object() == NULL, "invariant") ;
 if (MonitorInUseLists) {
 m->FreeNext = Self->omInUseList;
 Self->omInUseList = m;
 Self->omInUseCount ++;
+// verifyInUse(Self);
+} else {
+m->FreeNext = NULL;
 }
 return m ;
 }
 // 2: try to allocate from the global gFreeList
 ObjectMonitor * take = gFreeList ;
 gFreeList = take->FreeNext ;
 guarantee (take->object() == NULL, "invariant") ;
 guarantee (!take->is_busy(), "invariant") ;
 take->Recycle() ;
-omRelease (Self, take) ;
+omRelease (Self, take, false) ;
 }
 Thread::muxRelease (&ListLock) ;
 Self->omFreeProvision += 1 + (Self->omFreeProvision/2) ;
 if (Self->omFreeProvision > MAXPRIVATE ) Self->omFreeProvision = MAXPRIVATE ;
 TEVENT (omFirst - reprovision) ;
-continue ;
 const int mx = MonitorBound ;
 if (mx > 0 && (MonitorPopulation-MonitorFreeCount) > 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
 // accumulation we could  limit omCount to (omProvision*2), otherwise return
 // the objectMonitor to the global list.  We should drain (return) in reasonable chunks.
 // That is, *not* one-at-a-time.
-void ObjectSynchronizer::omRelease (Thread * Self, ObjectMonitor * m) {
+void ObjectSynchronizer::omRelease (Thread * Self, ObjectMonitor * m, bool fromPerThreadAlloc) {
 guarantee (m->object() == NULL, "invariant") ;
-m->FreeNext = Self->omFreeList ;
-Self->omFreeList = m ;
+// Remove from omInUseList
-Self->omFreeCount ++ ;
+if (MonitorInUseLists && fromPerThreadAlloc) {
+ObjectMonitor* curmidinuse = NULL;
+for (ObjectMonitor* mid = Self->omInUseList; mid != NULL; ) {
+if (m == mid) {
+// extract from per-thread in-use-list
+if (mid == Self->omInUseList) {
+Self->omInUseList = mid->FreeNext;
+} else if (curmidinuse != NULL) {
+curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist
+}
+Self->omInUseCount --;
+// verifyInUse(Self);
+break;
+} else {
+curmidinuse = mid;
+mid = mid->FreeNext;
+}
+}
+}
+// FreeNext is used for both onInUseList and omFreeList, so clear old before setting new
+m->FreeNext = Self->omFreeList ;
+Self->omFreeList = m ;
+Self->omFreeCount ++ ;
 }
 // Return the monitors of a moribund thread's local free list to
 // the global free list.  Typically a thread calls omFlush() when
 // 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
+// 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.
 // That means that omFlush() can run concurrently with a safepoint and
 // the scavenge operator.  Calling omFlush() from JavaThread::exit() might
 // operator.
 void ObjectSynchronizer::omFlush (Thread * Self) {
 ObjectMonitor * List = Self->omFreeList ;  // Null-terminated SLL
 Self->omFreeList = NULL ;
-if (List == NULL) return ;
 ObjectMonitor * Tail = NULL ;
-ObjectMonitor * s ;
 int Tally = 0;
-for (s = List ; s != NULL ; s = s->FreeNext) {
+if (List != NULL) {
-Tally ++ ;
+ObjectMonitor * s ;
-Tail = s ;
+for (s = List ; s != NULL ; s = s->FreeNext) {
-guarantee (s->object() == NULL, "invariant") ;
+Tally ++ ;
-guarantee (!s->is_busy(), "invariant") ;
+Tail = s ;
-s->set_owner (NULL) ;   // redundant but good hygiene
+guarantee (s->object() == NULL, "invariant") ;
-TEVENT (omFlush - Move one) ;
+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 * InUseTail = NULL ;
+int InUseTally = 0;
+if (InUseList != NULL) {
+Self->omInUseList = NULL;
+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");
+}
 Thread::muxAcquire (&ListLock, "omFlush") ;
-Tail->FreeNext = gFreeList ;
+if (Tail != NULL) {
-gFreeList = List ;
+Tail->FreeNext = gFreeList ;
-MonitorFreeCount += Tally;
+gFreeList = List ;
+MonitorFreeCount += Tally;
+}
+if (InUseTail != NULL) {
+InUseTail->FreeNext = gOmInUseList;
+gOmInUseList = InUseList;
+gOmInUseCount += InUseTally;
+}
 Thread::muxRelease (&ListLock) ;
 TEVENT (omFlush) ;
 }
 ObjectMonitor * m = omAlloc (Self) ;
 // Optimistically prepare the objectmonitor - anticipate successful CAS
 // We do this before the CAS in order to minimize the length of time
 // in which INFLATING appears in the mark.
 m->Recycle();
-m->FreeNext      = NULL ;
 m->_Responsible  = NULL ;
 m->OwnerIsThread = 0 ;
 m->_recursions   = 0 ;
 m->_SpinDuration = Knob_SpinLimit ;   // Consider: maintain by type/class
 markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
 if (cmp != mark) {
-omRelease (Self, m) ;
+omRelease (Self, m, true) ;
 continue ;       // Interference -- just retry
 }
 // We've successfully installed INFLATING (0) into the mark-word.
 // This is the only case where 0 will appear in a mark-work.
 m->set_header(mark);
 m->set_owner(NULL);
 m->set_object(object);
 m->OwnerIsThread = 1 ;
 m->_recursions   = 0 ;
-m->FreeNext      = NULL ;
 m->_Responsible  = NULL ;
 m->_SpinDuration = Knob_SpinLimit ;       // consider: keep metastats by type/class
 if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
 m->set_object (NULL) ;
 m->set_owner  (NULL) ;
 m->OwnerIsThread = 0 ;
 m->Recycle() ;
-omRelease (Self, m) ;
+omRelease (Self, m, true) ;
 m = NULL ;
 continue ;
 // interference - the markword changed - just retry.
 // The state-transitions are one-way, so there's no chance of
 // live-lock -- "Inflated" is an absorbing state.
 // 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
 // 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
 // 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 --
 // Move the object to the working free list defined by FreeHead,FreeTail.
 if (*FreeHeadp == NULL) *FreeHeadp = mid;
 if (*FreeTailp != NULL) {
 ObjectMonitor * prevtail = *FreeTailp;
+assert(prevtail->FreeNext == NULL, "cleaned up deflated?"); // TODO KK
 prevtail->FreeNext = mid;
 }
 *FreeTailp = mid;
 deflated = true;
 }
 return deflated;
+}
+// Caller acquires ListLock
+int ObjectSynchronizer::walk_monitor_list(ObjectMonitor** listheadp,
+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);
+}
+if (deflated) {
+// extract from per-thread in-use-list
+if (mid == *listheadp) {
+*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 = next;
+deflatedcount++;
+} else {
+curmidinuse = mid;
+mid = mid->FreeNext;
+}
+}
+return deflatedcount;
 }
 void ObjectSynchronizer::deflate_idle_monitors() {
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 int nInuse = 0 ;              // currently associated with objects
 // And in case the vm thread is acquiring a lock during a safepoint
 // See e.g. 6320749
 Thread::muxAcquire (&ListLock, "scavenge - return") ;
 if (MonitorInUseLists) {
-ObjectMonitor* mid;
+int inUse = 0;
-ObjectMonitor* next;
-ObjectMonitor* curmidinuse;
 for (JavaThread* cur = Threads::first(); cur != NULL; cur = cur->next()) {
-curmidinuse = NULL;
+nInCirculation+= cur->omInUseCount;
-for (mid = cur->omInUseList; mid != NULL; ) {
+int deflatedcount = walk_monitor_list(cur->omInUseList_addr(), &FreeHead, &FreeTail);
-oop obj = (oop) mid->object();
+cur->omInUseCount-= deflatedcount;
-deflated = false;
+// verifyInUse(cur);
-if (obj != NULL) {
+nScavenged += deflatedcount;
-deflated = deflate_monitor(mid, obj, &FreeHead, &FreeTail);
+nInuse += cur->omInUseCount;
-}
-if (deflated) {
-// extract from per-thread in-use-list
-if (mid == cur->omInUseList) {
-cur->omInUseList = 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 = next;
-cur->omInUseCount--;
-nScavenged ++ ;
-} else {
-curmidinuse = mid;
-mid = mid->FreeNext;
-nInuse ++;
-}
 }
-}
+// For moribund threads, scan gOmInUseList
+if (gOmInUseList) {
+nInCirculation += gOmInUseCount;
+int deflatedcount = walk_monitor_list((ObjectMonitor **)&gOmInUseList, &FreeHead, &FreeTail);
+gOmInUseCount-= deflatedcount;
+nScavenged += deflatedcount;
+nInuse += gOmInUseCount;
+}
 } else for (ObjectMonitor* block = gBlockList; block != NULL; block = next(block)) {
 // Iterate over all extant monitors - Scavenge all idle monitors.
 assert(block->object() == CHAINMARKER, "must be a block header");
 nInCirculation += _BLOCKSIZE ;
 for (int i = 1 ; i < _BLOCKSIZE; i++) {

changeset 5920	8fdbb85e62d3
parent 5712	7e82752d3fdf
child 6975	dc9b63952682