src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/gc_implementation/parallelScavenge

src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp

Print this page




  35 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
  36 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
  37 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
  38 #include "gc_implementation/shared/gcHeapSummary.hpp"
  39 #include "gc_implementation/shared/gcWhen.hpp"
  40 #include "memory/gcLocker.inline.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "runtime/handles.inline.hpp"
  43 #include "runtime/java.hpp"
  44 #include "runtime/vmThread.hpp"
  45 #include "services/memTracker.hpp"
  46 #include "utilities/vmError.hpp"
  47 
  48 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  49 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
  50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  52 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
  53 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
  54 
  55 static void trace_gen_sizes(const char* const str,
  56                             size_t og_min, size_t og_max,
  57                             size_t yg_min, size_t yg_max)
  58 {
  59   if (TracePageSizes) {
  60     tty->print_cr("%s:  " SIZE_FORMAT "," SIZE_FORMAT " "
  61                   SIZE_FORMAT "," SIZE_FORMAT " "
  62                   SIZE_FORMAT,
  63                   str,
  64                   og_min / K, og_max / K,
  65                   yg_min / K, yg_max / K,
  66                   (og_max + yg_max) / K);
  67   }
  68 }
  69 
  70 jint ParallelScavengeHeap::initialize() {
  71   CollectedHeap::pre_initialize();
  72 
  73   // Cannot be initialized until after the flags are parsed
  74   // GenerationSizer flag_parser;
  75   _collector_policy = new GenerationSizer();

  76 
  77   size_t yg_min_size = _collector_policy->min_young_gen_size();
  78   size_t yg_max_size = _collector_policy->max_young_gen_size();
  79   size_t og_min_size = _collector_policy->min_old_gen_size();
  80   size_t og_max_size = _collector_policy->max_old_gen_size();
  81 
  82   trace_gen_sizes("ps heap raw",
  83                   og_min_size, og_max_size,
  84                   yg_min_size, yg_max_size);
  85 
  86   const size_t og_page_sz = os::page_size_for_region(yg_min_size + og_min_size,
  87                                                      yg_max_size + og_max_size,
  88                                                      8);
  89 
  90   const size_t og_align = set_alignment(_old_gen_alignment,   og_page_sz);
  91   const size_t yg_align = set_alignment(_young_gen_alignment, og_page_sz);
  92 
  93   // Update sizes to reflect the selected page size(s).
  94   //
  95   // NEEDS_CLEANUP.  The default TwoGenerationCollectorPolicy uses NewRatio; it
  96   // should check UseAdaptiveSizePolicy.  Changes from generationSizer could
  97   // move to the common code.
  98   yg_min_size = align_size_up(yg_min_size, yg_align);
  99   yg_max_size = align_size_up(yg_max_size, yg_align);
 100   size_t yg_cur_size =
 101     align_size_up(_collector_policy->young_gen_size(), yg_align);
 102   yg_cur_size = MAX2(yg_cur_size, yg_min_size);
 103 
 104   og_min_size = align_size_up(og_min_size, og_align);
 105   // Align old gen size down to preserve specified heap size.
 106   assert(og_align == yg_align, "sanity");
 107   og_max_size = align_size_down(og_max_size, og_align);
 108   og_max_size = MAX2(og_max_size, og_min_size);
 109   size_t og_cur_size =
 110     align_size_down(_collector_policy->old_gen_size(), og_align);
 111   og_cur_size = MAX2(og_cur_size, og_min_size);
 112 
 113   trace_gen_sizes("ps heap rnd",
 114                   og_min_size, og_max_size,
 115                   yg_min_size, yg_max_size);
 116 
 117   const size_t heap_size = og_max_size + yg_max_size;
 118 
 119   ReservedSpace heap_rs = Universe::reserve_heap(heap_size, og_align);
 120 

 121   MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
 122 
 123   os::trace_page_sizes("ps main", og_min_size + yg_min_size,
 124                        og_max_size + yg_max_size, og_page_sz,
 125                        heap_rs.base(),
 126                        heap_rs.size());
 127   if (!heap_rs.is_reserved()) {
 128     vm_shutdown_during_initialization(
 129       "Could not reserve enough space for object heap");
 130     return JNI_ENOMEM;
 131   }
 132 
 133   _reserved = MemRegion((HeapWord*)heap_rs.base(),
 134                         (HeapWord*)(heap_rs.base() + heap_rs.size()));
 135 
 136   CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3);
 137   _barrier_set = barrier_set;
 138   oopDesc::set_bs(_barrier_set);
 139   if (_barrier_set == NULL) {
 140     vm_shutdown_during_initialization(
 141       "Could not reserve enough space for barrier set");
 142     return JNI_ENOMEM;
 143   }
 144 
 145   // Initial young gen size is 4 Mb
 146   //
 147   // XXX - what about flag_parser.young_gen_size()?
 148   const size_t init_young_size = align_size_up(4 * M, yg_align);
 149   yg_cur_size = MAX2(MIN2(init_young_size, yg_max_size), yg_cur_size);
 150 
 151   // Make up the generations
 152   // Calculate the maximum size that a generation can grow.  This
 153   // includes growth into the other generation.  Note that the
 154   // parameter _max_gen_size is kept as the maximum
 155   // size of the generation as the boundaries currently stand.
 156   // _max_gen_size is still used as that value.
 157   double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
 158   double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
 159 
 160   _gens = new AdjoiningGenerations(heap_rs,
 161                                    og_cur_size,
 162                                    og_min_size,
 163                                    og_max_size,
 164                                    yg_cur_size,
 165                                    yg_min_size,
 166                                    yg_max_size,
 167                                    yg_align);
 168 
 169   _old_gen = _gens->old_gen();
 170   _young_gen = _gens->young_gen();
 171 
 172   const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
 173   const size_t old_capacity = _old_gen->capacity_in_bytes();
 174   const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
 175   _size_policy =
 176     new PSAdaptiveSizePolicy(eden_capacity,
 177                              initial_promo_size,
 178                              young_gen()->to_space()->capacity_in_bytes(),
 179                              intra_heap_alignment(),
 180                              max_gc_pause_sec,
 181                              max_gc_minor_pause_sec,
 182                              GCTimeRatio
 183                              );
 184 
 185   assert(!UseAdaptiveGCBoundary ||
 186     (old_gen()->virtual_space()->high_boundary() ==
 187      young_gen()->virtual_space()->low_boundary()),
 188     "Boundaries must meet");
 189   // initialize the policy counters - 2 collectors, 3 generations
 190   _gc_policy_counters =
 191     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 3, _size_policy);
 192   _psh = this;
 193 
 194   // Set up the GCTaskManager
 195   _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
 196 
 197   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
 198     return JNI_ENOMEM;
 199   }




  35 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
  36 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
  37 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
  38 #include "gc_implementation/shared/gcHeapSummary.hpp"
  39 #include "gc_implementation/shared/gcWhen.hpp"
  40 #include "memory/gcLocker.inline.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "runtime/handles.inline.hpp"
  43 #include "runtime/java.hpp"
  44 #include "runtime/vmThread.hpp"
  45 #include "services/memTracker.hpp"
  46 #include "utilities/vmError.hpp"
  47 
  48 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  49 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
  50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
  51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
  52 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
  53 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
  54 















  55 jint ParallelScavengeHeap::initialize() {
  56   CollectedHeap::pre_initialize();
  57 
  58   // Initialize collector policy

  59   _collector_policy = new GenerationSizer();
  60   _collector_policy->initialize_all();
  61 
  62   const size_t heap_size = _collector_policy->max_heap_byte_size();










































  63 
  64   ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
  65   MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
  66 
  67   os::trace_page_sizes("ps main", _collector_policy->min_heap_byte_size(),
  68                        heap_size, generation_alignment(),
  69                        heap_rs.base(),
  70                        heap_rs.size());
  71   if (!heap_rs.is_reserved()) {
  72     vm_shutdown_during_initialization(
  73       "Could not reserve enough space for object heap");
  74     return JNI_ENOMEM;
  75   }
  76 
  77   _reserved = MemRegion((HeapWord*)heap_rs.base(),
  78                         (HeapWord*)(heap_rs.base() + heap_rs.size()));
  79 
  80   CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3);
  81   _barrier_set = barrier_set;
  82   oopDesc::set_bs(_barrier_set);
  83   if (_barrier_set == NULL) {
  84     vm_shutdown_during_initialization(
  85       "Could not reserve enough space for barrier set");
  86     return JNI_ENOMEM;
  87   }
  88 






  89   // Make up the generations
  90   // Calculate the maximum size that a generation can grow.  This
  91   // includes growth into the other generation.  Note that the
  92   // parameter _max_gen_size is kept as the maximum
  93   // size of the generation as the boundaries currently stand.
  94   // _max_gen_size is still used as that value.
  95   double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
  96   double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
  97 
  98   _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());







  99 
 100   _old_gen = _gens->old_gen();
 101   _young_gen = _gens->young_gen();
 102 
 103   const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
 104   const size_t old_capacity = _old_gen->capacity_in_bytes();
 105   const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
 106   _size_policy =
 107     new PSAdaptiveSizePolicy(eden_capacity,
 108                              initial_promo_size,
 109                              young_gen()->to_space()->capacity_in_bytes(),
 110                              _collector_policy->gen_alignment(),
 111                              max_gc_pause_sec,
 112                              max_gc_minor_pause_sec,
 113                              GCTimeRatio
 114                              );
 115 
 116   assert(!UseAdaptiveGCBoundary ||
 117     (old_gen()->virtual_space()->high_boundary() ==
 118      young_gen()->virtual_space()->low_boundary()),
 119     "Boundaries must meet");
 120   // initialize the policy counters - 2 collectors, 3 generations
 121   _gc_policy_counters =
 122     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 3, _size_policy);
 123   _psh = this;
 124 
 125   // Set up the GCTaskManager
 126   _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
 127 
 128   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
 129     return JNI_ENOMEM;
 130   }


src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File