< prev index next >

src/hotspot/share/gc/serial/serialHeap.cpp

Print this page

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

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

 185     return JNI_ENOMEM;
 186   }
 187 
 188   initialize_reserved_region(heap_rs);
 189 
 190   ReservedSpace young_rs = heap_rs.first_part(MaxNewSize);
 191   ReservedSpace old_rs = heap_rs.last_part(MaxNewSize);
 192 
 193   _rem_set = new CardTableRS(heap_rs.region());
 194   _rem_set->initialize(young_rs.base(), old_rs.base());
 195 
 196   CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set);
 197   bs->initialize();
 198   BarrierSet::set_barrier_set(bs);
 199 
 200   _young_gen = new DefNewGeneration(young_rs, NewSize, MinNewSize, MaxNewSize);
 201   _old_gen = new TenuredGeneration(old_rs, OldSize, MinOldSize, MaxOldSize, rem_set());
 202 
 203   GCInitLogger::print();
 204 


 205   return JNI_OK;
 206 }
 207 
 208 ReservedHeapSpace SerialHeap::allocate(size_t alignment) {
 209   // Now figure out the total size.
 210   const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
 211   assert(alignment % pageSize == 0, "Must be");
 212 
 213   // Check for overflow.
 214   size_t total_reserved = MaxNewSize + MaxOldSize;
 215   if (total_reserved < MaxNewSize) {
 216     vm_exit_during_initialization("The size of the object heap + VM data exceeds "
 217                                   "the maximum representable size");
 218   }
 219   assert(total_reserved % alignment == 0,
 220          "Gen size; total_reserved=" SIZE_FORMAT ", alignment="
 221          SIZE_FORMAT, total_reserved, alignment);
 222 
 223   ReservedHeapSpace heap_rs = Universe::reserve_heap(total_reserved, alignment);
 224   size_t used_page_size = heap_rs.page_size();

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

 186     return JNI_ENOMEM;
 187   }
 188 
 189   initialize_reserved_region(heap_rs);
 190 
 191   ReservedSpace young_rs = heap_rs.first_part(MaxNewSize);
 192   ReservedSpace old_rs = heap_rs.last_part(MaxNewSize);
 193 
 194   _rem_set = new CardTableRS(heap_rs.region());
 195   _rem_set->initialize(young_rs.base(), old_rs.base());
 196 
 197   CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set);
 198   bs->initialize();
 199   BarrierSet::set_barrier_set(bs);
 200 
 201   _young_gen = new DefNewGeneration(young_rs, NewSize, MinNewSize, MaxNewSize);
 202   _old_gen = new TenuredGeneration(old_rs, OldSize, MinOldSize, MaxOldSize, rem_set());
 203 
 204   GCInitLogger::print();
 205 
 206   SlidingForwarding::initialize(_reserved, SpaceAlignment / HeapWordSize);
 207 
 208   return JNI_OK;
 209 }
 210 
 211 ReservedHeapSpace SerialHeap::allocate(size_t alignment) {
 212   // Now figure out the total size.
 213   const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
 214   assert(alignment % pageSize == 0, "Must be");
 215 
 216   // Check for overflow.
 217   size_t total_reserved = MaxNewSize + MaxOldSize;
 218   if (total_reserved < MaxNewSize) {
 219     vm_exit_during_initialization("The size of the object heap + VM data exceeds "
 220                                   "the maximum representable size");
 221   }
 222   assert(total_reserved % alignment == 0,
 223          "Gen size; total_reserved=" SIZE_FORMAT ", alignment="
 224          SIZE_FORMAT, total_reserved, alignment);
 225 
 226   ReservedHeapSpace heap_rs = Universe::reserve_heap(total_reserved, alignment);
 227   size_t used_page_size = heap_rs.page_size();
< prev index next >