29 #include "utilities/bitMap.inline.hpp"
30 #include "utilities/copy.hpp"
31 #include "utilities/debug.hpp"
32
33 STATIC_ASSERT(sizeof(BitMap::bm_word_t) == BytesPerWord); // "Implementation assumption."
34
35 typedef BitMap::bm_word_t bm_word_t;
36 typedef BitMap::idx_t idx_t;
37
38 class ResourceBitMapAllocator : StackObj {
39 public:
40 bm_word_t* allocate(idx_t size_in_words) const {
41 return NEW_RESOURCE_ARRAY(bm_word_t, size_in_words);
42 }
43 void free(bm_word_t* map, idx_t size_in_words) const {
44 // Don't free resource allocated arrays.
45 }
46 };
47
48 class CHeapBitMapAllocator : StackObj {
49 public:
50 bm_word_t* allocate(size_t size_in_words) const {
51 return ArrayAllocator<bm_word_t>::allocate(size_in_words, mtInternal);
52 }
53 void free(bm_word_t* map, idx_t size_in_words) const {
54 ArrayAllocator<bm_word_t>::free(map, size_in_words);
55 }
56 };
57
58 class ArenaBitMapAllocator : StackObj {
59 Arena* _arena;
60
61 public:
62 ArenaBitMapAllocator(Arena* arena) : _arena(arena) {}
63 bm_word_t* allocate(idx_t size_in_words) const {
64 return (bm_word_t*)_arena->Amalloc(size_in_words * BytesPerWord);
65 }
66 void free(bm_word_t* map, idx_t size_in_words) const {
67 // ArenaBitMaps currently don't free memory.
68 }
69 };
70
71 template <class Allocator>
131 ResourceBitMap::ResourceBitMap(idx_t size_in_bits)
132 : BitMap(allocate(ResourceBitMapAllocator(), size_in_bits), size_in_bits) {
133 }
134
135 void ResourceBitMap::resize(idx_t new_size_in_bits) {
136 BitMap::resize(ResourceBitMapAllocator(), new_size_in_bits);
137 }
138
139 void ResourceBitMap::initialize(idx_t size_in_bits) {
140 BitMap::initialize(ResourceBitMapAllocator(), size_in_bits);
141 }
142
143 void ResourceBitMap::reinitialize(idx_t size_in_bits) {
144 BitMap::reinitialize(ResourceBitMapAllocator(), size_in_bits);
145 }
146
147 ArenaBitMap::ArenaBitMap(Arena* arena, idx_t size_in_bits)
148 : BitMap(allocate(ArenaBitMapAllocator(arena), size_in_bits), size_in_bits) {
149 }
150
151 CHeapBitMap::CHeapBitMap(idx_t size_in_bits)
152 : BitMap(allocate(CHeapBitMapAllocator(), size_in_bits), size_in_bits) {
153 }
154
155 CHeapBitMap::~CHeapBitMap() {
156 free(CHeapBitMapAllocator(), map(), size());
157 }
158
159 void CHeapBitMap::resize(idx_t new_size_in_bits) {
160 BitMap::resize(CHeapBitMapAllocator(), new_size_in_bits);
161 }
162
163 void CHeapBitMap::initialize(idx_t size_in_bits) {
164 BitMap::initialize(CHeapBitMapAllocator(), size_in_bits);
165 }
166
167 void CHeapBitMap::reinitialize(idx_t size_in_bits) {
168 BitMap::reinitialize(CHeapBitMapAllocator(), size_in_bits);
169 }
170
171 #ifdef ASSERT
172 void BitMap::verify_index(idx_t index) const {
173 assert(index < _size, "BitMap index out of bounds");
174 }
175
176 void BitMap::verify_range(idx_t beg_index, idx_t end_index) const {
177 assert(beg_index <= end_index, "BitMap range error");
178 // Note that [0,0) and [size,size) are both valid ranges.
179 if (end_index != _size) verify_index(end_index);
180 }
181 #endif // #ifdef ASSERT
182
183 void BitMap::pretouch() {
184 os::pretouch_memory(word_addr(0), word_addr(size()));
185 }
186
187 void BitMap::set_range_within_word(idx_t beg, idx_t end) {
188 // With a valid range (beg <= end), this test ensures that end != 0, as
|
29 #include "utilities/bitMap.inline.hpp"
30 #include "utilities/copy.hpp"
31 #include "utilities/debug.hpp"
32
33 STATIC_ASSERT(sizeof(BitMap::bm_word_t) == BytesPerWord); // "Implementation assumption."
34
35 typedef BitMap::bm_word_t bm_word_t;
36 typedef BitMap::idx_t idx_t;
37
38 class ResourceBitMapAllocator : StackObj {
39 public:
40 bm_word_t* allocate(idx_t size_in_words) const {
41 return NEW_RESOURCE_ARRAY(bm_word_t, size_in_words);
42 }
43 void free(bm_word_t* map, idx_t size_in_words) const {
44 // Don't free resource allocated arrays.
45 }
46 };
47
48 class CHeapBitMapAllocator : StackObj {
49 private:
50 MEMFLAGS _flags;
51
52 public:
53 CHeapBitMapAllocator(MEMFLAGS flags) : _flags(flags) {}
54 bm_word_t* allocate(size_t size_in_words) const {
55 return ArrayAllocator<bm_word_t>::allocate(size_in_words, _flags);
56 }
57 void free(bm_word_t* map, idx_t size_in_words) const {
58 ArrayAllocator<bm_word_t>::free(map, size_in_words);
59 }
60 };
61
62 class ArenaBitMapAllocator : StackObj {
63 Arena* _arena;
64
65 public:
66 ArenaBitMapAllocator(Arena* arena) : _arena(arena) {}
67 bm_word_t* allocate(idx_t size_in_words) const {
68 return (bm_word_t*)_arena->Amalloc(size_in_words * BytesPerWord);
69 }
70 void free(bm_word_t* map, idx_t size_in_words) const {
71 // ArenaBitMaps currently don't free memory.
72 }
73 };
74
75 template <class Allocator>
135 ResourceBitMap::ResourceBitMap(idx_t size_in_bits)
136 : BitMap(allocate(ResourceBitMapAllocator(), size_in_bits), size_in_bits) {
137 }
138
139 void ResourceBitMap::resize(idx_t new_size_in_bits) {
140 BitMap::resize(ResourceBitMapAllocator(), new_size_in_bits);
141 }
142
143 void ResourceBitMap::initialize(idx_t size_in_bits) {
144 BitMap::initialize(ResourceBitMapAllocator(), size_in_bits);
145 }
146
147 void ResourceBitMap::reinitialize(idx_t size_in_bits) {
148 BitMap::reinitialize(ResourceBitMapAllocator(), size_in_bits);
149 }
150
151 ArenaBitMap::ArenaBitMap(Arena* arena, idx_t size_in_bits)
152 : BitMap(allocate(ArenaBitMapAllocator(arena), size_in_bits), size_in_bits) {
153 }
154
155 CHeapBitMap::CHeapBitMap(idx_t size_in_bits, MEMFLAGS flags)
156 : BitMap(allocate(CHeapBitMapAllocator(flags), size_in_bits), size_in_bits), _flags(flags) {
157 }
158
159 CHeapBitMap::CHeapBitMap(idx_t size_in_bits)
160 : BitMap(allocate(CHeapBitMapAllocator(mtInternal), size_in_bits), size_in_bits), _flags(mtInternal) {
161 }
162
163 CHeapBitMap::~CHeapBitMap() {
164 free(CHeapBitMapAllocator(_flags), map(), size());
165 }
166
167 void CHeapBitMap::resize(idx_t new_size_in_bits) {
168 BitMap::resize(CHeapBitMapAllocator(_flags), new_size_in_bits);
169 }
170
171 void CHeapBitMap::initialize(idx_t size_in_bits) {
172 BitMap::initialize(CHeapBitMapAllocator(_flags), size_in_bits);
173 }
174
175 void CHeapBitMap::reinitialize(idx_t size_in_bits) {
176 BitMap::reinitialize(CHeapBitMapAllocator(_flags), size_in_bits);
177 }
178
179 #ifdef ASSERT
180 void BitMap::verify_index(idx_t index) const {
181 assert(index < _size, "BitMap index out of bounds");
182 }
183
184 void BitMap::verify_range(idx_t beg_index, idx_t end_index) const {
185 assert(beg_index <= end_index, "BitMap range error");
186 // Note that [0,0) and [size,size) are both valid ranges.
187 if (end_index != _size) verify_index(end_index);
188 }
189 #endif // #ifdef ASSERT
190
191 void BitMap::pretouch() {
192 os::pretouch_memory(word_addr(0), word_addr(size()));
193 }
194
195 void BitMap::set_range_within_word(idx_t beg, idx_t end) {
196 // With a valid range (beg <= end), this test ensures that end != 0, as
|