--- a/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp Mon Feb 26 09:34:20 2018 +0100
+++ b/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp Mon Feb 26 09:34:12 2018 +0100
@@ -448,7 +448,7 @@
_start_sampling(false),
_between_prologue_and_epilogue(false),
_markBitMap(0, Mutex::leaf + 1, "CMS_markBitMap_lock"),
- _modUnionTable((CardTableModRefBS::card_shift - LogHeapWordSize),
+ _modUnionTable((CardTable::card_shift - LogHeapWordSize),
-1 /* lock-free */, "No_lock" /* dummy */),
_modUnionClosurePar(&_modUnionTable),
// Adjust my span to cover old (cms) gen
@@ -900,7 +900,7 @@
// card size.
MemRegion mr(start,
align_up(start + obj_size,
- CardTableModRefBS::card_size /* bytes */));
+ CardTable::card_size /* bytes */));
if (par) {
_modUnionTable.par_mark_range(mr);
} else {
@@ -3223,7 +3223,7 @@
if (sp->used_region().contains(_restart_addr)) {
// Align down to a card boundary for the start of 0th task
// for this space.
- aligned_start = align_down(_restart_addr, CardTableModRefBS::card_size);
+ aligned_start = align_down(_restart_addr, CardTable::card_size);
}
size_t chunk_size = sp->marking_task_size();
@@ -4026,17 +4026,16 @@
startTimer();
sample_eden();
// Get and clear dirty region from card table
- dirtyRegion = _ct->ct_bs()->dirty_card_range_after_reset(
- MemRegion(nextAddr, endAddr),
- true,
- CardTableModRefBS::precleaned_card_val());
+ dirtyRegion = _ct->dirty_card_range_after_reset(MemRegion(nextAddr, endAddr),
+ true,
+ CardTable::precleaned_card_val());
assert(dirtyRegion.start() >= nextAddr,
"returned region inconsistent?");
}
lastAddr = dirtyRegion.end();
numDirtyCards =
- dirtyRegion.word_size()/CardTableModRefBS::card_size_in_words;
+ dirtyRegion.word_size()/CardTable::card_size_in_words;
if (!dirtyRegion.is_empty()) {
stopTimer();
@@ -4050,7 +4049,7 @@
if (stop_point != NULL) {
assert((_collectorState == AbortablePreclean && should_abort_preclean()),
"Should only be AbortablePreclean.");
- _ct->ct_bs()->invalidate(MemRegion(stop_point, dirtyRegion.end()));
+ _ct->invalidate(MemRegion(stop_point, dirtyRegion.end()));
if (should_abort_preclean()) {
break; // out of preclean loop
} else {
@@ -4577,7 +4576,7 @@
SequentialSubTasksDone* pst = sp->conc_par_seq_tasks();
assert(pst->valid(), "Uninitialized use?");
uint nth_task = 0;
- const int alignment = CardTableModRefBS::card_size * BitsPerWord;
+ const int alignment = CardTable::card_size * BitsPerWord;
MemRegion span = sp->used_region();
HeapWord* start_addr = span.start();
HeapWord* end_addr = align_up(span.end(), alignment);
@@ -4603,7 +4602,7 @@
// precleaned, and setting the corresponding bits in the mod union
// table. Since we have been careful to partition at Card and MUT-word
// boundaries no synchronization is needed between parallel threads.
- _collector->_ct->ct_bs()->dirty_card_iterate(this_span,
+ _collector->_ct->dirty_card_iterate(this_span,
&modUnionClosure);
// Having transferred these marks into the modUnionTable,
@@ -4914,16 +4913,14 @@
// mod union table.
{
ModUnionClosure modUnionClosure(&_modUnionTable);
- _ct->ct_bs()->dirty_card_iterate(
- _cmsGen->used_region(),
- &modUnionClosure);
+ _ct->dirty_card_iterate(_cmsGen->used_region(),
+ &modUnionClosure);
}
// Having transferred these marks into the modUnionTable, we just need
// to rescan the marked objects on the dirty cards in the modUnionTable.
// The initial marking may have been done during an asynchronous
// collection so there may be dirty bits in the mod-union table.
- const int alignment =
- CardTableModRefBS::card_size * BitsPerWord;
+ const int alignment = CardTable::card_size * BitsPerWord;
{
// ... First handle dirty cards in CMS gen
markFromDirtyCardsClosure.set_space(_cmsGen->cmsSpace());
@@ -5633,9 +5630,9 @@
}
assert(sz > 0, "size must be nonzero");
HeapWord* next_block = addr + sz;
- HeapWord* next_card = align_up(next_block, CardTableModRefBS::card_size);
- assert(align_down((uintptr_t)addr, CardTableModRefBS::card_size) <
- align_down((uintptr_t)next_card, CardTableModRefBS::card_size),
+ HeapWord* next_card = align_up(next_block, CardTable::card_size);
+ assert(align_down((uintptr_t)addr, CardTable::card_size) <
+ align_down((uintptr_t)next_card, CardTable::card_size),
"must be different cards");
return next_card;
}
@@ -6294,7 +6291,7 @@
assert(_markStack->isEmpty(), "would cause duplicates on stack");
assert(_span.contains(addr), "Out of bounds _finger?");
_finger = addr;
- _threshold = align_up(_finger, CardTableModRefBS::card_size);
+ _threshold = align_up(_finger, CardTable::card_size);
}
// Should revisit to see if this should be restructured for
@@ -6321,7 +6318,7 @@
// during the preclean or remark phase. (CMSCleanOnEnter)
if (CMSCleanOnEnter) {
size_t sz = _collector->block_size_using_printezis_bits(addr);
- HeapWord* end_card_addr = align_up(addr + sz, CardTableModRefBS::card_size);
+ HeapWord* end_card_addr = align_up(addr + sz, CardTable::card_size);
MemRegion redirty_range = MemRegion(addr, end_card_addr);
assert(!redirty_range.is_empty(), "Arithmetical tautology");
// Bump _threshold to end_card_addr; note that
@@ -6408,9 +6405,9 @@
// _threshold is always kept card-aligned but _finger isn't
// always card-aligned.
HeapWord* old_threshold = _threshold;
- assert(is_aligned(old_threshold, CardTableModRefBS::card_size),
+ assert(is_aligned(old_threshold, CardTable::card_size),
"_threshold should always be card-aligned");
- _threshold = align_up(_finger, CardTableModRefBS::card_size);
+ _threshold = align_up(_finger, CardTable::card_size);
MemRegion mr(old_threshold, _threshold);
assert(!mr.is_empty(), "Control point invariant");
assert(_span.contains(mr), "Should clear within span");
@@ -6520,9 +6517,9 @@
// _threshold is always kept card-aligned but _finger isn't
// always card-aligned.
HeapWord* old_threshold = _threshold;
- assert(is_aligned(old_threshold, CardTableModRefBS::card_size),
+ assert(is_aligned(old_threshold, CardTable::card_size),
"_threshold should always be card-aligned");
- _threshold = align_up(_finger, CardTableModRefBS::card_size);
+ _threshold = align_up(_finger, CardTable::card_size);
MemRegion mr(old_threshold, _threshold);
assert(!mr.is_empty(), "Control point invariant");
assert(_span.contains(mr), "Should clear within span"); // _whole_span ??
@@ -6890,7 +6887,7 @@
// are required.
if (obj->is_objArray()) {
size_t sz = obj->size();
- HeapWord* end_card_addr = align_up(addr + sz, CardTableModRefBS::card_size);
+ HeapWord* end_card_addr = align_up(addr + sz, CardTable::card_size);
MemRegion redirty_range = MemRegion(addr, end_card_addr);
assert(!redirty_range.is_empty(), "Arithmetical tautology");
_mod_union_table->mark_range(redirty_range);
@@ -7003,15 +7000,15 @@
}
void MarkFromDirtyCardsClosure::do_MemRegion(MemRegion mr) {
- assert(((size_t)mr.start())%CardTableModRefBS::card_size_in_words == 0,
+ assert(((size_t)mr.start())%CardTable::card_size_in_words == 0,
"mr should be aligned to start at a card boundary");
// We'd like to assert:
- // assert(mr.word_size()%CardTableModRefBS::card_size_in_words == 0,
+ // assert(mr.word_size()%CardTable::card_size_in_words == 0,
// "mr should be a range of cards");
// However, that would be too strong in one case -- the last
// partition ends at _unallocated_block which, in general, can be
// an arbitrary boundary, not necessarily card aligned.
- _num_dirty_cards += mr.word_size()/CardTableModRefBS::card_size_in_words;
+ _num_dirty_cards += mr.word_size()/CardTable::card_size_in_words;
_space->object_iterate_mem(mr, &_scan_cl);
}
@@ -7620,7 +7617,7 @@
// table.
if (obj->is_objArray()) {
size_t sz = obj->size();
- HeapWord* end_card_addr = align_up(addr + sz, CardTableModRefBS::card_size);
+ HeapWord* end_card_addr = align_up(addr + sz, CardTable::card_size);
MemRegion redirty_range = MemRegion(addr, end_card_addr);
assert(!redirty_range.is_empty(), "Arithmetical tautology");
_collector->_modUnionTable.mark_range(redirty_range);