656 walk_mem_region_with_cl_DECL(FilteringClosure);
657
658 public:
659 FreeListSpace_DCTOC(CompactibleFreeListSpace* sp,
660 CMSCollector* collector,
661 ExtendedOopClosure* cl,
662 CardTableModRefBS::PrecisionStyle precision,
663 HeapWord* boundary) :
664 Filtering_DCTOC(sp, cl, precision, boundary),
665 _cfls(sp), _collector(collector) {}
666 };
667
668 // We de-virtualize the block-related calls below, since we know that our
669 // space is a CompactibleFreeListSpace.
670
671 #define FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \
672 void FreeListSpace_DCTOC::walk_mem_region_with_cl(MemRegion mr, \
673 HeapWord* bottom, \
674 HeapWord* top, \
675 ClosureType* cl) { \
676 bool is_par = SharedHeap::heap()->n_par_threads() > 0; \
677 if (is_par) { \
678 assert(SharedHeap::heap()->n_par_threads() == \
679 SharedHeap::heap()->workers()->active_workers(), "Mismatch"); \
680 walk_mem_region_with_cl_par(mr, bottom, top, cl); \
681 } else { \
682 walk_mem_region_with_cl_nopar(mr, bottom, top, cl); \
683 } \
684 } \
685 void FreeListSpace_DCTOC::walk_mem_region_with_cl_par(MemRegion mr, \
686 HeapWord* bottom, \
687 HeapWord* top, \
688 ClosureType* cl) { \
689 /* Skip parts that are before "mr", in case "block_start" sent us \
690 back too far. */ \
691 HeapWord* mr_start = mr.start(); \
692 size_t bot_size = _cfls->CompactibleFreeListSpace::block_size(bottom); \
693 HeapWord* next = bottom + bot_size; \
694 while (next < mr_start) { \
695 bottom = next; \
696 bot_size = _cfls->CompactibleFreeListSpace::block_size(bottom); \
697 next = bottom + bot_size; \
698 } \
699 \
1890 size_t new_size) {
1891 assert_locked();
1892 size_t size = chunk->size();
1893 assert(size > new_size, "Split from a smaller block?");
1894 assert(is_aligned(chunk), "alignment problem");
1895 assert(size == adjustObjectSize(size), "alignment problem");
1896 size_t rem_sz = size - new_size;
1897 assert(rem_sz == adjustObjectSize(rem_sz), "alignment problem");
1898 assert(rem_sz >= MinChunkSize, "Free chunk smaller than minimum");
1899 FreeChunk* ffc = (FreeChunk*)((HeapWord*)chunk + new_size);
1900 assert(is_aligned(ffc), "alignment problem");
1901 ffc->set_size(rem_sz);
1902 ffc->link_next(NULL);
1903 ffc->link_prev(NULL); // Mark as a free block for other (parallel) GC threads.
1904 // Above must occur before BOT is updated below.
1905 // adjust block offset table
1906 OrderAccess::storestore();
1907 assert(chunk->is_free() && ffc->is_free(), "Error");
1908 _bt.split_block((HeapWord*)chunk, chunk->size(), new_size);
1909 if (rem_sz < SmallForDictionary) {
1910 bool is_par = (SharedHeap::heap()->n_par_threads() > 0);
1911 if (is_par) _indexedFreeListParLocks[rem_sz]->lock();
1912 assert(!is_par ||
1913 (SharedHeap::heap()->n_par_threads() ==
1914 SharedHeap::heap()->workers()->active_workers()), "Mismatch");
1915 returnChunkToFreeList(ffc);
1916 split(size, rem_sz);
1917 if (is_par) _indexedFreeListParLocks[rem_sz]->unlock();
1918 } else {
1919 returnChunkToDictionary(ffc);
1920 split(size, rem_sz);
1921 }
1922 chunk->set_size(new_size);
1923 return chunk;
1924 }
1925
1926 void
1927 CompactibleFreeListSpace::sweep_completed() {
1928 // Now that space is probably plentiful, refill linear
1929 // allocation blocks as needed.
1930 refillLinearAllocBlocksIfNeeded();
1931 }
1932
1933 void
1934 CompactibleFreeListSpace::gc_prologue() {
1965 // Mark the "end" of the used space at the time of this call;
1966 // note, however, that promoted objects from this point
1967 // on are tracked in the _promoInfo below.
1968 set_saved_mark_word(unallocated_block());
1969 #ifdef ASSERT
1970 // Check the sanity of save_marks() etc.
1971 MemRegion ur = used_region();
1972 MemRegion urasm = used_region_at_save_marks();
1973 assert(ur.contains(urasm),
1974 err_msg(" Error at save_marks(): [" PTR_FORMAT "," PTR_FORMAT ")"
1975 " should contain [" PTR_FORMAT "," PTR_FORMAT ")",
1976 p2i(ur.start()), p2i(ur.end()), p2i(urasm.start()), p2i(urasm.end())));
1977 #endif
1978 // inform allocator that promotions should be tracked.
1979 assert(_promoInfo.noPromotions(), "_promoInfo inconsistency");
1980 _promoInfo.startTrackingPromotions();
1981 }
1982
1983 bool CompactibleFreeListSpace::no_allocs_since_save_marks() {
1984 assert(_promoInfo.tracking(), "No preceding save_marks?");
1985 assert(SharedHeap::heap()->n_par_threads() == 0,
1986 "Shouldn't be called if using parallel gc.");
1987 return _promoInfo.noPromotions();
1988 }
1989
1990 #define CFLS_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
1991 \
1992 void CompactibleFreeListSpace:: \
1993 oop_since_save_marks_iterate##nv_suffix(OopClosureType* blk) { \
1994 assert(SharedHeap::heap()->n_par_threads() == 0, \
1995 "Shouldn't be called (yet) during parallel part of gc."); \
1996 _promoInfo.promoted_oops_iterate##nv_suffix(blk); \
1997 /* \
1998 * This also restores any displaced headers and removes the elements from \
1999 * the iteration set as they are processed, so that we have a clean slate \
2000 * at the end of the iteration. Note, thus, that if new objects are \
2001 * promoted as a result of the iteration they are iterated over as well. \
2002 */ \
2003 assert(_promoInfo.noPromotions(), "_promoInfo inconsistency"); \
2004 }
2005
2006 ALL_SINCE_SAVE_MARKS_CLOSURES(CFLS_OOP_SINCE_SAVE_MARKS_DEFN)
2007
2008 bool CompactibleFreeListSpace::linearAllocationWouldFail() const {
2009 return _smallLinearAllocBlock._word_size == 0;
2010 }
2011
2012 void CompactibleFreeListSpace::repairLinearAllocationBlocks() {
2013 // Fix up linear allocation blocks to look like free blocks
2014 repairLinearAllocBlock(&_smallLinearAllocBlock);
|
656 walk_mem_region_with_cl_DECL(FilteringClosure);
657
658 public:
659 FreeListSpace_DCTOC(CompactibleFreeListSpace* sp,
660 CMSCollector* collector,
661 ExtendedOopClosure* cl,
662 CardTableModRefBS::PrecisionStyle precision,
663 HeapWord* boundary) :
664 Filtering_DCTOC(sp, cl, precision, boundary),
665 _cfls(sp), _collector(collector) {}
666 };
667
668 // We de-virtualize the block-related calls below, since we know that our
669 // space is a CompactibleFreeListSpace.
670
671 #define FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \
672 void FreeListSpace_DCTOC::walk_mem_region_with_cl(MemRegion mr, \
673 HeapWord* bottom, \
674 HeapWord* top, \
675 ClosureType* cl) { \
676 bool is_par = GenCollectedHeap::heap()->n_par_threads() > 0; \
677 if (is_par) { \
678 assert(GenCollectedHeap::heap()->n_par_threads() == \
679 GenCollectedHeap::heap()->workers()->active_workers(), "Mismatch"); \
680 walk_mem_region_with_cl_par(mr, bottom, top, cl); \
681 } else { \
682 walk_mem_region_with_cl_nopar(mr, bottom, top, cl); \
683 } \
684 } \
685 void FreeListSpace_DCTOC::walk_mem_region_with_cl_par(MemRegion mr, \
686 HeapWord* bottom, \
687 HeapWord* top, \
688 ClosureType* cl) { \
689 /* Skip parts that are before "mr", in case "block_start" sent us \
690 back too far. */ \
691 HeapWord* mr_start = mr.start(); \
692 size_t bot_size = _cfls->CompactibleFreeListSpace::block_size(bottom); \
693 HeapWord* next = bottom + bot_size; \
694 while (next < mr_start) { \
695 bottom = next; \
696 bot_size = _cfls->CompactibleFreeListSpace::block_size(bottom); \
697 next = bottom + bot_size; \
698 } \
699 \
1890 size_t new_size) {
1891 assert_locked();
1892 size_t size = chunk->size();
1893 assert(size > new_size, "Split from a smaller block?");
1894 assert(is_aligned(chunk), "alignment problem");
1895 assert(size == adjustObjectSize(size), "alignment problem");
1896 size_t rem_sz = size - new_size;
1897 assert(rem_sz == adjustObjectSize(rem_sz), "alignment problem");
1898 assert(rem_sz >= MinChunkSize, "Free chunk smaller than minimum");
1899 FreeChunk* ffc = (FreeChunk*)((HeapWord*)chunk + new_size);
1900 assert(is_aligned(ffc), "alignment problem");
1901 ffc->set_size(rem_sz);
1902 ffc->link_next(NULL);
1903 ffc->link_prev(NULL); // Mark as a free block for other (parallel) GC threads.
1904 // Above must occur before BOT is updated below.
1905 // adjust block offset table
1906 OrderAccess::storestore();
1907 assert(chunk->is_free() && ffc->is_free(), "Error");
1908 _bt.split_block((HeapWord*)chunk, chunk->size(), new_size);
1909 if (rem_sz < SmallForDictionary) {
1910 bool is_par = (GenCollectedHeap::heap()->n_par_threads() > 0);
1911 if (is_par) _indexedFreeListParLocks[rem_sz]->lock();
1912 assert(!is_par ||
1913 (GenCollectedHeap::heap()->n_par_threads() ==
1914 GenCollectedHeap::heap()->workers()->active_workers()), "Mismatch");
1915 returnChunkToFreeList(ffc);
1916 split(size, rem_sz);
1917 if (is_par) _indexedFreeListParLocks[rem_sz]->unlock();
1918 } else {
1919 returnChunkToDictionary(ffc);
1920 split(size, rem_sz);
1921 }
1922 chunk->set_size(new_size);
1923 return chunk;
1924 }
1925
1926 void
1927 CompactibleFreeListSpace::sweep_completed() {
1928 // Now that space is probably plentiful, refill linear
1929 // allocation blocks as needed.
1930 refillLinearAllocBlocksIfNeeded();
1931 }
1932
1933 void
1934 CompactibleFreeListSpace::gc_prologue() {
1965 // Mark the "end" of the used space at the time of this call;
1966 // note, however, that promoted objects from this point
1967 // on are tracked in the _promoInfo below.
1968 set_saved_mark_word(unallocated_block());
1969 #ifdef ASSERT
1970 // Check the sanity of save_marks() etc.
1971 MemRegion ur = used_region();
1972 MemRegion urasm = used_region_at_save_marks();
1973 assert(ur.contains(urasm),
1974 err_msg(" Error at save_marks(): [" PTR_FORMAT "," PTR_FORMAT ")"
1975 " should contain [" PTR_FORMAT "," PTR_FORMAT ")",
1976 p2i(ur.start()), p2i(ur.end()), p2i(urasm.start()), p2i(urasm.end())));
1977 #endif
1978 // inform allocator that promotions should be tracked.
1979 assert(_promoInfo.noPromotions(), "_promoInfo inconsistency");
1980 _promoInfo.startTrackingPromotions();
1981 }
1982
1983 bool CompactibleFreeListSpace::no_allocs_since_save_marks() {
1984 assert(_promoInfo.tracking(), "No preceding save_marks?");
1985 assert(GenCollectedHeap::heap()->n_par_threads() == 0,
1986 "Shouldn't be called if using parallel gc.");
1987 return _promoInfo.noPromotions();
1988 }
1989
1990 #define CFLS_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
1991 \
1992 void CompactibleFreeListSpace:: \
1993 oop_since_save_marks_iterate##nv_suffix(OopClosureType* blk) { \
1994 assert(GenCollectedHeap::heap()->n_par_threads() == 0, \
1995 "Shouldn't be called (yet) during parallel part of gc."); \
1996 _promoInfo.promoted_oops_iterate##nv_suffix(blk); \
1997 /* \
1998 * This also restores any displaced headers and removes the elements from \
1999 * the iteration set as they are processed, so that we have a clean slate \
2000 * at the end of the iteration. Note, thus, that if new objects are \
2001 * promoted as a result of the iteration they are iterated over as well. \
2002 */ \
2003 assert(_promoInfo.noPromotions(), "_promoInfo inconsistency"); \
2004 }
2005
2006 ALL_SINCE_SAVE_MARKS_CLOSURES(CFLS_OOP_SINCE_SAVE_MARKS_DEFN)
2007
2008 bool CompactibleFreeListSpace::linearAllocationWouldFail() const {
2009 return _smallLinearAllocBlock._word_size == 0;
2010 }
2011
2012 void CompactibleFreeListSpace::repairLinearAllocationBlocks() {
2013 // Fix up linear allocation blocks to look like free blocks
2014 repairLinearAllocBlock(&_smallLinearAllocBlock);
|