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 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP 27 28 #include "gc_implementation/g1/heapRegionSet.hpp" 29 30 //////////////////// HeapRegionSetBase //////////////////// 31 32 inline void HeapRegionSetBase::update_for_addition(HeapRegion* hr) { 33 // Assumes the caller has already verified the region. 34 35 _length += 1; 36 _region_num += hr->region_num(); 37 _total_used_bytes += hr->used(); 38 } 39 40 inline void HeapRegionSetBase::add_internal(HeapRegion* hr) { 41 hrs_assert_region_ok(this, hr, NULL); 42 assert(hr->next() == NULL, hrs_ext_msg(this, "should not already be linked")); 43 44 update_for_addition(hr); 45 hr->set_containing_set(this); 46 } 47 48 inline void HeapRegionSetBase::update_for_removal(HeapRegion* hr) { 49 // Assumes the caller has already verified the region. 50 assert(_length > 0, hrs_ext_msg(this, "pre-condition")); 51 _length -= 1; 52 53 uint region_num_diff = hr->region_num(); 54 assert(region_num_diff <= _region_num, 55 hrs_err_msg("[%s] region's region num: %u " 56 "should be <= region num: %u", 57 name(), region_num_diff, _region_num)); 58 _region_num -= region_num_diff; 59 60 size_t used_bytes = hr->used(); 61 assert(used_bytes <= _total_used_bytes, 62 hrs_err_msg("[%s] region's used bytes: "SIZE_FORMAT" " 63 "should be <= used bytes: "SIZE_FORMAT, 64 name(), used_bytes, _total_used_bytes)); 65 _total_used_bytes -= used_bytes; 66 } 67 68 inline void HeapRegionSetBase::remove_internal(HeapRegion* hr) { 69 hrs_assert_region_ok(this, hr, this); 70 assert(hr->next() == NULL, hrs_ext_msg(this, "should already be unlinked")); 71 72 hr->set_containing_set(NULL); 73 update_for_removal(hr); 74 } 75 76 //////////////////// HeapRegionSet //////////////////// 77 78 inline void HeapRegionSet::add(HeapRegion* hr) { 79 hrs_assert_mt_safety_ok(this); 80 // add_internal() will verify the region. 81 add_internal(hr); 82 } 83 84 inline void HeapRegionSet::remove(HeapRegion* hr) { 85 hrs_assert_mt_safety_ok(this); 86 // remove_internal() will verify the region. 87 remove_internal(hr); 88 } 89 90 inline void HeapRegionSet::remove_with_proxy(HeapRegion* hr, 91 HeapRegionSet* proxy_set) { 92 // No need to fo the MT safety check here given that this method 93 // does not update the contents of the set but instead accumulates 94 // the changes in proxy_set which is assumed to be thread-local. 95 hrs_assert_sets_match(this, proxy_set); 96 hrs_assert_region_ok(this, hr, this); 97 98 hr->set_containing_set(NULL); 99 proxy_set->update_for_addition(hr); 100 } 101 102 //////////////////// HeapRegionLinkedList //////////////////// 103 104 inline void HeapRegionLinkedList::add_as_head(HeapRegion* hr) { 105 hrs_assert_mt_safety_ok(this); 106 assert((length() == 0 && _head == NULL && _tail == NULL) || 107 (length() > 0 && _head != NULL && _tail != NULL), 108 hrs_ext_msg(this, "invariant")); 109 // add_internal() will verify the region. 110 add_internal(hr); 111 112 // Now link the region. 113 if (_head != NULL) { 114 hr->set_next(_head); 115 } else { 116 _tail = hr; 117 } 118 _head = hr; 119 } 120 121 inline void HeapRegionLinkedList::add_as_tail(HeapRegion* hr) { 122 hrs_assert_mt_safety_ok(this); 123 assert((length() == 0 && _head == NULL && _tail == NULL) || 124 (length() > 0 && _head != NULL && _tail != NULL), 125 hrs_ext_msg(this, "invariant")); 126 // add_internal() will verify the region. 127 add_internal(hr); 128 129 // Now link the region. 130 if (_tail != NULL) { 131 _tail->set_next(hr); 132 } else { 133 _head = hr; 134 } 135 _tail = hr; 136 } 137 138 inline HeapRegion* HeapRegionLinkedList::remove_head() { 139 hrs_assert_mt_safety_ok(this); 140 assert(!is_empty(), hrs_ext_msg(this, "the list should not be empty")); 141 assert(length() > 0 && _head != NULL && _tail != NULL, 142 hrs_ext_msg(this, "invariant")); 143 144 // We need to unlink it first. 145 HeapRegion* hr = _head; 146 _head = hr->next(); 147 if (_head == NULL) { 148 _tail = NULL; 149 } 150 hr->set_next(NULL); 151 152 // remove_internal() will verify the region. 153 remove_internal(hr); 154 return hr; 155 } 156 157 inline HeapRegion* HeapRegionLinkedList::remove_head_or_null() { 158 hrs_assert_mt_safety_ok(this); 159 160 if (!is_empty()) { 161 return remove_head(); 162 } else { 163 return NULL; 164 } 165 } 166 167 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP | 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 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP 27 28 #include "gc_implementation/g1/heapRegionSet.hpp" 29 30 //////////////////// HeapRegionSetBase //////////////////// 31 32 inline void HeapRegionSetBase::add(HeapRegion* hr) { 33 check_mt_safety(); 34 assert(hr->containing_set() == NULL, hrs_ext_msg(this, "should not already have a containing set %u")); 35 assert(hr->next() == NULL, hrs_ext_msg(this, "should not already be linked")); 36 37 _count.increment(1u, hr->capacity()); 38 hr->set_containing_set(this); 39 verify_region(hr); 40 } 41 42 inline void HeapRegionSetBase::remove(HeapRegion* hr) { 43 check_mt_safety(); 44 verify_region(hr); 45 assert(hr->next() == NULL, hrs_ext_msg(this, "should already be unlinked")); 46 47 hr->set_containing_set(NULL); 48 assert(_count.length() > 0, hrs_ext_msg(this, "pre-condition")); 49 _count.decrement(1u, hr->capacity()); 50 } 51 52 //////////////////// HeapRegionLinkedList //////////////////// 53 54 inline void FreeRegionList::add_as_head(HeapRegion* hr) { 55 assert((length() == 0 && _head == NULL && _tail == NULL) || 56 (length() > 0 && _head != NULL && _tail != NULL), 57 hrs_ext_msg(this, "invariant")); 58 // add() will verify the region and check mt safety. 59 add(hr); 60 61 // Now link the region. 62 if (_head != NULL) { 63 hr->set_next(_head); 64 } else { 65 _tail = hr; 66 } 67 _head = hr; 68 } 69 70 inline void FreeRegionList::add_as_tail(HeapRegion* hr) { 71 check_mt_safety(); 72 assert((length() == 0 && _head == NULL && _tail == NULL) || 73 (length() > 0 && _head != NULL && _tail != NULL), 74 hrs_ext_msg(this, "invariant")); 75 // add() will verify the region and check mt safety 76 add(hr); 77 78 // Now link the region. 79 if (_tail != NULL) { 80 _tail->set_next(hr); 81 } else { 82 _head = hr; 83 } 84 _tail = hr; 85 } 86 87 inline HeapRegion* FreeRegionList::remove_head() { 88 assert(!is_empty(), hrs_ext_msg(this, "the list should not be empty")); 89 assert(length() > 0 && _head != NULL && _tail != NULL, 90 hrs_ext_msg(this, "invariant")); 91 92 // We need to unlink it first. 93 HeapRegion* hr = _head; 94 _head = hr->next(); 95 if (_head == NULL) { 96 _tail = NULL; 97 } 98 hr->set_next(NULL); 99 100 // remove() will verify the region and check mt safety 101 remove(hr); 102 return hr; 103 } 104 105 inline HeapRegion* FreeRegionList::remove_head_or_null() { 106 if (!is_empty()) { 107 return remove_head(); 108 } else { 109 return NULL; 110 } 111 } 112 113 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP |