269 }
270 }
271 }
272
273 // Minimum region size; we won't go lower than that.
274 // We might want to decrease this in the future, to deal with small
275 // heaps a bit more efficiently.
276 #define MIN_REGION_SIZE ( 1024 * 1024 )
277
278 // Maximum region size; we don't go higher than that. There's a good
279 // reason for having an upper bound. We don't want regions to get too
280 // large, otherwise cleanup's effectiveness would decrease as there
281 // will be fewer opportunities to find totally empty regions after
282 // marking.
283 #define MAX_REGION_SIZE ( 32 * 1024 * 1024 )
284
285 // The automatic region size calculation will try to have around this
286 // many regions in the heap (based on the min heap size).
287 #define TARGET_REGION_NUMBER 2048
288
289 void HeapRegion::setup_heap_region_size(uintx min_heap_size) {
290 // region_size in bytes
291 uintx region_size = G1HeapRegionSize;
292 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
293 // We base the automatic calculation on the min heap size. This
294 // can be problematic if the spread between min and max is quite
295 // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on
296 // the max size, the region size might be way too large for the
297 // min size. Either way, some users might have to set the region
298 // size manually for some -Xms / -Xmx combos.
299
300 region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER,
301 (uintx) MIN_REGION_SIZE);
302 }
303
304 int region_size_log = log2_long((jlong) region_size);
305 // Recalculate the region size to make sure it's a power of
306 // 2. This means that region_size is the largest power of 2 that's
307 // <= what we've calculated so far.
308 region_size = ((uintx)1 << region_size_log);
|
269 }
270 }
271 }
272
273 // Minimum region size; we won't go lower than that.
274 // We might want to decrease this in the future, to deal with small
275 // heaps a bit more efficiently.
276 #define MIN_REGION_SIZE ( 1024 * 1024 )
277
278 // Maximum region size; we don't go higher than that. There's a good
279 // reason for having an upper bound. We don't want regions to get too
280 // large, otherwise cleanup's effectiveness would decrease as there
281 // will be fewer opportunities to find totally empty regions after
282 // marking.
283 #define MAX_REGION_SIZE ( 32 * 1024 * 1024 )
284
285 // The automatic region size calculation will try to have around this
286 // many regions in the heap (based on the min heap size).
287 #define TARGET_REGION_NUMBER 2048
288
289 size_t HeapRegion::max_heap_alignment() {
290 return (size_t) MAX_REGION_SIZE;
291 }
292
293 void HeapRegion::setup_heap_region_size(uintx min_heap_size) {
294 // region_size in bytes
295 uintx region_size = G1HeapRegionSize;
296 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
297 // We base the automatic calculation on the min heap size. This
298 // can be problematic if the spread between min and max is quite
299 // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on
300 // the max size, the region size might be way too large for the
301 // min size. Either way, some users might have to set the region
302 // size manually for some -Xms / -Xmx combos.
303
304 region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER,
305 (uintx) MIN_REGION_SIZE);
306 }
307
308 int region_size_log = log2_long((jlong) region_size);
309 // Recalculate the region size to make sure it's a power of
310 // 2. This means that region_size is the largest power of 2 that's
311 // <= what we've calculated so far.
312 region_size = ((uintx)1 << region_size_log);
|