src/share/vm/services/memoryService.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File JDK-8015774 Sdiff src/share/vm/services

src/share/vm/services/memoryService.cpp

Print this page




  46 #include "utilities/growableArray.hpp"
  47 #include "utilities/macros.hpp"
  48 #if INCLUDE_ALL_GCS
  49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
  50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
  51 #include "gc_implementation/parNew/parNewGeneration.hpp"
  52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
  53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  54 #include "gc_implementation/parallelScavenge/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 MemoryPool*      MemoryService::_code_heap_pool        = NULL;


  67 MemoryPool*      MemoryService::_metaspace_pool        = NULL;
  68 MemoryPool*      MemoryService::_compressed_class_pool = NULL;
  69 
  70 class GcThreadCountClosure: public ThreadClosure {
  71  private:
  72   int _count;
  73  public:
  74   GcThreadCountClosure() : _count(0) {};
  75   void do_thread(Thread* thread);
  76   int count() { return _count; }
  77 };
  78 
  79 void GcThreadCountClosure::do_thread(Thread* thread) {
  80   _count++;
  81 }
  82 
  83 void MemoryService::set_universe_heap(CollectedHeap* heap) {
  84   CollectedHeap::Name kind = heap->kind();
  85   switch (kind) {
  86     case CollectedHeap::GenCollectedHeap : {


 374   G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
 375 
 376   major_mgr->add_pool(eden);
 377   major_mgr->add_pool(survivor);
 378   minor_mgr->add_pool(eden);
 379   minor_mgr->add_pool(survivor);
 380   _pools_list->append(eden);
 381   _pools_list->append(survivor);
 382 }
 383 
 384 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
 385                                              MemoryManager* mgr) {
 386   assert(mgr != NULL, "should have one manager");
 387 
 388   G1OldGenPool* old_gen = new G1OldGenPool(g1h);
 389   mgr->add_pool(old_gen);
 390   _pools_list->append(old_gen);
 391 }
 392 #endif // INCLUDE_ALL_GCS
 393 
 394 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
 395   _code_heap_pool = new CodeHeapPool(heap,
 396                                      "Code Cache",
 397                                      true /* support_usage_threshold */);
 398   MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
 399   mgr->add_pool(_code_heap_pool);







 400 
 401   _pools_list->append(_code_heap_pool);
 402   _managers_list->append(mgr);
 403 }
 404 
 405 void MemoryService::add_metaspace_memory_pools() {
 406   MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
 407 
 408   _metaspace_pool = new MetaspacePool();
 409   mgr->add_pool(_metaspace_pool);
 410   _pools_list->append(_metaspace_pool);
 411 
 412   if (UseCompressedClassPointers) {
 413     _compressed_class_pool = new CompressedKlassSpacePool();
 414     mgr->add_pool(_compressed_class_pool);
 415     _pools_list->append(_compressed_class_pool);
 416   }
 417 
 418   _managers_list->append(mgr);
 419 }
 420 
 421 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
 422   for (int i = 0; i < _managers_list->length(); i++) {




  46 #include "utilities/growableArray.hpp"
  47 #include "utilities/macros.hpp"
  48 #if INCLUDE_ALL_GCS
  49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
  50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
  51 #include "gc_implementation/parNew/parNewGeneration.hpp"
  52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
  53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
  54 #include "gc_implementation/parallelScavenge/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) {};
  77   void do_thread(Thread* thread);
  78   int count() { return _count; }
  79 };
  80 
  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 : {


 376   G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
 377 
 378   major_mgr->add_pool(eden);
 379   major_mgr->add_pool(survivor);
 380   minor_mgr->add_pool(eden);
 381   minor_mgr->add_pool(survivor);
 382   _pools_list->append(eden);
 383   _pools_list->append(survivor);
 384 }
 385 
 386 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
 387                                              MemoryManager* mgr) {
 388   assert(mgr != NULL, "should have one manager");
 389 
 390   G1OldGenPool* old_gen = new G1OldGenPool(g1h);
 391   mgr->add_pool(old_gen);
 392   _pools_list->append(old_gen);
 393 }
 394 #endif // INCLUDE_ALL_GCS
 395 
 396 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
 397   // Create new memory pool for this heap
 398   MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */);
 399 
 400   // Append to lists
 401   _code_heap_pools->append(code_heap_pool);
 402   _pools_list->append(code_heap_pool);
 403 
 404   if (_code_cache_manager == NULL) {
 405     // Create CodeCache memory manager
 406     _code_cache_manager = MemoryManager::get_code_cache_memory_manager();
 407     _managers_list->append(_code_cache_manager);
 408   }
 409 
 410   _code_cache_manager->add_pool(code_heap_pool);

 411 }
 412 
 413 void MemoryService::add_metaspace_memory_pools() {
 414   MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
 415 
 416   _metaspace_pool = new MetaspacePool();
 417   mgr->add_pool(_metaspace_pool);
 418   _pools_list->append(_metaspace_pool);
 419 
 420   if (UseCompressedClassPointers) {
 421     _compressed_class_pool = new CompressedKlassSpacePool();
 422     mgr->add_pool(_compressed_class_pool);
 423     _pools_list->append(_compressed_class_pool);
 424   }
 425 
 426   _managers_list->append(mgr);
 427 }
 428 
 429 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
 430   for (int i = 0; i < _managers_list->length(); i++) {


src/share/vm/services/memoryService.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File