132     }
 133   }
 134 }
 135 
 136 // Minimum region size; we won't go lower than that.
 137 // We might want to decrease this in the future, to deal with small
 138 // heaps a bit more efficiently.
 139 #define MIN_REGION_SIZE  (      1024 * 1024 )
 140 
 141 // Maximum region size; we don't go higher than that. There's a good
 142 // reason for having an upper bound. We don't want regions to get too
 143 // large, otherwise cleanup's effectiveness would decrease as there
 144 // will be fewer opportunities to find totally empty regions after
 145 // marking.
 146 #define MAX_REGION_SIZE  ( 32 * 1024 * 1024 )
 147 
 148 // The automatic region size calculation will try to have around this
 149 // many regions in the heap (based on the min heap size).
 150 #define TARGET_REGION_NUMBER          2048
 151 
 152 void HeapRegion::setup_heap_region_size(uintx min_heap_size) {
 153   // region_size in bytes
 154   uintx region_size = G1HeapRegionSize;
 155   if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
 156     // We base the automatic calculation on the min heap size. This
 157     // can be problematic if the spread between min and max is quite
 158     // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on
 159     // the max size, the region size might be way too large for the
 160     // min size. Either way, some users might have to set the region
 161     // size manually for some -Xms / -Xmx combos.
 162 
 163     region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER,
 164                        (uintx) MIN_REGION_SIZE);
 165   }
 166 
 167   int region_size_log = log2_long((jlong) region_size);
 168   // Recalculate the region size to make sure it's a power of
 169   // 2. This means that region_size is the largest power of 2 that's
 170   // <= what we've calculated so far.
 171   region_size = ((uintx)1 << region_size_log);
 172 
 173   // Now make sure that we don't go over or under our limits.
 174   if (region_size < MIN_REGION_SIZE) {
 175     region_size = MIN_REGION_SIZE;
 176   } else if (region_size > MAX_REGION_SIZE) {
 177     region_size = MAX_REGION_SIZE;
 178   }
 179 
 180   if (region_size != G1HeapRegionSize) {
 181     // Update the flag to make sure that PrintFlagsFinal logs the correct value
 182     FLAG_SET_ERGO(uintx, G1HeapRegionSize, region_size);
 183   }

 132     }
 133   }
 134 }
 135 
 136 // Minimum region size; we won't go lower than that.
 137 // We might want to decrease this in the future, to deal with small
 138 // heaps a bit more efficiently.
 139 #define MIN_REGION_SIZE  (      1024 * 1024 )
 140 
 141 // Maximum region size; we don't go higher than that. There's a good
 142 // reason for having an upper bound. We don't want regions to get too
 143 // large, otherwise cleanup's effectiveness would decrease as there
 144 // will be fewer opportunities to find totally empty regions after
 145 // marking.
 146 #define MAX_REGION_SIZE  ( 32 * 1024 * 1024 )
 147 
 148 // The automatic region size calculation will try to have around this
 149 // many regions in the heap (based on the min heap size).
 150 #define TARGET_REGION_NUMBER          2048
 151 
 152 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {

 153   uintx region_size = G1HeapRegionSize;
 154   if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
 155     size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
 156     region_size = MAX2(average_heap_size / TARGET_REGION_NUMBER,






 157                        (uintx) MIN_REGION_SIZE);
 158   }
 159 
 160   int region_size_log = log2_long((jlong) region_size);
 161   // Recalculate the region size to make sure it's a power of
 162   // 2. This means that region_size is the largest power of 2 that's
 163   // <= what we've calculated so far.
 164   region_size = ((uintx)1 << region_size_log);
 165 
 166   // Now make sure that we don't go over or under our limits.
 167   if (region_size < MIN_REGION_SIZE) {
 168     region_size = MIN_REGION_SIZE;
 169   } else if (region_size > MAX_REGION_SIZE) {
 170     region_size = MAX_REGION_SIZE;
 171   }
 172 
 173   if (region_size != G1HeapRegionSize) {
 174     // Update the flag to make sure that PrintFlagsFinal logs the correct value
 175     FLAG_SET_ERGO(uintx, G1HeapRegionSize, region_size);
 176   }