< prev index next >

src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

Print this page




  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "code/codeCache.hpp"
  27 #include "gc/parallel/parallelArguments.hpp"
  28 #include "gc/parallel/objectStartArray.inline.hpp"
  29 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
  30 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
  31 #include "gc/parallel/psMemoryPool.hpp"
  32 #include "gc/parallel/psParallelCompact.inline.hpp"
  33 #include "gc/parallel/psPromotionManager.hpp"
  34 #include "gc/parallel/psScavenge.hpp"
  35 #include "gc/parallel/psVMOperations.hpp"
  36 #include "gc/shared/gcHeapSummary.hpp"
  37 #include "gc/shared/gcLocker.hpp"
  38 #include "gc/shared/gcWhen.hpp"
  39 #include "gc/shared/genArguments.hpp"

  40 #include "gc/shared/locationPrinter.inline.hpp"
  41 #include "gc/shared/scavengableNMethods.hpp"
  42 #include "logging/log.hpp"
  43 #include "memory/iterator.hpp"
  44 #include "memory/metaspaceCounters.hpp"
  45 #include "memory/universe.hpp"
  46 #include "oops/oop.inline.hpp"
  47 #include "runtime/handles.inline.hpp"
  48 #include "runtime/java.hpp"
  49 #include "runtime/vmThread.hpp"
  50 #include "services/memoryManager.hpp"
  51 #include "services/memTracker.hpp"
  52 #include "utilities/macros.hpp"
  53 #include "utilities/vmError.hpp"
  54 
  55 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  56 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
  57 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  58 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  59 


 116                              GenAlignment,
 117                              max_gc_pause_sec,
 118                              max_gc_minor_pause_sec,
 119                              GCTimeRatio
 120                              );
 121 
 122   assert(ParallelArguments::is_heterogeneous_heap() ||
 123          (old_gen()->virtual_space()->high_boundary() ==
 124           young_gen()->virtual_space()->low_boundary()),
 125          "Boundaries must meet");
 126   // initialize the policy counters - 2 collectors, 2 generations
 127   _gc_policy_counters =
 128     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
 129 
 130   if (!PSParallelCompact::initialize()) {
 131     return JNI_ENOMEM;
 132   }
 133 
 134   // Set up WorkGang
 135   _workers.initialize_workers();


 136 
 137   return JNI_OK;
 138 }
 139 
 140 void ParallelScavengeHeap::initialize_serviceability() {
 141 
 142   _eden_pool = new EdenMutableSpacePool(_young_gen,
 143                                         _young_gen->eden_space(),
 144                                         "PS Eden Space",
 145                                         false /* support_usage_threshold */);
 146 
 147   _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
 148                                                 "PS Survivor Space",
 149                                                 false /* support_usage_threshold */);
 150 
 151   _old_pool = new PSGenerationPool(_old_gen,
 152                                    "PS Old Gen",
 153                                    true /* support_usage_threshold */);
 154 
 155   _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");




  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "code/codeCache.hpp"
  27 #include "gc/parallel/parallelArguments.hpp"
  28 #include "gc/parallel/objectStartArray.inline.hpp"
  29 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
  30 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
  31 #include "gc/parallel/psMemoryPool.hpp"
  32 #include "gc/parallel/psParallelCompact.inline.hpp"
  33 #include "gc/parallel/psPromotionManager.hpp"
  34 #include "gc/parallel/psScavenge.hpp"
  35 #include "gc/parallel/psVMOperations.hpp"
  36 #include "gc/shared/gcHeapSummary.hpp"
  37 #include "gc/shared/gcLocker.hpp"
  38 #include "gc/shared/gcWhen.hpp"
  39 #include "gc/shared/genArguments.hpp"
  40 #include "gc/shared/initLogger.hpp"
  41 #include "gc/shared/locationPrinter.inline.hpp"
  42 #include "gc/shared/scavengableNMethods.hpp"
  43 #include "logging/log.hpp"
  44 #include "memory/iterator.hpp"
  45 #include "memory/metaspaceCounters.hpp"
  46 #include "memory/universe.hpp"
  47 #include "oops/oop.inline.hpp"
  48 #include "runtime/handles.inline.hpp"
  49 #include "runtime/java.hpp"
  50 #include "runtime/vmThread.hpp"
  51 #include "services/memoryManager.hpp"
  52 #include "services/memTracker.hpp"
  53 #include "utilities/macros.hpp"
  54 #include "utilities/vmError.hpp"
  55 
  56 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  57 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
  58 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  59 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  60 


 117                              GenAlignment,
 118                              max_gc_pause_sec,
 119                              max_gc_minor_pause_sec,
 120                              GCTimeRatio
 121                              );
 122 
 123   assert(ParallelArguments::is_heterogeneous_heap() ||
 124          (old_gen()->virtual_space()->high_boundary() ==
 125           young_gen()->virtual_space()->low_boundary()),
 126          "Boundaries must meet");
 127   // initialize the policy counters - 2 collectors, 2 generations
 128   _gc_policy_counters =
 129     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
 130 
 131   if (!PSParallelCompact::initialize()) {
 132     return JNI_ENOMEM;
 133   }
 134 
 135   // Set up WorkGang
 136   _workers.initialize_workers();
 137 
 138   InitLogger::print();
 139 
 140   return JNI_OK;
 141 }
 142 
 143 void ParallelScavengeHeap::initialize_serviceability() {
 144 
 145   _eden_pool = new EdenMutableSpacePool(_young_gen,
 146                                         _young_gen->eden_space(),
 147                                         "PS Eden Space",
 148                                         false /* support_usage_threshold */);
 149 
 150   _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
 151                                                 "PS Survivor Space",
 152                                                 false /* support_usage_threshold */);
 153 
 154   _old_pool = new PSGenerationPool(_old_gen,
 155                                    "PS Old Gen",
 156                                    true /* support_usage_threshold */);
 157 
 158   _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");


< prev index next >