29 #include "gc/serial/defNewGeneration.hpp" 30 #include "gc/serial/tenuredGeneration.hpp" 31 #include "gc/shared/collectorPolicy.hpp" 32 #include "gc/shared/genCollectedHeap.hpp" 33 #include "gc/shared/generation.hpp" 34 #include "gc/shared/generationSpec.hpp" 35 #include "memory/heap.hpp" 36 #include "memory/memRegion.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "runtime/globals.hpp" 39 #include "runtime/javaCalls.hpp" 40 #include "services/classLoadingService.hpp" 41 #include "services/lowMemoryDetector.hpp" 42 #include "services/management.hpp" 43 #include "services/memoryManager.hpp" 44 #include "services/memoryPool.hpp" 45 #include "services/memoryService.hpp" 46 #include "utilities/growableArray.hpp" 47 #include "utilities/macros.hpp" 48 #if INCLUDE_ALL_GCS 49 #include "gc/cms/concurrentMarkSweepGeneration.hpp" 50 #include "gc/cms/parNewGeneration.hpp" 51 #include "gc/g1/g1CollectedHeap.inline.hpp" 52 #include "gc/parallel/parallelScavengeHeap.hpp" 53 #include "gc/parallel/psOldGen.hpp" 54 #include "gc/parallel/psYoungGen.hpp" 55 #include "services/g1MemoryPool.hpp" 56 #include "services/psMemoryPool.hpp" 57 #endif // INCLUDE_ALL_GCS 58 59 GrowableArray<MemoryPool*>* MemoryService::_pools_list = 60 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true); 61 GrowableArray<MemoryManager*>* MemoryService::_managers_list = 62 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true); 63 64 GCMemoryManager* MemoryService::_minor_gc_manager = NULL; 65 GCMemoryManager* MemoryService::_major_gc_manager = NULL; 66 MemoryManager* MemoryService::_code_cache_manager = NULL; 67 GrowableArray<MemoryPool*>* MemoryService::_code_heap_pools = 68 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_code_heap_pools_size, true); 69 MemoryPool* MemoryService::_metaspace_pool = NULL; 70 MemoryPool* MemoryService::_compressed_class_pool = NULL; 71 72 class GcThreadCountClosure: public ThreadClosure { 73 private: 74 int _count; 75 public: 76 GcThreadCountClosure() : _count(0) {}; 81 void GcThreadCountClosure::do_thread(Thread* thread) { 82 _count++; 83 } 84 85 void MemoryService::set_universe_heap(CollectedHeap* heap) { 86 CollectedHeap::Name kind = heap->kind(); 87 switch (kind) { 88 case CollectedHeap::GenCollectedHeap : { 89 add_gen_collected_heap_info(GenCollectedHeap::heap()); 90 break; 91 } 92 #if INCLUDE_ALL_GCS 93 case CollectedHeap::ParallelScavengeHeap : { 94 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap()); 95 break; 96 } 97 case CollectedHeap::G1CollectedHeap : { 98 add_g1_heap_info(G1CollectedHeap::heap()); 99 break; 100 } 101 #endif // INCLUDE_ALL_GCS 102 default: { 103 guarantee(false, "Unrecognized kind of heap"); 104 } 105 } 106 107 // set the GC thread count 108 GcThreadCountClosure gctcc; 109 heap->gc_threads_do(&gctcc); 110 int count = gctcc.count(); 111 if (count > 0) { 112 _minor_gc_manager->set_num_gc_threads(count); 113 _major_gc_manager->set_num_gc_threads(count); 114 } 115 116 // All memory pools and memory managers are initialized. 117 // 118 _minor_gc_manager->initialize_gc_stat_info(); 119 _major_gc_manager->initialize_gc_stat_info(); 120 } 121 122 // Add memory pools for GenCollectedHeap 123 // This function currently only supports two generations collected heap. 124 // The collector for GenCollectedHeap will have two memory managers. 125 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) { 126 CollectorPolicy* policy = heap->collector_policy(); 127 128 assert(policy->is_generation_policy(), "Only support two generations"); 129 GenCollectorPolicy* gen_policy = policy->as_generation_policy(); 130 if (gen_policy != NULL) { 131 Generation::Name kind = gen_policy->young_gen_spec()->name(); 132 switch (kind) { 133 case Generation::DefNew: 134 _minor_gc_manager = MemoryManager::get_copy_memory_manager(); 135 break; 136 #if INCLUDE_ALL_GCS 137 case Generation::ParNew: 138 _minor_gc_manager = MemoryManager::get_parnew_memory_manager(); 139 break; 170 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager(); 171 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager(); 172 _managers_list->append(_minor_gc_manager); 173 _managers_list->append(_major_gc_manager); 174 175 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager); 176 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager); 177 } 178 179 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) { 180 assert(UseG1GC, "sanity"); 181 182 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager(); 183 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager(); 184 _managers_list->append(_minor_gc_manager); 185 _managers_list->append(_major_gc_manager); 186 187 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager); 188 add_g1OldGen_memory_pool(g1h, _major_gc_manager); 189 } 190 #endif // INCLUDE_ALL_GCS 191 192 MemoryPool* MemoryService::add_gen(Generation* gen, 193 const char* name, 194 bool is_heap, 195 bool support_usage_threshold) { 196 197 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); 198 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold); 199 _pools_list->append(pool); 200 return (MemoryPool*) pool; 201 } 202 203 MemoryPool* MemoryService::add_space(ContiguousSpace* space, 204 const char* name, 205 bool is_heap, 206 size_t max_size, 207 bool support_usage_threshold) { 208 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); 209 ContiguousSpacePool* pool = new ContiguousSpacePool(space, name, type, max_size, support_usage_threshold); 368 369 G1EdenPool* eden = new G1EdenPool(g1h); 370 G1SurvivorPool* survivor = new G1SurvivorPool(g1h); 371 372 major_mgr->add_pool(eden); 373 major_mgr->add_pool(survivor); 374 minor_mgr->add_pool(eden); 375 minor_mgr->add_pool(survivor); 376 _pools_list->append(eden); 377 _pools_list->append(survivor); 378 } 379 380 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h, 381 MemoryManager* mgr) { 382 assert(mgr != NULL, "should have one manager"); 383 384 G1OldGenPool* old_gen = new G1OldGenPool(g1h); 385 mgr->add_pool(old_gen); 386 _pools_list->append(old_gen); 387 } 388 #endif // INCLUDE_ALL_GCS 389 390 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) { 391 // Create new memory pool for this heap 392 MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */); 393 394 // Append to lists 395 _code_heap_pools->append(code_heap_pool); 396 _pools_list->append(code_heap_pool); 397 398 if (_code_cache_manager == NULL) { 399 // Create CodeCache memory manager 400 _code_cache_manager = MemoryManager::get_code_cache_memory_manager(); 401 _managers_list->append(_code_cache_manager); 402 } 403 404 _code_cache_manager->add_pool(code_heap_pool); 405 } 406 407 void MemoryService::add_metaspace_memory_pools() { | 29 #include "gc/serial/defNewGeneration.hpp" 30 #include "gc/serial/tenuredGeneration.hpp" 31 #include "gc/shared/collectorPolicy.hpp" 32 #include "gc/shared/genCollectedHeap.hpp" 33 #include "gc/shared/generation.hpp" 34 #include "gc/shared/generationSpec.hpp" 35 #include "memory/heap.hpp" 36 #include "memory/memRegion.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "runtime/globals.hpp" 39 #include "runtime/javaCalls.hpp" 40 #include "services/classLoadingService.hpp" 41 #include "services/lowMemoryDetector.hpp" 42 #include "services/management.hpp" 43 #include "services/memoryManager.hpp" 44 #include "services/memoryPool.hpp" 45 #include "services/memoryService.hpp" 46 #include "utilities/growableArray.hpp" 47 #include "utilities/macros.hpp" 48 #if INCLUDE_ALL_GCS 49 #include "gc/shenandoah/shenandoahHeap.hpp" 50 #include "gc/cms/concurrentMarkSweepGeneration.hpp" 51 #include "gc/cms/parNewGeneration.hpp" 52 #include "gc/g1/g1CollectedHeap.inline.hpp" 53 #include "gc/parallel/parallelScavengeHeap.hpp" 54 #include "gc/parallel/psOldGen.hpp" 55 #include "gc/parallel/psYoungGen.hpp" 56 #include "services/g1MemoryPool.hpp" 57 #include "services/psMemoryPool.hpp" 58 #include "services/shenandoahMemoryPool.hpp" 59 #endif // INCLUDE_ALL_GCS 60 61 GrowableArray<MemoryPool*>* MemoryService::_pools_list = 62 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true); 63 GrowableArray<MemoryManager*>* MemoryService::_managers_list = 64 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true); 65 66 GCMemoryManager* MemoryService::_minor_gc_manager = NULL; 67 GCMemoryManager* MemoryService::_major_gc_manager = NULL; 68 MemoryManager* MemoryService::_code_cache_manager = NULL; 69 GrowableArray<MemoryPool*>* MemoryService::_code_heap_pools = 70 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_code_heap_pools_size, true); 71 MemoryPool* MemoryService::_metaspace_pool = NULL; 72 MemoryPool* MemoryService::_compressed_class_pool = NULL; 73 74 class GcThreadCountClosure: public ThreadClosure { 75 private: 76 int _count; 77 public: 78 GcThreadCountClosure() : _count(0) {}; 83 void GcThreadCountClosure::do_thread(Thread* thread) { 84 _count++; 85 } 86 87 void MemoryService::set_universe_heap(CollectedHeap* heap) { 88 CollectedHeap::Name kind = heap->kind(); 89 switch (kind) { 90 case CollectedHeap::GenCollectedHeap : { 91 add_gen_collected_heap_info(GenCollectedHeap::heap()); 92 break; 93 } 94 #if INCLUDE_ALL_GCS 95 case CollectedHeap::ParallelScavengeHeap : { 96 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap()); 97 break; 98 } 99 case CollectedHeap::G1CollectedHeap : { 100 add_g1_heap_info(G1CollectedHeap::heap()); 101 break; 102 } 103 case CollectedHeap::ShenandoahHeap : { 104 add_shenandoah_heap_info(ShenandoahHeap::heap()); 105 break; 106 } 107 #endif // INCLUDE_ALL_GCS 108 default: { 109 guarantee(false, "Unrecognized kind of heap"); 110 } 111 } 112 113 // set the GC thread count 114 GcThreadCountClosure gctcc; 115 heap->gc_threads_do(&gctcc); 116 int count = gctcc.count(); 117 if (count > 0) { 118 _minor_gc_manager->set_num_gc_threads(count); 119 _major_gc_manager->set_num_gc_threads(count); 120 } 121 122 // All memory pools and memory managers are initialized. 123 // 124 if (UseShenandoahGC) { 125 _major_gc_manager->initialize_gc_stat_info(); 126 } else { 127 _minor_gc_manager->initialize_gc_stat_info(); 128 _major_gc_manager->initialize_gc_stat_info(); 129 } 130 } 131 132 // Add memory pools for GenCollectedHeap 133 // This function currently only supports two generations collected heap. 134 // The collector for GenCollectedHeap will have two memory managers. 135 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) { 136 CollectorPolicy* policy = heap->collector_policy(); 137 138 assert(policy->is_generation_policy(), "Only support two generations"); 139 GenCollectorPolicy* gen_policy = policy->as_generation_policy(); 140 if (gen_policy != NULL) { 141 Generation::Name kind = gen_policy->young_gen_spec()->name(); 142 switch (kind) { 143 case Generation::DefNew: 144 _minor_gc_manager = MemoryManager::get_copy_memory_manager(); 145 break; 146 #if INCLUDE_ALL_GCS 147 case Generation::ParNew: 148 _minor_gc_manager = MemoryManager::get_parnew_memory_manager(); 149 break; 180 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager(); 181 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager(); 182 _managers_list->append(_minor_gc_manager); 183 _managers_list->append(_major_gc_manager); 184 185 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager); 186 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager); 187 } 188 189 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) { 190 assert(UseG1GC, "sanity"); 191 192 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager(); 193 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager(); 194 _managers_list->append(_minor_gc_manager); 195 _managers_list->append(_major_gc_manager); 196 197 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager); 198 add_g1OldGen_memory_pool(g1h, _major_gc_manager); 199 } 200 201 void MemoryService::add_shenandoah_heap_info(ShenandoahHeap* pgch) { 202 assert(UseShenandoahGC, "sanity"); 203 _major_gc_manager = MemoryManager::get_shenandoah_memory_manager(); 204 _minor_gc_manager = MemoryManager::get_shenandoah_memory_manager(); 205 _managers_list->append(_major_gc_manager); 206 add_shenandoah_memory_pool(pgch, _major_gc_manager); 207 } 208 209 #endif // INCLUDE_ALL_GCS 210 211 MemoryPool* MemoryService::add_gen(Generation* gen, 212 const char* name, 213 bool is_heap, 214 bool support_usage_threshold) { 215 216 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); 217 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold); 218 _pools_list->append(pool); 219 return (MemoryPool*) pool; 220 } 221 222 MemoryPool* MemoryService::add_space(ContiguousSpace* space, 223 const char* name, 224 bool is_heap, 225 size_t max_size, 226 bool support_usage_threshold) { 227 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); 228 ContiguousSpacePool* pool = new ContiguousSpacePool(space, name, type, max_size, support_usage_threshold); 387 388 G1EdenPool* eden = new G1EdenPool(g1h); 389 G1SurvivorPool* survivor = new G1SurvivorPool(g1h); 390 391 major_mgr->add_pool(eden); 392 major_mgr->add_pool(survivor); 393 minor_mgr->add_pool(eden); 394 minor_mgr->add_pool(survivor); 395 _pools_list->append(eden); 396 _pools_list->append(survivor); 397 } 398 399 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h, 400 MemoryManager* mgr) { 401 assert(mgr != NULL, "should have one manager"); 402 403 G1OldGenPool* old_gen = new G1OldGenPool(g1h); 404 mgr->add_pool(old_gen); 405 _pools_list->append(old_gen); 406 } 407 408 void MemoryService::add_shenandoah_memory_pool(ShenandoahHeap* pgc, 409 MemoryManager* mgr) { 410 ShenandoahMemoryPool* pool = new ShenandoahMemoryPool(pgc, 411 "Shenandoah", 412 MemoryPool::Heap, 413 false /* support_usage_threshold */); 414 415 mgr->add_pool(pool); 416 _pools_list->append(pool); 417 } 418 419 420 #endif // INCLUDE_ALL_GCS 421 422 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) { 423 // Create new memory pool for this heap 424 MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */); 425 426 // Append to lists 427 _code_heap_pools->append(code_heap_pool); 428 _pools_list->append(code_heap_pool); 429 430 if (_code_cache_manager == NULL) { 431 // Create CodeCache memory manager 432 _code_cache_manager = MemoryManager::get_code_cache_memory_manager(); 433 _managers_list->append(_code_cache_manager); 434 } 435 436 _code_cache_manager->add_pool(code_heap_pool); 437 } 438 439 void MemoryService::add_metaspace_memory_pools() { |