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"); |