1669 if (mid == *listHeadp) {
1670 *listHeadp = mid->FreeNext;
1671 } else if (cur_mid_in_use != NULL) {
1672 cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
1673 }
1674 next = mid->FreeNext;
1675 mid->FreeNext = NULL; // This mid is current tail in the freeHeadp list
1676 mid = next;
1677 deflated_count++;
1678 } else {
1679 if (obj != NULL && cl != NULL) {
1680 cl->do_oop((oop*) mid->object_addr());
1681 }
1682 cur_mid_in_use = mid;
1683 mid = mid->FreeNext;
1684 }
1685 }
1686 return deflated_count;
1687 }
1688
1689 void ObjectSynchronizer::deflate_idle_monitors() {
1690 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
1691 int nInuse = 0; // currently associated with objects
1692 int nInCirculation = 0; // extant
1693 int nScavenged = 0; // reclaimed
1694 bool deflated = false;
1695
1696 ObjectMonitor * freeHeadp = NULL; // Local SLL of scavenged monitors
1697 ObjectMonitor * freeTailp = NULL;
1698
1699 TEVENT(deflate_idle_monitors);
1700 if (MonitorInUseLists) {
1701 if (! Universe::heap()->supports_per_thread_monitor_deflation() ||
1702 ForceMonitorScavenge == 1) {
1703 Universe::heap()->deflate_idle_monitors_all_threads();
1704 }
1705 }
1706
1707 // Prevent omFlush from changing mids in Thread dtor's during deflation
1708 // And in case the vm thread is acquiring a lock during a safepoint
1709 // See e.g. 6320749
1710 Thread::muxAcquire(&gListLock, "scavenge - return");
1711
1712 if (MonitorInUseLists) {
1713 // For moribund threads, scan gOmInUseList
1714 if (gOmInUseList) {
1715 nInCirculation += gOmInUseCount;
1716 int deflated_count = deflate_monitor_list((ObjectMonitor **)&gOmInUseList, &freeHeadp, &freeTailp);
1717 gOmInUseCount-= deflated_count;
1718 nScavenged += deflated_count;
1719 nInuse += gOmInUseCount;
1720 }
1721
1722 } else {
1723 PaddedEnd<ObjectMonitor> * block =
1724 (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
1725 for (; block != NULL; block = (PaddedEnd<ObjectMonitor> *)next(block)) {
1726 // Iterate over all extant monitors - Scavenge all idle monitors.
1727 assert(block->object() == CHAINMARKER, "must be a block header");
1728 nInCirculation += _BLOCKSIZE;
1729 for (int i = 1; i < _BLOCKSIZE; i++) {
1730 ObjectMonitor* mid = (ObjectMonitor*)&block[i];
1731 oop obj = (oop)mid->object();
1732
1769 guarantee(freeTailp != NULL && nScavenged > 0, "invariant");
1770 assert(freeTailp->FreeNext == NULL, "invariant");
1771 // constant-time list splice - prepend scavenged segment to gFreeList
1772 freeTailp->FreeNext = gFreeList;
1773 gFreeList = freeHeadp;
1774 }
1775 Thread::muxRelease(&gListLock);
1776
1777 OM_PERFDATA_OP(Deflations, inc(nScavenged));
1778 OM_PERFDATA_OP(MonExtant, set_value(nInCirculation));
1779
1780 // TODO: Add objectMonitor leak detection.
1781 // Audit/inventory the objectMonitors -- make sure they're all accounted for.
1782 GVars.stwRandom = os::random();
1783 GVars.stwCycle++;
1784 }
1785
1786 void ObjectSynchronizer::deflate_idle_monitors_and_oops_do(Thread* thread, OopClosure* cl) {
1787 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
1788 if (! MonitorInUseLists) return;
1789 if (ForceMonitorScavenge == 1) return;
1790 assert(Universe::heap()->supports_per_thread_monitor_deflation(), "only call this when supported by GC");
1791
1792 ObjectMonitor * freeHeadp = NULL; // Local SLL of scavenged monitors
1793 ObjectMonitor * freeTailp = NULL;
1794
1795 int deflated_count = deflate_monitor_list(thread->omInUseList_addr(), &freeHeadp, &freeTailp, cl);
1796 thread->omInUseCount-= deflated_count;
1797 if (ObjectMonitor::Knob_VerifyInUse) {
1798 verifyInUse(thread);
1799 }
1800
1801 // Move the scavenged monitors back to the global free list.
1802 if (freeHeadp != NULL) {
1803 Thread::muxAcquire(&gListLock, "scavenge - return");
1804 guarantee(freeTailp != NULL && deflated_count > 0, "invariant");
1805 assert(freeTailp->FreeNext == NULL, "invariant");
1806
1807 gMonitorFreeCount += deflated_count;
1808 // constant-time list splice - prepend scavenged segment to gFreeList
1809 freeTailp->FreeNext = gFreeList;
1810 gFreeList = freeHeadp;
|
1669 if (mid == *listHeadp) {
1670 *listHeadp = mid->FreeNext;
1671 } else if (cur_mid_in_use != NULL) {
1672 cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
1673 }
1674 next = mid->FreeNext;
1675 mid->FreeNext = NULL; // This mid is current tail in the freeHeadp list
1676 mid = next;
1677 deflated_count++;
1678 } else {
1679 if (obj != NULL && cl != NULL) {
1680 cl->do_oop((oop*) mid->object_addr());
1681 }
1682 cur_mid_in_use = mid;
1683 mid = mid->FreeNext;
1684 }
1685 }
1686 return deflated_count;
1687 }
1688
1689 void ObjectSynchronizer::deflate_idle_monitors(bool deflate_tl) {
1690 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
1691 int nInuse = 0; // currently associated with objects
1692 int nInCirculation = 0; // extant
1693 int nScavenged = 0; // reclaimed
1694 bool deflated = false;
1695
1696 ObjectMonitor * freeHeadp = NULL; // Local SLL of scavenged monitors
1697 ObjectMonitor * freeTailp = NULL;
1698
1699 TEVENT(deflate_idle_monitors);
1700 // Prevent omFlush from changing mids in Thread dtor's during deflation
1701 // And in case the vm thread is acquiring a lock during a safepoint
1702 // See e.g. 6320749
1703 Thread::muxAcquire(&gListLock, "scavenge - return");
1704
1705 if (MonitorInUseLists) {
1706 if (deflate_tl) {
1707 for (JavaThread* cur = Threads::first(); cur != NULL; cur = cur->next()) {
1708 nInCirculation+= cur->omInUseCount;
1709 int deflated_count = deflate_monitor_list(cur->omInUseList_addr(), &freeHeadp, &freeTailp);
1710 cur->omInUseCount-= deflated_count;
1711 if (ObjectMonitor::Knob_VerifyInUse) {
1712 verifyInUse(cur);
1713 }
1714 nScavenged += deflated_count;
1715 nInuse += cur->omInUseCount;
1716 }
1717 }
1718
1719 // For moribund threads, scan gOmInUseList
1720 if (gOmInUseList) {
1721 nInCirculation += gOmInUseCount;
1722 int deflated_count = deflate_monitor_list((ObjectMonitor **)&gOmInUseList, &freeHeadp, &freeTailp);
1723 gOmInUseCount-= deflated_count;
1724 nScavenged += deflated_count;
1725 nInuse += gOmInUseCount;
1726 }
1727
1728 } else {
1729 PaddedEnd<ObjectMonitor> * block =
1730 (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
1731 for (; block != NULL; block = (PaddedEnd<ObjectMonitor> *)next(block)) {
1732 // Iterate over all extant monitors - Scavenge all idle monitors.
1733 assert(block->object() == CHAINMARKER, "must be a block header");
1734 nInCirculation += _BLOCKSIZE;
1735 for (int i = 1; i < _BLOCKSIZE; i++) {
1736 ObjectMonitor* mid = (ObjectMonitor*)&block[i];
1737 oop obj = (oop)mid->object();
1738
1775 guarantee(freeTailp != NULL && nScavenged > 0, "invariant");
1776 assert(freeTailp->FreeNext == NULL, "invariant");
1777 // constant-time list splice - prepend scavenged segment to gFreeList
1778 freeTailp->FreeNext = gFreeList;
1779 gFreeList = freeHeadp;
1780 }
1781 Thread::muxRelease(&gListLock);
1782
1783 OM_PERFDATA_OP(Deflations, inc(nScavenged));
1784 OM_PERFDATA_OP(MonExtant, set_value(nInCirculation));
1785
1786 // TODO: Add objectMonitor leak detection.
1787 // Audit/inventory the objectMonitors -- make sure they're all accounted for.
1788 GVars.stwRandom = os::random();
1789 GVars.stwCycle++;
1790 }
1791
1792 void ObjectSynchronizer::deflate_idle_monitors_and_oops_do(Thread* thread, OopClosure* cl) {
1793 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
1794 if (! MonitorInUseLists) return;
1795
1796 ObjectMonitor * freeHeadp = NULL; // Local SLL of scavenged monitors
1797 ObjectMonitor * freeTailp = NULL;
1798
1799 int deflated_count = deflate_monitor_list(thread->omInUseList_addr(), &freeHeadp, &freeTailp, cl);
1800 thread->omInUseCount-= deflated_count;
1801 if (ObjectMonitor::Knob_VerifyInUse) {
1802 verifyInUse(thread);
1803 }
1804
1805 // Move the scavenged monitors back to the global free list.
1806 if (freeHeadp != NULL) {
1807 Thread::muxAcquire(&gListLock, "scavenge - return");
1808 guarantee(freeTailp != NULL && deflated_count > 0, "invariant");
1809 assert(freeTailp->FreeNext == NULL, "invariant");
1810
1811 gMonitorFreeCount += deflated_count;
1812 // constant-time list splice - prepend scavenged segment to gFreeList
1813 freeTailp->FreeNext = gFreeList;
1814 gFreeList = freeHeadp;
|