49 int    HeapRegion::LogOfHRGrainBytes = 0;
  50 int    HeapRegion::LogOfHRGrainWords = 0;
  51 size_t HeapRegion::GrainBytes        = 0;
  52 size_t HeapRegion::GrainWords        = 0;
  53 size_t HeapRegion::CardsPerRegion    = 0;
  54 
  55 size_t HeapRegion::max_region_size() {
  56   return HeapRegionBounds::max_size();
  57 }
  58 
  59 size_t HeapRegion::min_region_size_in_words() {
  60   return HeapRegionBounds::min_size() >> LogHeapWordSize;
  61 }
  62 
  63 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
  64   size_t region_size = G1HeapRegionSize;
  65   if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
  66     size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
  67     region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
  68                        HeapRegionBounds::min_size());







  69   }
  70 
  71   int region_size_log = log2_long((jlong) region_size);
  72   // Recalculate the region size to make sure it's a power of
  73   // 2. This means that region_size is the largest power of 2 that's
  74   // <= what we've calculated so far.
  75   region_size = ((size_t)1 << region_size_log);
  76 
  77   // Now make sure that we don't go over or under our limits.
  78   if (region_size < HeapRegionBounds::min_size()) {
  79     region_size = HeapRegionBounds::min_size();
  80   } else if (region_size > HeapRegionBounds::max_size()) {
  81     region_size = HeapRegionBounds::max_size();
  82   }
  83 
  84   // And recalculate the log.
  85   region_size_log = log2_long((jlong) region_size);
  86 
  87   // Now, set up the globals.
  88   guarantee(LogOfHRGrainBytes == 0, "we should only set it once");

  49 int    HeapRegion::LogOfHRGrainBytes = 0;
  50 int    HeapRegion::LogOfHRGrainWords = 0;
  51 size_t HeapRegion::GrainBytes        = 0;
  52 size_t HeapRegion::GrainWords        = 0;
  53 size_t HeapRegion::CardsPerRegion    = 0;
  54 
  55 size_t HeapRegion::max_region_size() {
  56   return HeapRegionBounds::max_size();
  57 }
  58 
  59 size_t HeapRegion::min_region_size_in_words() {
  60   return HeapRegionBounds::min_size() >> LogHeapWordSize;
  61 }
  62 
  63 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
  64   size_t region_size = G1HeapRegionSize;
  65   if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
  66     size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
  67     region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
  68                        HeapRegionBounds::min_size());
  69     if (DumpSharedSpaces && max_heap_size >= 128*M && region_size < 8*M) {
  70       // CDS archived heap supports up to 32G heaps, with region size up to 8MB.
  71       // At CDS dump time, if we use small regions for G1, the CARC and OARC regions may end up
  72       // in the same 8MB block. At run time with a large heap, G1CollectedHeap::alloc_archive_regions
  73       // might fail because CARC and OARC will end up in the same G1 region.
  74       region_size = 8*M;
  75     }
  76   }
  77 
  78   int region_size_log = log2_long((jlong) region_size);
  79   // Recalculate the region size to make sure it's a power of
  80   // 2. This means that region_size is the largest power of 2 that's
  81   // <= what we've calculated so far.
  82   region_size = ((size_t)1 << region_size_log);
  83 
  84   // Now make sure that we don't go over or under our limits.
  85   if (region_size < HeapRegionBounds::min_size()) {
  86     region_size = HeapRegionBounds::min_size();
  87   } else if (region_size > HeapRegionBounds::max_size()) {
  88     region_size = HeapRegionBounds::max_size();
  89   }
  90 
  91   // And recalculate the log.
  92   region_size_log = log2_long((jlong) region_size);
  93 
  94   // Now, set up the globals.
  95   guarantee(LogOfHRGrainBytes == 0, "we should only set it once");