diff -r 580bb0b85f63 -r 7e958a8ebcd3 src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp --- 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);