--- a/hotspot/src/share/vm/gc/cms/compactibleFreeListSpace.cpp Thu Jan 14 09:18:11 2016 +0100
+++ b/hotspot/src/share/vm/gc/cms/compactibleFreeListSpace.cpp Thu Jan 14 13:26:19 2016 +0100
@@ -576,7 +576,7 @@
}
}
-class FreeListSpace_DCTOC : public Filtering_DCTOC {
+class FreeListSpaceDCTOC : public FilteringDCTOC {
CompactibleFreeListSpace* _cfls;
CMSCollector* _collector;
bool _parallel;
@@ -596,21 +596,21 @@
walk_mem_region_with_cl_DECL(FilteringClosure);
public:
- FreeListSpace_DCTOC(CompactibleFreeListSpace* sp,
- CMSCollector* collector,
- ExtendedOopClosure* cl,
- CardTableModRefBS::PrecisionStyle precision,
- HeapWord* boundary,
- bool parallel) :
- Filtering_DCTOC(sp, cl, precision, boundary),
+ FreeListSpaceDCTOC(CompactibleFreeListSpace* sp,
+ CMSCollector* collector,
+ ExtendedOopClosure* cl,
+ CardTableModRefBS::PrecisionStyle precision,
+ HeapWord* boundary,
+ bool parallel) :
+ FilteringDCTOC(sp, cl, precision, boundary),
_cfls(sp), _collector(collector), _parallel(parallel) {}
};
// We de-virtualize the block-related calls below, since we know that our
// space is a CompactibleFreeListSpace.
-#define FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \
-void FreeListSpace_DCTOC::walk_mem_region_with_cl(MemRegion mr, \
+#define FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \
+void FreeListSpaceDCTOC::walk_mem_region_with_cl(MemRegion mr, \
HeapWord* bottom, \
HeapWord* top, \
ClosureType* cl) { \
@@ -620,10 +620,10 @@
walk_mem_region_with_cl_nopar(mr, bottom, top, cl); \
} \
} \
-void FreeListSpace_DCTOC::walk_mem_region_with_cl_par(MemRegion mr, \
- HeapWord* bottom, \
- HeapWord* top, \
- ClosureType* cl) { \
+void FreeListSpaceDCTOC::walk_mem_region_with_cl_par(MemRegion mr, \
+ HeapWord* bottom, \
+ HeapWord* top, \
+ ClosureType* cl) { \
/* Skip parts that are before "mr", in case "block_start" sent us \
back too far. */ \
HeapWord* mr_start = mr.start(); \
@@ -647,10 +647,10 @@
} \
} \
} \
-void FreeListSpace_DCTOC::walk_mem_region_with_cl_nopar(MemRegion mr, \
- HeapWord* bottom, \
- HeapWord* top, \
- ClosureType* cl) { \
+void FreeListSpaceDCTOC::walk_mem_region_with_cl_nopar(MemRegion mr, \
+ HeapWord* bottom, \
+ HeapWord* top, \
+ ClosureType* cl) { \
/* Skip parts that are before "mr", in case "block_start" sent us \
back too far. */ \
HeapWord* mr_start = mr.start(); \
@@ -678,15 +678,15 @@
// (There are only two of these, rather than N, because the split is due
// only to the introduction of the FilteringClosure, a local part of the
// impl of this abstraction.)
-FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure)
-FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure)
+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,
HeapWord* boundary,
bool parallel) {
- return new FreeListSpace_DCTOC(this, _collector, cl, precision, boundary, parallel);
+ return new FreeListSpaceDCTOC(this, _collector, cl, precision, boundary, parallel);
}
@@ -2413,7 +2413,7 @@
}
///////////////////////////////////////////////////////////////////////////
-// CFLS_LAB
+// CompactibleFreeListSpaceLAB
///////////////////////////////////////////////////////////////////////////
#define VECTOR_257(x) \
@@ -2432,12 +2432,12 @@
// generic OldPLABSize, whose static default is different; if overridden at the
// command-line, this will get reinitialized via a call to
// modify_initialization() below.
-AdaptiveWeightedAverage CFLS_LAB::_blocks_to_claim[] =
- VECTOR_257(AdaptiveWeightedAverage(OldPLABWeight, (float)CFLS_LAB::_default_dynamic_old_plab_size));
-size_t CFLS_LAB::_global_num_blocks[] = VECTOR_257(0);
-uint CFLS_LAB::_global_num_workers[] = VECTOR_257(0);
+AdaptiveWeightedAverage CompactibleFreeListSpaceLAB::_blocks_to_claim[] =
+ VECTOR_257(AdaptiveWeightedAverage(OldPLABWeight, (float)CompactibleFreeListSpaceLAB::_default_dynamic_old_plab_size));
+size_t CompactibleFreeListSpaceLAB::_global_num_blocks[] = VECTOR_257(0);
+uint CompactibleFreeListSpaceLAB::_global_num_workers[] = VECTOR_257(0);
-CFLS_LAB::CFLS_LAB(CompactibleFreeListSpace* cfls) :
+CompactibleFreeListSpaceLAB::CompactibleFreeListSpaceLAB(CompactibleFreeListSpace* cfls) :
_cfls(cfls)
{
assert(CompactibleFreeListSpace::IndexSetSize == 257, "Modify VECTOR_257() macro above");
@@ -2451,7 +2451,7 @@
static bool _CFLS_LAB_modified = false;
-void CFLS_LAB::modify_initialization(size_t n, unsigned wt) {
+void CompactibleFreeListSpaceLAB::modify_initialization(size_t n, unsigned wt) {
assert(!_CFLS_LAB_modified, "Call only once");
_CFLS_LAB_modified = true;
for (size_t i = CompactibleFreeListSpace::IndexSetStart;
@@ -2461,7 +2461,7 @@
}
}
-HeapWord* CFLS_LAB::alloc(size_t word_sz) {
+HeapWord* CompactibleFreeListSpaceLAB::alloc(size_t word_sz) {
FreeChunk* res;
assert(word_sz == _cfls->adjustObjectSize(word_sz), "Error");
if (word_sz >= CompactibleFreeListSpace::IndexSetSize) {
@@ -2491,7 +2491,7 @@
// Get a chunk of blocks of the right size and update related
// book-keeping stats
-void CFLS_LAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList<FreeChunk>* fl) {
+void CompactibleFreeListSpaceLAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList<FreeChunk>* fl) {
// Get the #blocks we want to claim
size_t n_blks = (size_t)_blocks_to_claim[word_sz].average();
assert(n_blks > 0, "Error");
@@ -2525,7 +2525,7 @@
_num_blocks[word_sz] += fl->count();
}
-void CFLS_LAB::compute_desired_plab_size() {
+void CompactibleFreeListSpaceLAB::compute_desired_plab_size() {
for (size_t i = CompactibleFreeListSpace::IndexSetStart;
i < CompactibleFreeListSpace::IndexSetSize;
i += CompactibleFreeListSpace::IndexSetStride) {
@@ -2551,7 +2551,7 @@
// access, one would need to take the FL locks and,
// depending on how it is used, stagger access from
// parallel threads to reduce contention.
-void CFLS_LAB::retire(int tid) {
+void CompactibleFreeListSpaceLAB::retire(int tid) {
// We run this single threaded with the world stopped;
// so no need for locks and such.
NOT_PRODUCT(Thread* t = Thread::current();)