< prev index next >

src/hotspot/share/gc/shared/genCollectedHeap.cpp

Print this page

  37 #include "gc/shared/adaptiveSizePolicy.hpp"
  38 #include "gc/shared/cardTableBarrierSet.hpp"
  39 #include "gc/shared/collectedHeap.inline.hpp"
  40 #include "gc/shared/collectorCounters.hpp"
  41 #include "gc/shared/continuationGCSupport.inline.hpp"
  42 #include "gc/shared/gcId.hpp"
  43 #include "gc/shared/gcInitLogger.hpp"
  44 #include "gc/shared/gcLocker.hpp"
  45 #include "gc/shared/gcPolicyCounters.hpp"
  46 #include "gc/shared/gcTrace.hpp"
  47 #include "gc/shared/gcTraceTime.inline.hpp"
  48 #include "gc/shared/gcVMOperations.hpp"
  49 #include "gc/shared/genArguments.hpp"
  50 #include "gc/shared/genCollectedHeap.hpp"
  51 #include "gc/shared/generationSpec.hpp"
  52 #include "gc/shared/locationPrinter.inline.hpp"
  53 #include "gc/shared/oopStorage.inline.hpp"
  54 #include "gc/shared/oopStorageParState.inline.hpp"
  55 #include "gc/shared/oopStorageSet.inline.hpp"
  56 #include "gc/shared/scavengableNMethods.hpp"

  57 #include "gc/shared/space.hpp"
  58 #include "gc/shared/strongRootsScope.hpp"
  59 #include "gc/shared/weakProcessor.hpp"
  60 #include "gc/shared/workerThread.hpp"
  61 #include "memory/iterator.hpp"
  62 #include "memory/metaspaceCounters.hpp"
  63 #include "memory/metaspaceUtils.hpp"
  64 #include "memory/resourceArea.hpp"
  65 #include "memory/universe.hpp"
  66 #include "oops/oop.inline.hpp"
  67 #include "runtime/handles.hpp"
  68 #include "runtime/handles.inline.hpp"
  69 #include "runtime/java.hpp"
  70 #include "runtime/threads.hpp"
  71 #include "runtime/vmThread.hpp"
  72 #include "services/memoryService.hpp"
  73 #include "utilities/autoRestore.hpp"
  74 #include "utilities/debug.hpp"
  75 #include "utilities/formatBuffer.hpp"
  76 #include "utilities/macros.hpp"

 115     return JNI_ENOMEM;
 116   }
 117 
 118   initialize_reserved_region(heap_rs);
 119 
 120   ReservedSpace young_rs = heap_rs.first_part(_young_gen_spec->max_size());
 121   ReservedSpace old_rs = heap_rs.last_part(_young_gen_spec->max_size());
 122 
 123   _rem_set = create_rem_set(heap_rs.region());
 124   _rem_set->initialize(young_rs.base(), old_rs.base());
 125 
 126   CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set);
 127   bs->initialize();
 128   BarrierSet::set_barrier_set(bs);
 129 
 130   _young_gen = _young_gen_spec->init(young_rs, rem_set());
 131   _old_gen = _old_gen_spec->init(old_rs, rem_set());
 132 
 133   GCInitLogger::print();
 134 


 135   return JNI_OK;
 136 }
 137 
 138 CardTableRS* GenCollectedHeap::create_rem_set(const MemRegion& reserved_region) {
 139   return new CardTableRS(reserved_region);
 140 }
 141 
 142 void GenCollectedHeap::initialize_size_policy(size_t init_eden_size,
 143                                               size_t init_promo_size,
 144                                               size_t init_survivor_size) {
 145   const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
 146   _size_policy = new AdaptiveSizePolicy(init_eden_size,
 147                                         init_promo_size,
 148                                         init_survivor_size,
 149                                         max_gc_pause_sec,
 150                                         GCTimeRatio);
 151 }
 152 
 153 ReservedHeapSpace GenCollectedHeap::allocate(size_t alignment) {
 154   // Now figure out the total size.

  37 #include "gc/shared/adaptiveSizePolicy.hpp"
  38 #include "gc/shared/cardTableBarrierSet.hpp"
  39 #include "gc/shared/collectedHeap.inline.hpp"
  40 #include "gc/shared/collectorCounters.hpp"
  41 #include "gc/shared/continuationGCSupport.inline.hpp"
  42 #include "gc/shared/gcId.hpp"
  43 #include "gc/shared/gcInitLogger.hpp"
  44 #include "gc/shared/gcLocker.hpp"
  45 #include "gc/shared/gcPolicyCounters.hpp"
  46 #include "gc/shared/gcTrace.hpp"
  47 #include "gc/shared/gcTraceTime.inline.hpp"
  48 #include "gc/shared/gcVMOperations.hpp"
  49 #include "gc/shared/genArguments.hpp"
  50 #include "gc/shared/genCollectedHeap.hpp"
  51 #include "gc/shared/generationSpec.hpp"
  52 #include "gc/shared/locationPrinter.inline.hpp"
  53 #include "gc/shared/oopStorage.inline.hpp"
  54 #include "gc/shared/oopStorageParState.inline.hpp"
  55 #include "gc/shared/oopStorageSet.inline.hpp"
  56 #include "gc/shared/scavengableNMethods.hpp"
  57 #include "gc/shared/slidingForwarding.hpp"
  58 #include "gc/shared/space.hpp"
  59 #include "gc/shared/strongRootsScope.hpp"
  60 #include "gc/shared/weakProcessor.hpp"
  61 #include "gc/shared/workerThread.hpp"
  62 #include "memory/iterator.hpp"
  63 #include "memory/metaspaceCounters.hpp"
  64 #include "memory/metaspaceUtils.hpp"
  65 #include "memory/resourceArea.hpp"
  66 #include "memory/universe.hpp"
  67 #include "oops/oop.inline.hpp"
  68 #include "runtime/handles.hpp"
  69 #include "runtime/handles.inline.hpp"
  70 #include "runtime/java.hpp"
  71 #include "runtime/threads.hpp"
  72 #include "runtime/vmThread.hpp"
  73 #include "services/memoryService.hpp"
  74 #include "utilities/autoRestore.hpp"
  75 #include "utilities/debug.hpp"
  76 #include "utilities/formatBuffer.hpp"
  77 #include "utilities/macros.hpp"

 116     return JNI_ENOMEM;
 117   }
 118 
 119   initialize_reserved_region(heap_rs);
 120 
 121   ReservedSpace young_rs = heap_rs.first_part(_young_gen_spec->max_size());
 122   ReservedSpace old_rs = heap_rs.last_part(_young_gen_spec->max_size());
 123 
 124   _rem_set = create_rem_set(heap_rs.region());
 125   _rem_set->initialize(young_rs.base(), old_rs.base());
 126 
 127   CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set);
 128   bs->initialize();
 129   BarrierSet::set_barrier_set(bs);
 130 
 131   _young_gen = _young_gen_spec->init(young_rs, rem_set());
 132   _old_gen = _old_gen_spec->init(old_rs, rem_set());
 133 
 134   GCInitLogger::print();
 135 
 136   SlidingForwarding::initialize(_reserved, SpaceAlignment / HeapWordSize);
 137 
 138   return JNI_OK;
 139 }
 140 
 141 CardTableRS* GenCollectedHeap::create_rem_set(const MemRegion& reserved_region) {
 142   return new CardTableRS(reserved_region);
 143 }
 144 
 145 void GenCollectedHeap::initialize_size_policy(size_t init_eden_size,
 146                                               size_t init_promo_size,
 147                                               size_t init_survivor_size) {
 148   const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
 149   _size_policy = new AdaptiveSizePolicy(init_eden_size,
 150                                         init_promo_size,
 151                                         init_survivor_size,
 152                                         max_gc_pause_sec,
 153                                         GCTimeRatio);
 154 }
 155 
 156 ReservedHeapSpace GenCollectedHeap::allocate(size_t alignment) {
 157   // Now figure out the total size.
< prev index next >