jdk8-mips64-public/hotspot: comparison src/share/vm/services/memoryService.cpp

-:46e60405583b
+:db9981fd3124
 #include "services/management.hpp"
 #include "services/memoryManager.hpp"
 #include "services/memoryPool.hpp"
 #include "services/memoryService.hpp"
 #include "utilities/growableArray.hpp"
-#ifndef SERIALGC
+#include "utilities/macros.hpp"
+#if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/parNew/parNewGeneration.hpp"
 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
 #include "services/g1MemoryPool.hpp"
 #include "services/psMemoryPool.hpp"
-#endif
+#endif // INCLUDE_ALL_GCS
 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
 switch (kind) {
 case CollectedHeap::GenCollectedHeap : {
 add_gen_collected_heap_info(GenCollectedHeap::heap());
 break;
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case CollectedHeap::ParallelScavengeHeap : {
 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap());
 break;
 }
 case CollectedHeap::G1CollectedHeap : {
 add_g1_heap_info(G1CollectedHeap::heap());
 break;
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 default: {
 guarantee(false, "Unrecognized kind of heap");
 }
 }
 Generation::Name kind = specs[0]->name();
 switch (kind) {
 case Generation::DefNew:
 _minor_gc_manager = MemoryManager::get_copy_memory_manager();
 break;
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case Generation::ParNew:
 case Generation::ASParNew:
 _minor_gc_manager = MemoryManager::get_parnew_memory_manager();
 break;
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 default:
 guarantee(false, "Unrecognized generation spec");
 break;
 }
 if (policy->is_mark_sweep_policy()) {
 _major_gc_manager = MemoryManager::get_msc_memory_manager();
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 } else if (policy->is_concurrent_mark_sweep_policy()) {
 _major_gc_manager = MemoryManager::get_cms_memory_manager();
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 } else {
 guarantee(false, "Unknown two-gen policy");
 }
 } else {
 guarantee(false, "Non two-gen policy");
 add_generation_memory_pool(heap->get_gen(minor), _major_gc_manager, _minor_gc_manager);
 add_generation_memory_pool(heap->get_gen(major), _major_gc_manager);
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 // Add memory pools for ParallelScavengeHeap
 // This function currently only supports two generations collected heap.
 // The collector for ParallelScavengeHeap will have two memory managers.
 void MemoryService::add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap) {
 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
 _managers_list->append(_major_gc_manager);
 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
 add_g1OldGen_memory_pool(g1h, _major_gc_manager);
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 MemoryPool* MemoryService::add_gen(Generation* gen,
 const char* name,
 bool is_heap,
 bool support_usage_threshold) {
 _pools_list->append(pool);
 return (MemoryPool*) pool;
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 MemoryPool* MemoryService::add_cms_space(CompactibleFreeListSpace* space,
 const char* name,
 bool is_heap,
 size_t max_size,
 bool support_usage_threshold) {
 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
 CompactibleFreeListSpacePool* pool = new CompactibleFreeListSpacePool(space, name, type, max_size, support_usage_threshold);
 _pools_list->append(pool);
 return (MemoryPool*) pool;
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 // Add memory pool(s) for one generation
 void MemoryService::add_generation_memory_pool(Generation* gen,
 MemoryManager* major_mgr,
 MemoryManager* minor_mgr) {
 young_gen->max_survivor_size(),
 false /* support_usage_threshold */);
 break;
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case Generation::ParNew:
 case Generation::ASParNew:
 {
 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
 // Add a memory pool for each space and young gen doesn't
 parnew_gen->max_survivor_size(),
 false /* support_usage_threshold */);
 break;
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 case Generation::MarkSweepCompact: {
 assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
 add_gen(gen,
 "Tenured Gen",
 true, /* is_heap */
 true  /* support_usage_threshold */);
 break;
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case Generation::ConcurrentMarkSweep:
 case Generation::ASConcurrentMarkSweep:
 {
 assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
 ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) gen;
 true, /* is_heap */
 cms->reserved().byte_size(),
 true  /* support_usage_threshold */);
 break;
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 default:
 assert(false, "should not reach here");
 // no memory pool added for others
 break;
 }
 }
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 void MemoryService::add_psYoung_memory_pool(PSYoungGen* gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) {
 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
 // Add a memory pool for each space and young gen doesn't
 // support low memory detection as it is expected to get filled up.
 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
 mgr->add_pool(old_gen);
 _pools_list->append(old_gen);
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
 _code_heap_pool = new CodeHeapPool(heap,
 "Code Cache",
 true /* support_usage_threshold */);
 // doing mark-sweep-compact uses major gc manager (so _fullGC is set
 // to true).
 TraceMemoryManagerStats::TraceMemoryManagerStats(Generation::Name kind, GCCause::Cause cause) {
 switch (kind) {
 case Generation::DefNew:
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case Generation::ParNew:
 case Generation::ASParNew:
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 _fullGC=false;
 break;
 case Generation::MarkSweepCompact:
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 case Generation::ConcurrentMarkSweep:
 case Generation::ASConcurrentMarkSweep:
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 _fullGC=true;
 break;
 default:
 assert(false, "Unrecognized gc generation kind.");
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/services/memoryService.cpp

src/share/vm/services/memoryService.cpp