Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @ 3746:537a4053b0f9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557 Summary: Do a one-step look-ahead, when sweeping free or garbage blocks, to avoid overstepping sweep limit, which may become a non-block-boundary because of a heap expansion delta coalescing with a previously co-terminal free block. Reviewed-by: brutisso, tonyp
author ysr
date Mon, 23 May 2011 16:42:14 -0700
parents 78542e2b5e35
children 41e6ee74f879
comparison
equal deleted inserted replaced
3397:cfbca4d74a61 3746:537a4053b0f9
1699 // _freeFinger is the address of the current LHC 1699 // _freeFinger is the address of the current LHC
1700 class SweepClosure: public BlkClosureCareful { 1700 class SweepClosure: public BlkClosureCareful {
1701 CMSCollector* _collector; // collector doing the work 1701 CMSCollector* _collector; // collector doing the work
1702 ConcurrentMarkSweepGeneration* _g; // Generation being swept 1702 ConcurrentMarkSweepGeneration* _g; // Generation being swept
1703 CompactibleFreeListSpace* _sp; // Space being swept 1703 CompactibleFreeListSpace* _sp; // Space being swept
1704 HeapWord* _limit;// the address at which the sweep should stop because 1704 HeapWord* _limit;// the address at or above which the sweep should stop
1705 // we do not expect blocks eligible for sweeping past 1705 // because we do not expect newly garbage blocks
1706 // that address. 1706 // eligible for sweeping past that address.
1707 Mutex* _freelistLock; // Free list lock (in space) 1707 Mutex* _freelistLock; // Free list lock (in space)
1708 CMSBitMap* _bitMap; // Marking bit map (in 1708 CMSBitMap* _bitMap; // Marking bit map (in
1709 // generation) 1709 // generation)
1710 bool _inFreeRange; // Indicates if we are in the 1710 bool _inFreeRange; // Indicates if we are in the
1711 // midst of a free run 1711 // midst of a free run
1748 // Code that is common to a free chunk or garbage when 1748 // Code that is common to a free chunk or garbage when
1749 // encountered during sweeping. 1749 // encountered during sweeping.
1750 void do_post_free_or_garbage_chunk(FreeChunk *fc, size_t chunkSize); 1750 void do_post_free_or_garbage_chunk(FreeChunk *fc, size_t chunkSize);
1751 // Process a free chunk during sweeping. 1751 // Process a free chunk during sweeping.
1752 void do_already_free_chunk(FreeChunk *fc); 1752 void do_already_free_chunk(FreeChunk *fc);
1753 // Work method called when processing an already free or a
1754 // freshly garbage chunk to do a lookahead and possibly a
1755 // premptive flush if crossing over _limit.
1756 void lookahead_and_flush(FreeChunk* fc, size_t chunkSize);
1753 // Process a garbage chunk during sweeping. 1757 // Process a garbage chunk during sweeping.
1754 size_t do_garbage_chunk(FreeChunk *fc); 1758 size_t do_garbage_chunk(FreeChunk *fc);
1755 // Process a live chunk during sweeping. 1759 // Process a live chunk during sweeping.
1756 size_t do_live_chunk(FreeChunk* fc); 1760 size_t do_live_chunk(FreeChunk* fc);
1757 1761
1758 // Accessors. 1762 // Accessors.
1759 HeapWord* freeFinger() const { return _freeFinger; } 1763 HeapWord* freeFinger() const { return _freeFinger; }
1760 void set_freeFinger(HeapWord* v) { _freeFinger = v; } 1764 void set_freeFinger(HeapWord* v) { _freeFinger = v; }
1761 size_t freeRangeSize() const { return _freeRangeSize; }
1762 void set_freeRangeSize(size_t v) { _freeRangeSize = v; }
1763 bool inFreeRange() const { return _inFreeRange; } 1765 bool inFreeRange() const { return _inFreeRange; }
1764 void set_inFreeRange(bool v) { _inFreeRange = v; } 1766 void set_inFreeRange(bool v) { _inFreeRange = v; }
1765 bool lastFreeRangeCoalesced() const { return _lastFreeRangeCoalesced; } 1767 bool lastFreeRangeCoalesced() const { return _lastFreeRangeCoalesced; }
1766 void set_lastFreeRangeCoalesced(bool v) { _lastFreeRangeCoalesced = v; } 1768 void set_lastFreeRangeCoalesced(bool v) { _lastFreeRangeCoalesced = v; }
1767 bool freeRangeInFreeLists() const { return _freeRangeInFreeLists; } 1769 bool freeRangeInFreeLists() const { return _freeRangeInFreeLists; }
1777 1779
1778 // Yield 1780 // Yield
1779 void do_yield_work(HeapWord* addr); 1781 void do_yield_work(HeapWord* addr);
1780 1782
1781 // Debugging/Printing 1783 // Debugging/Printing
1782 void record_free_block_coalesced(FreeChunk* fc) const PRODUCT_RETURN; 1784 void print_free_block_coalesced(FreeChunk* fc) const;
1783 1785
1784 public: 1786 public:
1785 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g, 1787 SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g,
1786 CMSBitMap* bitMap, bool should_yield); 1788 CMSBitMap* bitMap, bool should_yield);
1787 ~SweepClosure(); 1789 ~SweepClosure() PRODUCT_RETURN;
1788 1790
1789 size_t do_blk_careful(HeapWord* addr); 1791 size_t do_blk_careful(HeapWord* addr);
1792 void print() const { print_on(tty); }
1793 void print_on(outputStream *st) const;
1790 }; 1794 };
1791 1795
1792 // Closures related to weak references processing 1796 // Closures related to weak references processing
1793 1797
1794 // During CMS' weak reference processing, this is a 1798 // During CMS' weak reference processing, this is a