< prev index next >

src/hotspot/share/gc/cms/cmsHeap.cpp

Print this page
rev 47957 : 8191564: Refactor GC related servicability code into GC specific subclasses

*** 21,38 **** --- 21,43 ---- * questions. * */ #include "precompiled.hpp" + #include "gc/cms/compactibleFreeListSpace.hpp" + #include "gc/cms/concurrentMarkSweepGeneration.hpp" #include "gc/cms/concurrentMarkSweepThread.hpp" #include "gc/cms/cmsHeap.hpp" + #include "gc/cms/parNewGeneration.hpp" #include "gc/cms/vmCMSOperations.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/strongRootsScope.hpp" #include "gc/shared/workgroup.hpp" #include "oops/oop.inline.hpp" #include "runtime/vmThread.hpp" + #include "services/memoryManager.hpp" + #include "services/memoryPool.hpp" #include "utilities/stack.inline.hpp" CMSHeap::CMSHeap(GenCollectorPolicy *policy) : GenCollectedHeap(policy) { _workers = new WorkGang("GC Thread", ParallelGCThreads, /* are_GC_task_threads */true,
*** 181,185 **** --- 186,269 ---- void CMSHeap::gc_epilogue(bool full) { GenCollectedHeap::gc_epilogue(full); always_do_update_barrier = true; }; + + class ParNewMemoryManager : public GCMemoryManager { + private: + public: + ParNewMemoryManager() : GCMemoryManager() {} + + const char* name() { return "ParNew"; } + virtual const char* gc_end_message() { return "end of major GC"; } + }; + + class CMSMemoryManager : public GCMemoryManager { + private: + public: + CMSMemoryManager() : GCMemoryManager() {} + + const char* name() { return "ConcurrentMarkSweep";} + virtual const char* gc_end_message() { return "end of minor GC"; } + }; + + class CompactibleFreeListSpacePool : public CollectedMemoryPool { + private: + CompactibleFreeListSpace* _space; + public: + CompactibleFreeListSpacePool(CompactibleFreeListSpace* space, + const char* name, + PoolType type, + size_t max_size, + bool support_usage_threshold) : + CollectedMemoryPool(name, type, space->capacity(), max_size, + support_usage_threshold), _space(space) { + } + + MemoryUsage get_memory_usage() { + size_t maxSize = (available_for_allocation() ? max_size() : 0); + size_t used = used_in_bytes(); + size_t committed = _space->capacity(); + + return MemoryUsage(initial_size(), used, committed, maxSize); + } + + size_t used_in_bytes() { + return _space->used(); + } + }; + + void CMSHeap::init_memory_managers() { + _minor_mgr = new ParNewMemoryManager(); + _major_mgr = new CMSMemoryManager(); + } + + GrowableArray<MemoryManager*> CMSHeap::memory_managers() { + GrowableArray<MemoryManager*> cms_memory_managers; + cms_memory_managers.append(_minor_mgr); + cms_memory_managers.append(_major_mgr); + return cms_memory_managers; + } + + GrowableArray<MemoryPool*> CMSHeap::memory_pools() { + GrowableArray<MemoryPool*> cms_memory_pools; + + ParNewGeneration* young = (ParNewGeneration*) young_gen(); + ContiguousSpacePool* eden = new ContiguousSpacePool(young->eden(), "Par Eden Space", MemoryPool::Heap, young->max_eden_size(), false); + SurvivorContiguousSpacePool* survivor = new SurvivorContiguousSpacePool(young, "Par Survivor Space", MemoryPool::Heap, young->max_survivor_size(), false); + + ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) old_gen(); + CompactibleFreeListSpacePool* old = new CompactibleFreeListSpacePool(cms->cmsSpace(), "CMS Old Gen", MemoryPool::Heap, cms->reserved().byte_size(), true); + + cms_memory_pools.append(eden); + cms_memory_pools.append(survivor); + cms_memory_pools.append(old); + + _minor_mgr->add_pool(eden); + _major_mgr->add_pool(eden); + _minor_mgr->add_pool(survivor); + _major_mgr->add_pool(survivor); + _major_mgr->add_pool(old); + + return cms_memory_pools; + }
< prev index next >