< 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 >