575 CardTableRS* _ct; // card table
576
577 // CMS marking support structures
578 CMSBitMap _markBitMap;
579 CMSBitMap _modUnionTable;
580 CMSMarkStack _markStack;
581 CMSMarkStack _revisitStack; // used to keep track of klassKlass objects
582 // to revisit
583 CMSBitMap _perm_gen_verify_bit_map; // Mark bit map for perm gen verification support.
584
585 HeapWord* _restart_addr; // in support of marking stack overflow
586 void lower_restart_addr(HeapWord* low);
587
588 // Counters in support of marking stack / work queue overflow handling:
589 // a non-zero value indicates certain types of overflow events during
590 // the current CMS cycle and could lead to stack resizing efforts at
591 // an opportune future time.
592 size_t _ser_pmc_preclean_ovflw;
593 size_t _ser_pmc_remark_ovflw;
594 size_t _par_pmc_remark_ovflw;
595 size_t _ser_kac_ovflw;
596 size_t _par_kac_ovflw;
597 NOT_PRODUCT(size_t _num_par_pushes;)
598
599 // ("Weak") Reference processing support
600 ReferenceProcessor* _ref_processor;
601 CMSIsAliveClosure _is_alive_closure;
602 // keep this textually after _markBitMap and _span; c'tor dependency
603
604 ConcurrentMarkSweepThread* _cmsThread; // the thread doing the work
605 ModUnionClosure _modUnionClosure;
606 ModUnionClosurePar _modUnionClosurePar;
607
608 // CMS abstract state machine
609 // initial_state: Idling
610 // next_state(Idling) = {Marking}
611 // next_state(Marking) = {Precleaning, Sweeping}
612 // next_state(Precleaning) = {AbortablePreclean, FinalMarking}
613 // next_state(AbortablePreclean) = {FinalMarking}
614 // next_state(FinalMarking) = {Sweeping}
1732 // Yield
1733 void do_yield_work(HeapWord* addr);
1734
1735 // Debugging/Printing
1736 void record_free_block_coalesced(FreeChunk* fc) const PRODUCT_RETURN;
1737
1738 public:
1739 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g,
1740 CMSBitMap* bitMap, bool should_yield);
1741 ~SweepClosure();
1742
1743 size_t do_blk_careful(HeapWord* addr);
1744 };
1745
1746 // Closures related to weak references processing
1747
1748 // During CMS' weak reference processing, this is a
1749 // work-routine/closure used to complete transitive
1750 // marking of objects as live after a certain point
1751 // in which an initial set has been completely accumulated.
1752 class CMSDrainMarkingStackClosure: public VoidClosure {
1753 CMSCollector* _collector;
1754 MemRegion _span;
1755 CMSMarkStack* _mark_stack;
1756 CMSBitMap* _bit_map;
1757 CMSKeepAliveClosure* _keep_alive;
1758 public:
1759 CMSDrainMarkingStackClosure(CMSCollector* collector, MemRegion span,
1760 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
1761 CMSKeepAliveClosure* keep_alive):
1762 _collector(collector),
1763 _span(span),
1764 _bit_map(bit_map),
1765 _mark_stack(mark_stack),
1766 _keep_alive(keep_alive) { }
1767
1768 void do_void();
1769 };
1770
1771 // A parallel version of CMSDrainMarkingStackClosure above.
1772 class CMSParDrainMarkingStackClosure: public VoidClosure {
1773 CMSCollector* _collector;
1774 MemRegion _span;
1775 OopTaskQueue* _work_queue;
1776 CMSBitMap* _bit_map;
1777 CMSInnerParMarkAndPushClosure _mark_and_push;
1778
1779 public:
1780 CMSParDrainMarkingStackClosure(CMSCollector* collector,
1781 MemRegion span, CMSBitMap* bit_map,
1782 OopTaskQueue* work_queue):
1783 _collector(collector),
1784 _span(span),
1785 _bit_map(bit_map),
1786 _work_queue(work_queue),
|
575 CardTableRS* _ct; // card table
576
577 // CMS marking support structures
578 CMSBitMap _markBitMap;
579 CMSBitMap _modUnionTable;
580 CMSMarkStack _markStack;
581 CMSMarkStack _revisitStack; // used to keep track of klassKlass objects
582 // to revisit
583 CMSBitMap _perm_gen_verify_bit_map; // Mark bit map for perm gen verification support.
584
585 HeapWord* _restart_addr; // in support of marking stack overflow
586 void lower_restart_addr(HeapWord* low);
587
588 // Counters in support of marking stack / work queue overflow handling:
589 // a non-zero value indicates certain types of overflow events during
590 // the current CMS cycle and could lead to stack resizing efforts at
591 // an opportune future time.
592 size_t _ser_pmc_preclean_ovflw;
593 size_t _ser_pmc_remark_ovflw;
594 size_t _par_pmc_remark_ovflw;
595 size_t _ser_kac_preclean_ovflw;
596 size_t _ser_kac_ovflw;
597 size_t _par_kac_ovflw;
598 NOT_PRODUCT(size_t _num_par_pushes;)
599
600 // ("Weak") Reference processing support
601 ReferenceProcessor* _ref_processor;
602 CMSIsAliveClosure _is_alive_closure;
603 // keep this textually after _markBitMap and _span; c'tor dependency
604
605 ConcurrentMarkSweepThread* _cmsThread; // the thread doing the work
606 ModUnionClosure _modUnionClosure;
607 ModUnionClosurePar _modUnionClosurePar;
608
609 // CMS abstract state machine
610 // initial_state: Idling
611 // next_state(Idling) = {Marking}
612 // next_state(Marking) = {Precleaning, Sweeping}
613 // next_state(Precleaning) = {AbortablePreclean, FinalMarking}
614 // next_state(AbortablePreclean) = {FinalMarking}
615 // next_state(FinalMarking) = {Sweeping}
1733 // Yield
1734 void do_yield_work(HeapWord* addr);
1735
1736 // Debugging/Printing
1737 void record_free_block_coalesced(FreeChunk* fc) const PRODUCT_RETURN;
1738
1739 public:
1740 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g,
1741 CMSBitMap* bitMap, bool should_yield);
1742 ~SweepClosure();
1743
1744 size_t do_blk_careful(HeapWord* addr);
1745 };
1746
1747 // Closures related to weak references processing
1748
1749 // During CMS' weak reference processing, this is a
1750 // work-routine/closure used to complete transitive
1751 // marking of objects as live after a certain point
1752 // in which an initial set has been completely accumulated.
1753 // This closure is currently used both during the final
1754 // remark stop-world phase, as well as during the concurrent
1755 // precleaning of the discovered reference lists.
1756 class CMSDrainMarkingStackClosure: public VoidClosure {
1757 CMSCollector* _collector;
1758 MemRegion _span;
1759 CMSMarkStack* _mark_stack;
1760 CMSBitMap* _bit_map;
1761 CMSKeepAliveClosure* _keep_alive;
1762 bool _concurrent_precleaning;
1763 public:
1764 CMSDrainMarkingStackClosure(CMSCollector* collector, MemRegion span,
1765 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
1766 CMSKeepAliveClosure* keep_alive,
1767 bool concurrent_precleaning):
1768 _collector(collector),
1769 _span(span),
1770 _bit_map(bit_map),
1771 _mark_stack(mark_stack),
1772 _keep_alive(keep_alive),
1773 _concurrent_precleaning(concurrent_precleaning) {
1774 assert(_concurrent_precleaning == _keep_alive->_concurrent_precleaning,
1775 "Mismatch");
1776 }
1777
1778 void do_void();
1779 };
1780
1781 // A parallel version of CMSDrainMarkingStackClosure above.
1782 class CMSParDrainMarkingStackClosure: public VoidClosure {
1783 CMSCollector* _collector;
1784 MemRegion _span;
1785 OopTaskQueue* _work_queue;
1786 CMSBitMap* _bit_map;
1787 CMSInnerParMarkAndPushClosure _mark_and_push;
1788
1789 public:
1790 CMSParDrainMarkingStackClosure(CMSCollector* collector,
1791 MemRegion span, CMSBitMap* bit_map,
1792 OopTaskQueue* work_queue):
1793 _collector(collector),
1794 _span(span),
1795 _bit_map(bit_map),
1796 _work_queue(work_queue),
|