1 /* 2 * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "gc/g1/g1FullCollector.inline.hpp" 26 #include "gc/g1/g1FullGCCompactionPoint.hpp" 27 #include "gc/g1/g1HeapRegion.hpp" 28 #include "gc/shared/fullGCForwarding.inline.hpp" 29 #include "gc/shared/preservedMarks.inline.hpp" 30 #include "oops/oop.inline.hpp" 31 #include "utilities/debug.hpp" 32 33 G1FullGCCompactionPoint::G1FullGCCompactionPoint(G1FullCollector* collector, PreservedMarks* preserved_stack) : 34 _collector(collector), 35 _current_region(nullptr), 36 _compaction_top(nullptr), 37 _preserved_stack(preserved_stack) { 38 _compaction_regions = new (mtGC) GrowableArray<G1HeapRegion*>(32, mtGC); 39 _compaction_region_iterator = _compaction_regions->begin(); 40 } 41 42 G1FullGCCompactionPoint::~G1FullGCCompactionPoint() { 43 delete _compaction_regions; 44 } 45 46 void G1FullGCCompactionPoint::update() { 47 if (is_initialized()) { 48 _collector->set_compaction_top(_current_region, _compaction_top); 49 } 50 } 51 52 void G1FullGCCompactionPoint::initialize_values() { 53 _compaction_top = _collector->compaction_top(_current_region); 54 } 55 56 bool G1FullGCCompactionPoint::has_regions() { 57 return !_compaction_regions->is_empty(); 58 } 59 60 bool G1FullGCCompactionPoint::is_initialized() { 61 return _current_region != nullptr; 62 } 63 64 void G1FullGCCompactionPoint::initialize(G1HeapRegion* hr) { 65 _current_region = hr; 66 initialize_values(); 67 } 68 69 G1HeapRegion* G1FullGCCompactionPoint::current_region() { 70 return *_compaction_region_iterator; 71 } 72 73 G1HeapRegion* G1FullGCCompactionPoint::next_region() { 74 G1HeapRegion* next = *(++_compaction_region_iterator); 75 assert(next != nullptr, "Must return valid region"); 76 return next; 77 } 78 79 GrowableArray<G1HeapRegion*>* G1FullGCCompactionPoint::regions() { 80 return _compaction_regions; 81 } 82 83 bool G1FullGCCompactionPoint::object_will_fit(size_t size) { 84 size_t space_left = pointer_delta(_current_region->end(), _compaction_top); 85 return size <= space_left; 86 } 87 88 void G1FullGCCompactionPoint::switch_region() { 89 // Save compaction top in the region. 90 _collector->set_compaction_top(_current_region, _compaction_top); 91 // Get the next region and re-initialize the values. 92 _current_region = next_region(); 93 initialize_values(); 94 } 95 96 void G1FullGCCompactionPoint::forward(oop object, size_t size) { 97 assert(_current_region != nullptr, "Must have been initialized"); 98 99 size_t old_size = size; 100 size_t new_size = object->copy_size(old_size, object->mark()); 101 size = cast_from_oop<HeapWord*>(object) != _compaction_top ? new_size : old_size; 102 103 // Ensure the object fit in the current region. 104 while (!object_will_fit(size)) { 105 switch_region(); 106 size = cast_from_oop<HeapWord*>(object) != _compaction_top ? new_size : old_size; 107 } 108 109 // Store a forwarding pointer if the object should be moved. 110 if (cast_from_oop<HeapWord*>(object) != _compaction_top) { 111 if (!object->is_forwarded()) { 112 preserved_stack()->push_if_necessary(object, object->mark()); 113 } 114 FullGCForwarding::forward_to(object, cast_to_oop(_compaction_top)); 115 assert(FullGCForwarding::is_forwarded(object), "must be forwarded"); 116 } else { 117 assert(!FullGCForwarding::is_forwarded(object), "must not be forwarded"); 118 } 119 120 // Update compaction values. 121 _compaction_top += size; 122 _current_region->update_bot_for_block(_compaction_top - size, _compaction_top); 123 } 124 125 void G1FullGCCompactionPoint::add(G1HeapRegion* hr) { 126 _compaction_regions->append(hr); 127 } 128 129 void G1FullGCCompactionPoint::remove_at_or_above(uint bottom) { 130 G1HeapRegion* cur = current_region(); 131 assert(cur->hrm_index() >= bottom, "Sanity!"); 132 133 int start_index = 0; 134 for (G1HeapRegion* r : *_compaction_regions) { 135 if (r->hrm_index() < bottom) { 136 start_index++; 137 } 138 } 139 140 assert(start_index >= 0, "Should have at least one region"); 141 _compaction_regions->trunc_to(start_index); 142 } 143 144 void G1FullGCCompactionPoint::add_humongous(G1HeapRegion* hr) { 145 assert(hr->is_starts_humongous(), "Sanity!"); 146 147 _collector->add_humongous_region(hr); 148 149 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 150 g1h->humongous_obj_regions_iterate(hr, 151 [&] (G1HeapRegion* r) { 152 add(r); 153 _collector->update_from_skip_compacting_to_compacting(r->hrm_index()); 154 }); 155 } 156 157 void G1FullGCCompactionPoint::forward_humongous(G1HeapRegion* hr) { 158 assert(hr->is_starts_humongous(), "Sanity!"); 159 160 oop obj = cast_to_oop(hr->bottom()); 161 size_t old_size = obj->size(); 162 size_t new_size = obj->copy_size(old_size, obj->mark()); 163 uint num_regions = (uint)G1CollectedHeap::humongous_obj_size_in_regions(new_size); 164 165 if (!has_regions()) { 166 return; 167 } 168 169 // Find contiguous compaction target regions for the humongous object. 170 uint range_begin = find_contiguous_before(hr, num_regions); 171 172 if (range_begin == UINT_MAX) { 173 // No contiguous compaction target regions found, so the object cannot be moved. 174 return; 175 } 176 177 // Preserve the mark for the humongous object as the region was initially not compacting. 178 preserved_stack()->push_if_necessary(obj, obj->mark()); 179 180 G1HeapRegion* dest_hr = _compaction_regions->at(range_begin); 181 assert(hr->bottom() != dest_hr->bottom(), "assuming actual humongous move"); 182 FullGCForwarding::forward_to(obj, cast_to_oop(dest_hr->bottom())); 183 assert(FullGCForwarding::is_forwarded(obj), "Object must be forwarded!"); 184 185 // Add the humongous object regions to the compaction point. 186 add_humongous(hr); 187 188 // Remove covered regions from compaction target candidates. 189 _compaction_regions->remove_range(range_begin, (range_begin + num_regions)); 190 191 return; 192 } 193 194 uint G1FullGCCompactionPoint::find_contiguous_before(G1HeapRegion* hr, uint num_regions) { 195 assert(num_regions > 0, "Sanity!"); 196 assert(has_regions(), "Sanity!"); 197 198 if (num_regions == 1) { 199 // If only one region, return the first region. 200 return 0; 201 } 202 203 uint contiguous_region_count = 1; 204 205 uint range_end = 1; 206 uint range_limit = (uint)_compaction_regions->length(); 207 208 for (; range_end < range_limit; range_end++) { 209 if (contiguous_region_count == num_regions) { 210 break; 211 } 212 // Check if the current region and the previous region are contiguous. 213 bool regions_are_contiguous = (_compaction_regions->at(range_end)->hrm_index() - _compaction_regions->at(range_end - 1)->hrm_index()) == 1; 214 contiguous_region_count = regions_are_contiguous ? contiguous_region_count + 1 : 1; 215 } 216 217 if (contiguous_region_count < num_regions && 218 hr->hrm_index() - _compaction_regions->at(range_end-1)->hrm_index() != 1) { 219 // We reached the end but the final region is not contiguous with the target region; 220 // no contiguous regions to move to. 221 return UINT_MAX; 222 } 223 // Return the index of the first region in the range of contiguous regions. 224 return range_end - contiguous_region_count; 225 }