< prev index next >
src/share/vm/gc/cms/compactibleFreeListSpace.cpp
Print this page
rev 12906 : [mq]: gc_interface
@@ -83,13 +83,13 @@
_freelistLock(_lockRank--, "CompactibleFreeListSpace._lock", true,
Monitor::_safepoint_check_sometimes),
_parDictionaryAllocLock(Mutex::leaf - 1, // == rank(ExpandHeap_lock) - 1
"CompactibleFreeListSpace._dict_par_lock", true,
Monitor::_safepoint_check_never),
- _rescan_task_size(CardTableModRefBS::card_size_in_words * BitsPerWord *
+ _rescan_task_size(CardTable::card_size_in_words * BitsPerWord *
CMSRescanMultiple),
- _marking_task_size(CardTableModRefBS::card_size_in_words * BitsPerWord *
+ _marking_task_size(CardTable::card_size_in_words * BitsPerWord *
CMSConcMarkMultiple),
_collector(NULL),
_preconsumptionDirtyCardClosure(NULL)
{
assert(sizeof(FreeChunk) / BytesPerWord <= MinChunkSize,
@@ -604,11 +604,11 @@
public:
FreeListSpaceDCTOC(CompactibleFreeListSpace* sp,
CMSCollector* collector,
ExtendedOopClosure* cl,
- CardTableModRefBS::PrecisionStyle precision,
+ CardTable::PrecisionStyle precision,
HeapWord* boundary,
bool parallel) :
FilteringDCTOC(sp, cl, precision, boundary),
_cfls(sp), _collector(collector), _parallel(parallel) {}
};
@@ -688,11 +688,11 @@
FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure)
FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure)
DirtyCardToOopClosure*
CompactibleFreeListSpace::new_dcto_cl(ExtendedOopClosure* cl,
- CardTableModRefBS::PrecisionStyle precision,
+ CardTable::PrecisionStyle precision,
HeapWord* boundary,
bool parallel) {
return new FreeListSpaceDCTOC(this, _collector, cl, precision, boundary, parallel);
}
@@ -2826,11 +2826,11 @@
// Otherwise, we'll split a block from the dictionary.
par_get_chunk_of_blocks_dictionary(word_sz, n, fl);
}
const size_t CompactibleFreeListSpace::max_flag_size_for_task_size() const {
- const size_t ergo_max = _old_gen->reserved().word_size() / (CardTableModRefBS::card_size_in_words * BitsPerWord);
+ const size_t ergo_max = _old_gen->reserved().word_size() / (CardTable::card_size_in_words * BitsPerWord);
return ergo_max;
}
// Set up the space's par_seq_tasks structure for work claiming
// for parallel rescan. See CMSParRemarkTask where this is currently used.
@@ -2863,28 +2863,28 @@
initialize_sequential_subtasks_for_marking(int n_threads,
HeapWord* low) {
// The "size" of each task is fixed according to rescan_task_size.
assert(n_threads > 0, "Unexpected n_threads argument");
const size_t task_size = marking_task_size();
- assert(task_size > CardTableModRefBS::card_size_in_words &&
- (task_size % CardTableModRefBS::card_size_in_words == 0),
+ assert(task_size > CardTable::card_size_in_words &&
+ (task_size % CardTable::card_size_in_words == 0),
"Otherwise arithmetic below would be incorrect");
MemRegion span = _old_gen->reserved();
if (low != NULL) {
if (span.contains(low)) {
// Align low down to a card boundary so that
// we can use block_offset_careful() on span boundaries.
HeapWord* aligned_low = (HeapWord*)align_size_down((uintptr_t)low,
- CardTableModRefBS::card_size);
+ CardTable::card_size);
// Clip span prefix at aligned_low
span = span.intersection(MemRegion(aligned_low, span.end()));
} else if (low > span.end()) {
span = MemRegion(low, low); // Null region
} // else use entire span
}
assert(span.is_empty() ||
- ((uintptr_t)span.start() % CardTableModRefBS::card_size == 0),
+ ((uintptr_t)span.start() % CardTable::card_size == 0),
"span should start at a card boundary");
size_t n_tasks = (span.word_size() + task_size - 1)/task_size;
assert((n_tasks == 0) == span.is_empty(), "Inconsistency");
assert(n_tasks == 0 ||
((span.start() + (n_tasks - 1)*task_size < span.end()) &&
< prev index next >