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 #ifndef SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
26 #define SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
27
28 #include "gc/parallel/parMarkBitMap.hpp"
29 #include "utilities/bitMap.inline.hpp"
30
31 inline ParMarkBitMap::ParMarkBitMap():
32 _region_start(NULL), _region_size(0), _beg_bits(), _end_bits(), _virtual_space(NULL), _reserved_byte_size(0)
33 { }
34
35 inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end) {
36 _beg_bits.clear_range(beg, end);
37 _end_bits.clear_range(beg, end);
38 }
39
40 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(size_t words) {
41 // Need two bits (one begin bit, one end bit) for each unit of 'object
42 // granularity' in the heap.
43 return words_to_bits(words * 2);
44 }
45
46 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(MemRegion covered_region) {
47 return bits_required(covered_region.word_size());
48 }
129 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
130 HeapWord* range_beg,
131 HeapWord* range_end) const {
132 return iterate(live_closure, addr_to_bit(range_beg), addr_to_bit(range_end));
133 }
134
135 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
136 ParMarkBitMapClosure* dead_closure,
137 HeapWord* range_beg,
138 HeapWord* range_end,
139 HeapWord* dead_range_end) const {
140 return iterate(live_closure, dead_closure,
141 addr_to_bit(range_beg), addr_to_bit(range_end),
142 addr_to_bit(dead_range_end));
143 }
144
145 inline bool ParMarkBitMap::mark_obj(oop obj, int size) {
146 return mark_obj((HeapWord*)obj, (size_t)size);
147 }
148
149 inline BitMap::idx_t ParMarkBitMap::addr_to_bit(HeapWord* addr) const {
150 DEBUG_ONLY(verify_addr(addr);)
151 return words_to_bits(pointer_delta(addr, region_start()));
152 }
153
154 inline HeapWord* ParMarkBitMap::bit_to_addr(idx_t bit) const {
155 DEBUG_ONLY(verify_bit(bit);)
156 return region_start() + bits_to_words(bit);
157 }
158
159 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_beg(idx_t beg, idx_t end) const {
160 return _beg_bits.get_next_one_offset_aligned_right(beg, end);
161 }
162
163 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_end(idx_t beg, idx_t end) const {
164 return _end_bits.get_next_one_offset_aligned_right(beg, end);
165 }
166
167 inline HeapWord* ParMarkBitMap::find_obj_beg(HeapWord* beg, HeapWord* end) const {
168 const idx_t beg_bit = addr_to_bit(beg);
169 const idx_t end_bit = addr_to_bit(end);
170 const idx_t search_end = BitMap::word_align_up(end_bit);
171 const idx_t res_bit = MIN2(find_obj_beg(beg_bit, search_end), end_bit);
172 return bit_to_addr(res_bit);
173 }
174
175 inline HeapWord* ParMarkBitMap::find_obj_end(HeapWord* beg, HeapWord* end) const {
176 const idx_t beg_bit = addr_to_bit(beg);
177 const idx_t end_bit = addr_to_bit(end);
178 const idx_t search_end = BitMap::word_align_up(end_bit);
179 const idx_t res_bit = MIN2(find_obj_end(beg_bit, search_end), end_bit);
180 return bit_to_addr(res_bit);
181 }
182
183 #ifdef ASSERT
184 inline void ParMarkBitMap::verify_bit(idx_t bit) const {
185 // Allow one past the last valid bit; useful for loop bounds.
186 assert(bit <= _beg_bits.size(), "bit out of range");
187 }
188
189 inline void ParMarkBitMap::verify_addr(HeapWord* addr) const {
190 // Allow one past the last valid address; useful for loop bounds.
191 assert(addr >= region_start(),
192 "addr too small, addr: " PTR_FORMAT " region start: " PTR_FORMAT, p2i(addr), p2i(region_start()));
193 assert(addr <= region_end(),
194 "addr too big, addr: " PTR_FORMAT " region end: " PTR_FORMAT, p2i(addr), p2i(region_end()));
195 }
196 #endif // #ifdef ASSERT
197
198 #endif // SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
|
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 #ifndef SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
26 #define SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
27
28 #include "gc/parallel/parMarkBitMap.hpp"
29 #include "utilities/align.hpp"
30 #include "utilities/bitMap.inline.hpp"
31
32 inline ParMarkBitMap::ParMarkBitMap():
33 _region_start(NULL), _region_size(0), _beg_bits(), _end_bits(), _virtual_space(NULL), _reserved_byte_size(0)
34 { }
35
36 inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end) {
37 _beg_bits.clear_range(beg, end);
38 _end_bits.clear_range(beg, end);
39 }
40
41 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(size_t words) {
42 // Need two bits (one begin bit, one end bit) for each unit of 'object
43 // granularity' in the heap.
44 return words_to_bits(words * 2);
45 }
46
47 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(MemRegion covered_region) {
48 return bits_required(covered_region.word_size());
49 }
130 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
131 HeapWord* range_beg,
132 HeapWord* range_end) const {
133 return iterate(live_closure, addr_to_bit(range_beg), addr_to_bit(range_end));
134 }
135
136 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
137 ParMarkBitMapClosure* dead_closure,
138 HeapWord* range_beg,
139 HeapWord* range_end,
140 HeapWord* dead_range_end) const {
141 return iterate(live_closure, dead_closure,
142 addr_to_bit(range_beg), addr_to_bit(range_end),
143 addr_to_bit(dead_range_end));
144 }
145
146 inline bool ParMarkBitMap::mark_obj(oop obj, int size) {
147 return mark_obj((HeapWord*)obj, (size_t)size);
148 }
149
150 inline ParMarkBitMap::idx_t ParMarkBitMap::addr_to_bit(HeapWord* addr) const {
151 DEBUG_ONLY(verify_addr(addr);)
152 return words_to_bits(pointer_delta(addr, region_start()));
153 }
154
155 inline HeapWord* ParMarkBitMap::bit_to_addr(idx_t bit) const {
156 DEBUG_ONLY(verify_bit(bit);)
157 return region_start() + bits_to_words(bit);
158 }
159
160 inline ParMarkBitMap::idx_t ParMarkBitMap::align_range_end(idx_t range_end) const {
161 // size is aligned, so if range_end <= size then so is aligned result.
162 assert(range_end <= size(), "range end out of range");
163 return align_up(range_end, BitsPerWord);
164 }
165
166 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_beg(idx_t beg, idx_t end) const {
167 return _beg_bits.get_next_one_offset_aligned_right(beg, end);
168 }
169
170 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_end(idx_t beg, idx_t end) const {
171 return _end_bits.get_next_one_offset_aligned_right(beg, end);
172 }
173
174 inline HeapWord* ParMarkBitMap::find_obj_beg(HeapWord* beg, HeapWord* end) const {
175 const idx_t beg_bit = addr_to_bit(beg);
176 const idx_t end_bit = addr_to_bit(end);
177 const idx_t search_end = align_range_end(end_bit);
178 const idx_t res_bit = MIN2(find_obj_beg(beg_bit, search_end), end_bit);
179 return bit_to_addr(res_bit);
180 }
181
182 inline HeapWord* ParMarkBitMap::find_obj_end(HeapWord* beg, HeapWord* end) const {
183 const idx_t beg_bit = addr_to_bit(beg);
184 const idx_t end_bit = addr_to_bit(end);
185 const idx_t search_end = align_range_end(end_bit);
186 const idx_t res_bit = MIN2(find_obj_end(beg_bit, search_end), end_bit);
187 return bit_to_addr(res_bit);
188 }
189
190 #ifdef ASSERT
191 inline void ParMarkBitMap::verify_bit(idx_t bit) const {
192 // Allow one past the last valid bit; useful for loop bounds.
193 assert(bit <= _beg_bits.size(), "bit out of range");
194 }
195
196 inline void ParMarkBitMap::verify_addr(HeapWord* addr) const {
197 // Allow one past the last valid address; useful for loop bounds.
198 assert(addr >= region_start(),
199 "addr too small, addr: " PTR_FORMAT " region start: " PTR_FORMAT, p2i(addr), p2i(region_start()));
200 assert(addr <= region_end(),
201 "addr too big, addr: " PTR_FORMAT " region end: " PTR_FORMAT, p2i(addr), p2i(region_end()));
202 }
203 #endif // #ifdef ASSERT
204
205 #endif // SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
|