28 #include "gc/parallel/mutableSpace.hpp"

    28 #include "gc/shared/collectedHeap.hpp"

    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"

    87   CollectedHeap::Name kind = heap->kind();

    69   ResourceMark rm; // For internal allocations in GrowableArray.

    88   switch (kind) {

    70 

    89     case CollectedHeap::SerialHeap :

    71   GrowableArray<MemoryPool*> gc_mem_pools = heap->memory_pools();

    90     case CollectedHeap::CMSHeap : {

    72   _pools_list->appendAll(&gc_mem_pools);

    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 #endif // INCLUDE_ALL_GCS

   104     default: {

   105       guarantee(false, "Unrecognized kind of heap");

   106     }

   107   }

   113   if (count > 0) {

    78 

   114     _minor_gc_manager->set_num_gc_threads(count);

    79   GrowableArray<GCMemoryManager*> gc_memory_managers = heap->memory_managers();

   115     _major_gc_manager->set_num_gc_threads(count);

    80   for (int i = 0; i < gc_memory_managers.length(); i++) {

   116   }

    81     GCMemoryManager* gc_manager = gc_memory_managers.at(i);

   117 

    82 

   118   // All memory pools and memory managers are initialized.

    83     if (count > 0) {

   119   //

    84       gc_manager->set_num_gc_threads(count);

   120   _minor_gc_manager->initialize_gc_stat_info();

    85     }

   121   _major_gc_manager->initialize_gc_stat_info();

    86     gc_manager->initialize_gc_stat_info();

   122 }

    87     _managers_list->append(gc_manager);

   123 

    88   }

   124 // Add memory pools for GenCollectedHeap

    89 }

   125 // This function currently only supports two generations collected heap.

   126 // The collector for GenCollectedHeap will have two memory managers.

   127 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) {

   128   CollectorPolicy* policy = heap->collector_policy();

   129 

   130   assert(policy->is_generation_policy(), "Only support two generations");

   131   GenCollectorPolicy* gen_policy = policy->as_generation_policy();

   132   if (gen_policy != NULL) {

   133     Generation::Name kind = gen_policy->young_gen_spec()->name();

   134     switch (kind) {

   135       case Generation::DefNew:

   136         _minor_gc_manager = MemoryManager::get_copy_memory_manager();

   137         break;

   138 #if INCLUDE_ALL_GCS

   139       case Generation::ParNew:

   140         _minor_gc_manager = MemoryManager::get_parnew_memory_manager();

   141         break;

   142 #endif // INCLUDE_ALL_GCS

   143       default:

   144         guarantee(false, "Unrecognized generation spec");

   145         break;

   146     }

   147     if (policy->is_mark_sweep_policy()) {

   148       _major_gc_manager = MemoryManager::get_msc_memory_manager();

   149 #if INCLUDE_ALL_GCS

   150     } else if (policy->is_concurrent_mark_sweep_policy()) {

   151       _major_gc_manager = MemoryManager::get_cms_memory_manager();

   152 #endif // INCLUDE_ALL_GCS

   153     } else {

   154       guarantee(false, "Unknown two-gen policy");

   155     }

   156   } else {

   157     guarantee(false, "Non two-gen policy");

   158   }

   159   _managers_list->append(_minor_gc_manager);

   160   _managers_list->append(_major_gc_manager);

   161 

   162   add_generation_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);

   163   add_generation_memory_pool(heap->old_gen(), _major_gc_manager);

   164 }

   165 

   166 #if INCLUDE_ALL_GCS

   167 // Add memory pools for ParallelScavengeHeap

   168 // This function currently only supports two generations collected heap.

   169 // The collector for ParallelScavengeHeap will have two memory managers.

   170 void MemoryService::add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap) {

   171   // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.

   172   _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();

   173   _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();

   174   _managers_list->append(_minor_gc_manager);

   175   _managers_list->append(_major_gc_manager);

   176 

   177   add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);

   178   add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);

   179 }

   180 

   181 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {

   182   assert(UseG1GC, "sanity");

   183 

   184   _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager();

   185   _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager();

   186   _managers_list->append(_minor_gc_manager);

   187   _managers_list->append(_major_gc_manager);

   188 

   189   add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);

   190   add_g1OldGen_memory_pool(g1h, _major_gc_manager);

   191 }

   192 #endif // INCLUDE_ALL_GCS

   193 

   194 MemoryPool* MemoryService::add_gen(Generation* gen,

   195                                    const char* name,

   196                                    bool is_heap,

   197                                    bool support_usage_threshold) {

   198 

   199   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);

   200   GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold);

   201   _pools_list->append(pool);

   202   return (MemoryPool*) pool;

   203 }

   204 

   205 MemoryPool* MemoryService::add_space(ContiguousSpace* space,

   206                                      const char* name,

   207                                      bool is_heap,

   208                                      size_t max_size,

   209                                      bool support_usage_threshold) {

   210   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);

   211   ContiguousSpacePool* pool = new ContiguousSpacePool(space, name, type, max_size, support_usage_threshold);

   212 

   213   _pools_list->append(pool);

   214   return (MemoryPool*) pool;

   215 }

   216 

   217 MemoryPool* MemoryService::add_survivor_spaces(DefNewGeneration* young_gen,

   218                                                const char* name,

   219                                                bool is_heap,

   220                                                size_t max_size,

   221                                                bool support_usage_threshold) {

   222   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);

   223   SurvivorContiguousSpacePool* pool = new SurvivorContiguousSpacePool(young_gen, name, type, max_size, support_usage_threshold);

   224 

   225   _pools_list->append(pool);

   226   return (MemoryPool*) pool;

   227 }

   228 

   229 #if INCLUDE_ALL_GCS

   230 MemoryPool* MemoryService::add_cms_space(CompactibleFreeListSpace* space,

   231                                          const char* name,

   232                                          bool is_heap,

   233                                          size_t max_size,

   234                                          bool support_usage_threshold) {

   235   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);

   236   CompactibleFreeListSpacePool* pool = new CompactibleFreeListSpacePool(space, name, type, max_size, support_usage_threshold);

   237   _pools_list->append(pool);

   238   return (MemoryPool*) pool;

   239 }

   240 #endif // INCLUDE_ALL_GCS

   241 

   242 // Add memory pool(s) for one generation

   243 void MemoryService::add_generation_memory_pool(Generation* gen,

   244                                                MemoryManager* major_mgr,

   245                                                MemoryManager* minor_mgr) {

   246   guarantee(gen != NULL, "No generation for memory pool");

   247   Generation::Name kind = gen->kind();

   248   int index = _pools_list->length();

   249 

   250   switch (kind) {

   251     case Generation::DefNew: {

   252       assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");

   253       DefNewGeneration* young_gen = (DefNewGeneration*) gen;

   254       // Add a memory pool for each space and young gen doesn't

   255       // support low memory detection as it is expected to get filled up.

   256       MemoryPool* eden = add_space(young_gen->eden(),

   257                                    "Eden Space",

   258                                    true, /* is_heap */

   259                                    young_gen->max_eden_size(),

   260                                    false /* support_usage_threshold */);

   261       MemoryPool* survivor = add_survivor_spaces(young_gen,

   262                                                  "Survivor Space",

   263                                                  true, /* is_heap */

   264                                                  young_gen->max_survivor_size(),

   265                                                  false /* support_usage_threshold */);

   266       break;

   267     }

   268 

   269 #if INCLUDE_ALL_GCS

   270     case Generation::ParNew:

   271     {

   272       assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");

   273       // Add a memory pool for each space and young gen doesn't

   274       // support low memory detection as it is expected to get filled up.

   275       ParNewGeneration* parnew_gen = (ParNewGeneration*) gen;

   276       MemoryPool* eden = add_space(parnew_gen->eden(),

   277                                    "Par Eden Space",

   278                                    true /* is_heap */,

   279                                    parnew_gen->max_eden_size(),

   280                                    false /* support_usage_threshold */);

   281       MemoryPool* survivor = add_survivor_spaces(parnew_gen,

   282                                                  "Par Survivor Space",

   283                                                  true, /* is_heap */

   284                                                  parnew_gen->max_survivor_size(),

   285                                                  false /* support_usage_threshold */);

   286 

   287       break;

   288     }

   289 #endif // INCLUDE_ALL_GCS

   290 

   291     case Generation::MarkSweepCompact: {

   292       assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");

   293       add_gen(gen,

   294               "Tenured Gen",

   295               true, /* is_heap */

   296               true  /* support_usage_threshold */);

   297       break;

   298     }

   299 

   300 #if INCLUDE_ALL_GCS

   301     case Generation::ConcurrentMarkSweep:

   302     {

   303       assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");

   304       ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) gen;

   305       MemoryPool* pool = add_cms_space(cms->cmsSpace(),

   306                                        "CMS Old Gen",

   307                                        true, /* is_heap */

   308                                        cms->reserved().byte_size(),

   309                                        true  /* support_usage_threshold */);

   310       break;

   311     }

   312 #endif // INCLUDE_ALL_GCS

   313 

   314     default:

   315       assert(false, "should not reach here");

   316       // no memory pool added for others

   317       break;

   318   }

   319 

   320   assert(major_mgr != NULL, "Should have at least one manager");

   321   // Link managers and the memory pools together

   322   for (int i = index; i < _pools_list->length(); i++) {

   323     MemoryPool* pool = _pools_list->at(i);

   324     major_mgr->add_pool(pool);

   325     if (minor_mgr != NULL) {

   326       minor_mgr->add_pool(pool);

   327     }

   328   }

   329 }

   330 

   331 

   332 #if INCLUDE_ALL_GCS

   333 void MemoryService::add_psYoung_memory_pool(PSYoungGen* young_gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) {

   334   assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");

   335 

   336   // Add a memory pool for each space and young gen doesn't

   337   // support low memory detection as it is expected to get filled up.

   338   EdenMutableSpacePool* eden = new EdenMutableSpacePool(young_gen,

   339                                                         young_gen->eden_space(),

   340                                                         "PS Eden Space",

   341                                                         MemoryPool::Heap,

   342                                                         false /* support_usage_threshold */);

   343 

   344   SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(young_gen,

   345                                                                     "PS Survivor Space",

   346                                                                     MemoryPool::Heap,

   347                                                                     false /* support_usage_threshold */);

   348 

   349   major_mgr->add_pool(eden);

   350   major_mgr->add_pool(survivor);

   351   minor_mgr->add_pool(eden);

   352   minor_mgr->add_pool(survivor);

   353   _pools_list->append(eden);

   354   _pools_list->append(survivor);

   355 }

   356 

   357 void MemoryService::add_psOld_memory_pool(PSOldGen* old_gen, MemoryManager* mgr) {

   358   PSGenerationPool* old_gen_pool = new PSGenerationPool(old_gen,

   359                                                        "PS Old Gen",

   360                                                        MemoryPool::Heap,

   361                                                        true /* support_usage_threshold */);

   362   mgr->add_pool(old_gen_pool);

   363   _pools_list->append(old_gen_pool);

   364 }

   365 

   366 void MemoryService::add_g1YoungGen_memory_pool(G1CollectedHeap* g1h,

   367                                                MemoryManager* major_mgr,

   368                                                MemoryManager* minor_mgr) {

   369   assert(major_mgr != NULL && minor_mgr != NULL, "should have two managers");

   370 

   371   G1EdenPool* eden = new G1EdenPool(g1h);

   372   G1SurvivorPool* survivor = new G1SurvivorPool(g1h);

   373 

   374   major_mgr->add_pool(eden);

   375   major_mgr->add_pool(survivor);

   376   minor_mgr->add_pool(eden);

   377   minor_mgr->add_pool(survivor);

   378   _pools_list->append(eden);

   379   _pools_list->append(survivor);

   380 }

   381 

   382 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,

   383                                              MemoryManager* mgr) {

   384   assert(mgr != NULL, "should have one manager");

   385 

   386   G1OldGenPool* old_gen = new G1OldGenPool(g1h);

   387   mgr->add_pool(old_gen);

   388   _pools_list->append(old_gen);

   389 }

   390 #endif // INCLUDE_ALL_GCS

   466 void MemoryService::gc_begin(bool fullGC, bool recordGCBeginTime,

   165 void MemoryService::gc_begin(GCMemoryManager* manager, bool recordGCBeginTime,

   470   GCMemoryManager* mgr;

   169   manager->gc_begin(recordGCBeginTime, recordPreGCUsage, recordAccumulatedGCTime);

   471   if (fullGC) {

   472     mgr = _major_gc_manager;

   473   } else {

   474     mgr = _minor_gc_manager;

   475   }

   476   assert(mgr->is_gc_memory_manager(), "Sanity check");

   477   mgr->gc_begin(recordGCBeginTime, recordPreGCUsage, recordAccumulatedGCTime);

   488 void MemoryService::gc_end(bool fullGC, bool recordPostGCUsage,

   180 void MemoryService::gc_end(GCMemoryManager* manager, bool recordPostGCUsage,

   502   mgr->gc_end(recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,

   185   manager->gc_end(recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,

   503               countCollection, cause);

   186                   countCollection, cause);

   554 // GC manager type depends on the type of Generation. Depending on the space

   237 TraceMemoryManagerStats::TraceMemoryManagerStats(GCMemoryManager* gc_memory_manager,

   555 // availability and vm options the gc uses major gc manager or minor gc

   556 // manager or both. The type of gc manager depends on the generation kind.

   557 // For DefNew and ParNew generation doing scavenge gc uses minor gc manager (so

   558 // _fullGC is set to false ) and for other generation kinds doing

   559 // mark-sweep-compact uses major gc manager (so _fullGC is set to true).

   560 TraceMemoryManagerStats::TraceMemoryManagerStats(Generation::Name kind, GCCause::Cause cause) {

   561   switch (kind) {

   562     case Generation::DefNew:

   563 #if INCLUDE_ALL_GCS

   564     case Generation::ParNew:

   565 #endif // INCLUDE_ALL_GCS

   566       _fullGC = false;

   567       break;

   568     case Generation::MarkSweepCompact:

   569 #if INCLUDE_ALL_GCS

   570     case Generation::ConcurrentMarkSweep:

   571 #endif // INCLUDE_ALL_GCS

   572       _fullGC = true;

   573       break;

   574     default:

   575       _fullGC = false;

   576       assert(false, "Unrecognized gc generation kind.");

   577   }

   578   // this has to be called in a stop the world pause and represent

   579   // an entire gc pause, start to finish:

   580   initialize(_fullGC, cause, true, true, true, true, true, true, true);

   581 }

   582 

   583 TraceMemoryManagerStats::TraceMemoryManagerStats(bool fullGC,

   592   initialize(fullGC, cause, recordGCBeginTime, recordPreGCUsage, recordPeakUsage,

   246   initialize(gc_memory_manager, cause, recordGCBeginTime, recordPreGCUsage, recordPeakUsage,

   599 void TraceMemoryManagerStats::initialize(bool fullGC,

   253 void TraceMemoryManagerStats::initialize(GCMemoryManager* gc_memory_manager,

   608   _fullGC = fullGC;

   262   _gc_memory_manager = gc_memory_manager;

   618   MemoryService::gc_begin(_fullGC, _recordGCBeginTime, _recordAccumulatedGCTime,

   272   MemoryService::gc_begin(_gc_memory_manager, _recordGCBeginTime, _recordAccumulatedGCTime,

   623   MemoryService::gc_end(_fullGC, _recordPostGCUsage, _recordAccumulatedGCTime,

   277   MemoryService::gc_end(_gc_memory_manager, _recordPostGCUsage, _recordAccumulatedGCTime,