--- a/hotspot/src/share/vm/gc/g1/concurrentMark.cpp Wed Nov 25 00:47:35 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/concurrentMark.cpp Wed Nov 25 04:51:32 2015 +0000
@@ -74,9 +74,7 @@
addr = (HeapWord*)align_size_up((intptr_t)addr,
HeapWordSize << _shifter);
size_t addrOffset = heapWordToOffset(addr);
- if (limit == NULL) {
- limit = _bmStartWord + _bmWordSize;
- }
+ assert(limit != NULL, "limit must not be NULL");
size_t limitOffset = heapWordToOffset(limit);
size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);
HeapWord* nextAddr = offsetToHeapWord(nextOffset);
@@ -86,26 +84,6 @@
return nextAddr;
}
-HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(const HeapWord* addr,
- const HeapWord* limit) const {
- size_t addrOffset = heapWordToOffset(addr);
- if (limit == NULL) {
- limit = _bmStartWord + _bmWordSize;
- }
- size_t limitOffset = heapWordToOffset(limit);
- size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);
- HeapWord* nextAddr = offsetToHeapWord(nextOffset);
- assert(nextAddr >= addr, "get_next_one postcondition");
- assert(nextAddr == limit || !isMarked(nextAddr),
- "get_next_one postcondition");
- return nextAddr;
-}
-
-int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {
- assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
- return (int) (diff >> _shifter);
-}
-
#ifndef PRODUCT
bool CMBitMapRO::covers(MemRegion heap_rs) const {
// assert(_bm.map() == _virtual_space.low(), "map inconsistency");
@@ -211,17 +189,6 @@
return;
}
-void CMBitMap::markRange(MemRegion mr) {
- mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
- assert(!mr.is_empty(), "unexpected empty region");
- assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==
- ((HeapWord *) mr.end())),
- "markRange memory region end is not card aligned");
- // convert address range into offset range
- _bm.at_put_range(heapWordToOffset(mr.start()),
- heapWordToOffset(mr.end()), true);
-}
-
void CMBitMap::clearRange(MemRegion mr) {
mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
assert(!mr.is_empty(), "unexpected empty region");
@@ -230,20 +197,6 @@
heapWordToOffset(mr.end()), false);
}
-MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,
- HeapWord* end_addr) {
- HeapWord* start = getNextMarkedWordAddress(addr);
- start = MIN2(start, end_addr);
- HeapWord* end = getNextUnmarkedWordAddress(start);
- end = MIN2(end, end_addr);
- assert(start <= end, "Consistency check");
- MemRegion mr(start, end);
- if (!mr.is_empty()) {
- clearRange(mr);
- }
- return mr;
-}
-
CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
_base(NULL), _cm(cm)
{}
@@ -466,8 +419,6 @@
_max_parallel_marking_threads(0),
_sleep_factor(0.0),
_marking_task_overhead(1.0),
- _cleanup_sleep_factor(0.0),
- _cleanup_task_overhead(1.0),
_cleanup_list("Cleanup List"),
_region_bm((BitMap::idx_t)(g1h->max_regions()), false /* in_resource_area*/),
_card_bm((g1h->reserved_region().byte_size() + CardTableModRefBS::card_size - 1) >>
@@ -568,22 +519,6 @@
_parallel_marking_threads = ConcGCThreads;
_max_parallel_marking_threads = _parallel_marking_threads;
- if (parallel_marking_threads() > 1) {
- _cleanup_task_overhead = 1.0;
- } else {
- _cleanup_task_overhead = marking_task_overhead();
- }
- _cleanup_sleep_factor =
- (1.0 - cleanup_task_overhead()) / cleanup_task_overhead();
-
-#if 0
- gclog_or_tty->print_cr("Marking Threads %d", parallel_marking_threads());
- gclog_or_tty->print_cr("CM Marking Task Overhead %1.4lf", marking_task_overhead());
- gclog_or_tty->print_cr("CM Sleep Factor %1.4lf", sleep_factor());
- gclog_or_tty->print_cr("CL Marking Task Overhead %1.4lf", cleanup_task_overhead());
- gclog_or_tty->print_cr("CL Sleep Factor %1.4lf", cleanup_sleep_factor());
-#endif
-
_parallel_workers = new WorkGang("G1 Marker",
_max_parallel_marking_threads, false, true);
if (_parallel_workers == NULL) {
@@ -840,14 +775,6 @@
void ConcurrentMark::checkpointRootsInitialPost() {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
- // If we force an overflow during remark, the remark operation will
- // actually abort and we'll restart concurrent marking. If we always
- // force an overflow during remark we'll never actually complete the
- // marking phase. So, we initialize this here, at the start of the
- // cycle, so that at the remaining overflow number will decrease at
- // every remark and we'll eventually not need to cause one.
- force_overflow_stw()->init();
-
// Start Concurrent Marking weak-reference discovery.
ReferenceProcessor* rp = g1h->ref_processor_cm();
// enable ("weak") refs discovery
@@ -920,7 +847,6 @@
// we exit this method to abort the pause and restart concurrent
// marking.
reset_marking_state(true /* clear_overflow */);
- force_overflow()->update();
if (G1Log::fine()) {
gclog_or_tty->gclog_stamp();
@@ -940,32 +866,6 @@
// at this point everything should be re-initialized and ready to go
}
-#ifndef PRODUCT
-void ForceOverflowSettings::init() {
- _num_remaining = G1ConcMarkForceOverflow;
- _force = false;
- update();
-}
-
-void ForceOverflowSettings::update() {
- if (_num_remaining > 0) {
- _num_remaining -= 1;
- _force = true;
- } else {
- _force = false;
- }
-}
-
-bool ForceOverflowSettings::should_force() {
- if (_force) {
- _force = false;
- return true;
- } else {
- return false;
- }
-}
-#endif // !PRODUCT
-
class CMConcurrentMarkingTask: public AbstractGangTask {
private:
ConcurrentMark* _cm;
@@ -1131,7 +1031,6 @@
// stop-the-world GC happens even as we mark in this generation.
_restart_for_overflow = false;
- force_overflow_conc()->init();
// _g1h has _n_par_threads
_parallel_marking_threads = calc_parallel_marking_threads();
@@ -2440,10 +2339,6 @@
((CMBitMap*)_prevMarkBitMap)->clearRange(mr);
}
-void ConcurrentMark::clearRangeNextBitmap(MemRegion mr) {
- _nextMarkBitMap->clearRange(mr);
-}
-
HeapRegion*
ConcurrentMark::claim_region(uint worker_id) {
// "checkpoint" the finger
@@ -3535,15 +3430,6 @@
}
}
- // If we are about to wrap up and go into termination, check if we
- // should raise the overflow flag.
- if (do_termination && !has_aborted()) {
- if (_cm->force_overflow()->should_force()) {
- _cm->set_has_overflown();
- regular_clock_call();
- }
- }
-
// We still haven't aborted. Now, let's try to get into the
// termination protocol.
if (do_termination && !has_aborted()) {
--- a/hotspot/src/share/vm/gc/g1/concurrentMark.hpp Wed Nov 25 00:47:35 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/concurrentMark.hpp Wed Nov 25 04:51:32 2015 +0000
@@ -65,11 +65,8 @@
// constructor
CMBitMapRO(int shifter);
- enum { do_yield = true };
-
// inquiries
HeapWord* startWord() const { return _bmStartWord; }
- size_t sizeInWords() const { return _bmWordSize; }
// the following is one past the last word in space
HeapWord* endWord() const { return _bmStartWord + _bmWordSize; }
@@ -83,18 +80,12 @@
// iteration
inline bool iterate(BitMapClosure* cl, MemRegion mr);
- inline bool iterate(BitMapClosure* cl);
// Return the address corresponding to the next marked bit at or after
// "addr", and before "limit", if "limit" is non-NULL. If there is no
// such bit, returns "limit" if that is non-NULL, or else "endWord()".
HeapWord* getNextMarkedWordAddress(const HeapWord* addr,
const HeapWord* limit = NULL) const;
- // Return the address corresponding to the next unmarked bit at or after
- // "addr", and before "limit", if "limit" is non-NULL. If there is no
- // such bit, returns "limit" if that is non-NULL, or else "endWord()".
- HeapWord* getNextUnmarkedWordAddress(const HeapWord* addr,
- const HeapWord* limit = NULL) const;
// conversion utilities
HeapWord* offsetToHeapWord(size_t offset) const {
@@ -103,7 +94,6 @@
size_t heapWordToOffset(const HeapWord* addr) const {
return pointer_delta(addr, _bmStartWord) >> _shifter;
}
- int heapWordDiffToOffsetDiff(size_t diff) const;
// The argument addr should be the start address of a valid object
HeapWord* nextObject(HeapWord* addr) {
@@ -153,20 +143,9 @@
inline void mark(HeapWord* addr);
inline void clear(HeapWord* addr);
inline bool parMark(HeapWord* addr);
- inline bool parClear(HeapWord* addr);
- void markRange(MemRegion mr);
void clearRange(MemRegion mr);
- // Starting at the bit corresponding to "addr" (inclusive), find the next
- // "1" bit, if any. This bit starts some run of consecutive "1"'s; find
- // the end of this run (stopping at "end_addr"). Return the MemRegion
- // covering from the start of the region corresponding to the first bit
- // of the run to the end of the region corresponding to the last bit of
- // the run. If there is no "1" bit at or after "addr", return an empty
- // MemRegion.
- MemRegion getAndClearMarkedRegion(HeapWord* addr, HeapWord* end_addr);
-
// Clear the whole mark bitmap.
void clearAll();
};
@@ -231,19 +210,6 @@
template<typename Fn> void iterate(Fn fn);
};
-class ForceOverflowSettings VALUE_OBJ_CLASS_SPEC {
-private:
-#ifndef PRODUCT
- uintx _num_remaining;
- bool _force;
-#endif // !defined(PRODUCT)
-
-public:
- void init() PRODUCT_RETURN;
- void update() PRODUCT_RETURN;
- bool should_force() PRODUCT_RETURN_( return false; );
-};
-
class YoungList;
// Root Regions are regions that are not empty at the beginning of a
@@ -326,10 +292,6 @@
double _marking_task_overhead; // Marking target overhead for
// a single task
- // Same as the two above, but for the cleanup task
- double _cleanup_sleep_factor;
- double _cleanup_task_overhead;
-
FreeRegionList _cleanup_list;
// Concurrent marking support structures
@@ -404,9 +366,6 @@
WorkGang* _parallel_workers;
- ForceOverflowSettings _force_overflow_conc;
- ForceOverflowSettings _force_overflow_stw;
-
void weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes);
void weakRefsWork(bool clear_all_soft_refs);
@@ -443,8 +402,6 @@
uint max_parallel_marking_threads() const { return _max_parallel_marking_threads;}
double sleep_factor() { return _sleep_factor; }
double marking_task_overhead() { return _marking_task_overhead;}
- double cleanup_sleep_factor() { return _cleanup_sleep_factor; }
- double cleanup_task_overhead() { return _cleanup_task_overhead;}
HeapWord* finger() { return _finger; }
bool concurrent() { return _concurrent; }
@@ -502,22 +459,6 @@
void enter_first_sync_barrier(uint worker_id);
void enter_second_sync_barrier(uint worker_id);
- ForceOverflowSettings* force_overflow_conc() {
- return &_force_overflow_conc;
- }
-
- ForceOverflowSettings* force_overflow_stw() {
- return &_force_overflow_stw;
- }
-
- ForceOverflowSettings* force_overflow() {
- if (concurrent()) {
- return force_overflow_conc();
- } else {
- return force_overflow_stw();
- }
- }
-
// Live Data Counting data structures...
// These data structures are initialized at the start of
// marking. They are written to while marking is active.
@@ -625,28 +566,6 @@
uint worker_id,
HeapRegion* hr = NULL);
- // It iterates over the heap and for each object it comes across it
- // will dump the contents of its reference fields, as well as
- // liveness information for the object and its referents. The dump
- // will be written to a file with the following name:
- // G1PrintReachableBaseFile + "." + str.
- // vo decides whether the prev (vo == UsePrevMarking), the next
- // (vo == UseNextMarking) marking information, or the mark word
- // (vo == UseMarkWord) will be used to determine the liveness of
- // each object / referent.
- // If all is true, all objects in the heap will be dumped, otherwise
- // only the live ones. In the dump the following symbols / breviations
- // are used:
- // M : an explicitly live object (its bitmap bit is set)
- // > : an implicitly live object (over tams)
- // O : an object outside the G1 heap (typically: in the perm gen)
- // NOT : a reference field whose referent is not live
- // AND MARKED : indicates that an object is both explicitly and
- // implicitly live (it should be one or the other, not both)
- void print_reachable(const char* str,
- VerifyOption vo,
- bool all) PRODUCT_RETURN;
-
// Clear the next marking bitmap (will be called concurrently).
void clearNextBitmap();
@@ -686,7 +605,6 @@
// next bitmaps. NB: the previous bitmap is usually
// read-only, so use this carefully!
void clearRangePrevBitmap(MemRegion mr);
- void clearRangeNextBitmap(MemRegion mr);
// Notify data structures that a GC has started.
void note_start_of_gc() {
--- a/hotspot/src/share/vm/gc/g1/concurrentMark.inline.hpp Wed Nov 25 00:47:35 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/concurrentMark.inline.hpp Wed Nov 25 04:51:32 2015 +0000
@@ -185,11 +185,6 @@
return true;
}
-inline bool CMBitMapRO::iterate(BitMapClosure* cl) {
- MemRegion mr(startWord(), sizeInWords());
- return iterate(cl, mr);
-}
-
#define check_mark(addr) \
assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \
"outside underlying space?"); \
@@ -213,11 +208,6 @@
return _bm.par_set_bit(heapWordToOffset(addr));
}
-inline bool CMBitMap::parClear(HeapWord* addr) {
- check_mark(addr);
- return _bm.par_clear_bit(heapWordToOffset(addr));
-}
-
#undef check_mark
template<typename Fn>