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

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







 397 
 398   _pools_list->append(_code_heap_pool);
 399   _managers_list->append(mgr);
 400 }
 401 
 402 void MemoryService::add_metaspace_memory_pools() {
 403   MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
 404 
 405   _metaspace_pool = new MetaspacePool();
 406   mgr->add_pool(_metaspace_pool);
 407   _pools_list->append(_metaspace_pool);
 408 
 409   if (UseCompressedClassPointers) {
 410     _compressed_class_pool = new CompressedKlassSpacePool();
 411     mgr->add_pool(_compressed_class_pool);
 412     _pools_list->append(_compressed_class_pool);
 413   }
 414 
 415   _managers_list->append(mgr);
 416 }
 417 
 418 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
 419   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 : {

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

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