1/*
2 * Copyright (c) 2017, 2019, 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#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
31inline ParMarkBitMap::ParMarkBitMap():
32 _region_start(NULL), _region_size(0), _beg_bits(), _end_bits(), _virtual_space(NULL), _reserved_byte_size(0)
33{ }
34
35inline 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
40inline 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
46inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(MemRegion covered_region) {
47 return bits_required(covered_region.word_size());
48}
49
50inline HeapWord* ParMarkBitMap::region_start() const {
51 return _region_start;
52}
53
54inline HeapWord* ParMarkBitMap::region_end() const {
55 return region_start() + region_size();
56}
57
58inline size_t ParMarkBitMap::region_size() const {
59 return _region_size;
60}
61
62inline size_t ParMarkBitMap::size() const {
63 return _beg_bits.size();
64}
65
66inline bool ParMarkBitMap::is_obj_beg(idx_t bit) const {
67 return _beg_bits.at(bit);
68}
69
70inline bool ParMarkBitMap::is_obj_end(idx_t bit) const {
71 return _end_bits.at(bit);
72}
73
74inline bool ParMarkBitMap::is_marked(idx_t bit) const {
75 return is_obj_beg(bit);
76}
77
78inline bool ParMarkBitMap::is_marked(HeapWord* addr) const {
79 return is_marked(addr_to_bit(addr));
80}
81
82inline bool ParMarkBitMap::is_marked(oop obj) const {
83 return is_marked((HeapWord*)obj);
84}
85
86inline bool ParMarkBitMap::is_unmarked(idx_t bit) const {
87 return !is_marked(bit);
88}
89
90inline bool ParMarkBitMap::is_unmarked(HeapWord* addr) const {
91 return !is_marked(addr);
92}
93
94inline bool ParMarkBitMap::is_unmarked(oop obj) const {
95 return !is_marked(obj);
96}
97
98inline size_t ParMarkBitMap::bits_to_words(idx_t bits) {
99 return bits << obj_granularity_shift();
100}
101
102inline ParMarkBitMap::idx_t ParMarkBitMap::words_to_bits(size_t words) {
103 return words >> obj_granularity_shift();
104}
105
106inline size_t ParMarkBitMap::obj_size(idx_t beg_bit, idx_t end_bit) const {
107 DEBUG_ONLY(verify_bit(beg_bit);)
108 DEBUG_ONLY(verify_bit(end_bit);)
109 return bits_to_words(end_bit - beg_bit + 1);
110}
111
112inline size_t ParMarkBitMap::obj_size(HeapWord* beg_addr, HeapWord* end_addr) const {
113 DEBUG_ONLY(verify_addr(beg_addr);)
114 DEBUG_ONLY(verify_addr(end_addr);)
115 return pointer_delta(end_addr, beg_addr) + obj_granularity();
116}
117
118inline size_t ParMarkBitMap::obj_size(idx_t beg_bit) const {
119 const idx_t end_bit = _end_bits.get_next_one_offset(beg_bit, size());
120 assert(is_marked(beg_bit), "obj not marked");
121 assert(end_bit < size(), "end bit missing");
122 return obj_size(beg_bit, end_bit);
123}
124
125inline size_t ParMarkBitMap::obj_size(HeapWord* addr) const {
126 return obj_size(addr_to_bit(addr));
127}
128
129inline 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
135inline 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
145inline bool ParMarkBitMap::mark_obj(oop obj, int size) {
146 return mark_obj((HeapWord*)obj, (size_t)size);
147}
148
149inline 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
154inline 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
159inline 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
163inline 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
167inline 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
175inline 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
184inline 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
189inline 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
199