104 bool operator>=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
105 bool operator< (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
106 bool operator<=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
107
108 } ShenandoahSharedFlag;
109
110 typedef struct ShenandoahSharedBitmap {
111 shenandoah_padding(0);
112 volatile ShenandoahSharedValue value;
113 shenandoah_padding(1);
114
115 ShenandoahSharedBitmap() {
116 clear();
117 }
118
119 void set(uint mask) {
120 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
121 ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
122 while (true) {
123 ShenandoahSharedValue ov = Atomic::load_acquire(&value);
124 if ((ov & mask_val) != 0) {
125 // already set
126 return;
127 }
128
129 ShenandoahSharedValue nv = ov | mask_val;
130 if (Atomic::cmpxchg(&value, ov, nv) == ov) {
131 // successfully set
132 return;
133 }
134 }
135 }
136
137 void unset(uint mask) {
138 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
139 ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
140 while (true) {
141 ShenandoahSharedValue ov = Atomic::load_acquire(&value);
142 if ((ov & mask_val) == 0) {
143 // already unset
144 return;
145 }
146
147 ShenandoahSharedValue nv = ov & ~mask_val;
148 if (Atomic::cmpxchg(&value, ov, nv) == ov) {
149 // successfully unset
150 return;
151 }
152 }
153 }
154
155 void clear() {
156 Atomic::release_store_fence(&value, (ShenandoahSharedValue)0);
157 }
158
159 bool is_set(uint mask) const {
160 return !is_unset(mask);
161 }
162
163 bool is_unset(uint mask) const {
164 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
165 return (Atomic::load_acquire(&value) & (ShenandoahSharedValue) mask) == 0;
166 }
167
168 bool is_clear() const {
169 return (Atomic::load_acquire(&value)) == 0;
170 }
171
172 void set_cond(uint mask, bool val) {
173 if (val) {
174 set(mask);
175 } else {
176 unset(mask);
177 }
178 }
179
180 volatile ShenandoahSharedValue* addr_of() {
181 return &value;
182 }
185 return value;
186 }
187
188 private:
189 volatile ShenandoahSharedValue* operator&() {
190 fatal("Use addr_of() instead");
191 return nullptr;
192 }
193
194 bool operator==(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
195 bool operator!=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
196 bool operator> (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
197 bool operator>=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
198 bool operator< (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
199 bool operator<=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
200
201 } ShenandoahSharedBitmap;
202
203 template<class T>
204 struct ShenandoahSharedEnumFlag {
205 shenandoah_padding(0);
206 volatile ShenandoahSharedValue value;
207 shenandoah_padding(1);
208
209 ShenandoahSharedEnumFlag() {
210 value = 0;
211 }
212
213 void set(T v) {
214 assert (v >= 0, "sanity");
215 assert (v < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
216 Atomic::release_store_fence(&value, (ShenandoahSharedValue)v);
217 }
218
219 T get() const {
220 return (T)Atomic::load_acquire(&value);
221 }
222
223 T cmpxchg(T new_value, T expected) {
224 assert (new_value >= 0, "sanity");
225 assert (new_value < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
226 return (T)Atomic::cmpxchg(&value, (ShenandoahSharedValue)expected, (ShenandoahSharedValue)new_value);
227 }
228
229 volatile ShenandoahSharedValue* addr_of() {
230 return &value;
231 }
232
233 private:
234 volatile T* operator&() {
235 fatal("Use addr_of() instead");
236 return nullptr;
237 }
238
239 bool operator==(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
240 bool operator!=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
241 bool operator> (ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
242 bool operator>=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
243 bool operator< (ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
244 bool operator<=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
245
246 };
247
248 typedef struct ShenandoahSharedSemaphore {
249 shenandoah_padding(0);
|
104 bool operator>=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
105 bool operator< (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
106 bool operator<=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
107
108 } ShenandoahSharedFlag;
109
110 typedef struct ShenandoahSharedBitmap {
111 shenandoah_padding(0);
112 volatile ShenandoahSharedValue value;
113 shenandoah_padding(1);
114
115 ShenandoahSharedBitmap() {
116 clear();
117 }
118
119 void set(uint mask) {
120 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
121 ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
122 while (true) {
123 ShenandoahSharedValue ov = Atomic::load_acquire(&value);
124 // We require all bits of mask_val to be set
125 if ((ov & mask_val) == mask_val) {
126 // already set
127 return;
128 }
129
130 ShenandoahSharedValue nv = ov | mask_val;
131 if (Atomic::cmpxchg(&value, ov, nv) == ov) {
132 // successfully set: if value returned from cmpxchg equals ov, then nv has overwritten value.
133 return;
134 }
135 }
136 }
137
138 void unset(uint mask) {
139 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
140 ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
141 while (true) {
142 ShenandoahSharedValue ov = Atomic::load_acquire(&value);
143 if ((ov & mask_val) == 0) {
144 // already unset
145 return;
146 }
147
148 ShenandoahSharedValue nv = ov & ~mask_val;
149 if (Atomic::cmpxchg(&value, ov, nv) == ov) {
150 // successfully unset
151 return;
152 }
153 }
154 }
155
156 void clear() {
157 Atomic::release_store_fence(&value, (ShenandoahSharedValue)0);
158 }
159
160 // Returns true iff any bit set in mask is set in this.value.
161 bool is_set(uint mask) const {
162 return !is_unset(mask);
163 }
164
165 // Returns true iff all bits set in mask are set in this.value.
166 bool is_set_exactly(uint mask) const {
167 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
168 uint uvalue = Atomic::load_acquire(&value);
169 return (uvalue & mask) == mask;
170 }
171
172 // Returns true iff all bits set in mask are unset in this.value.
173 bool is_unset(uint mask) const {
174 assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
175 return (Atomic::load_acquire(&value) & (ShenandoahSharedValue) mask) == 0;
176 }
177
178 bool is_clear() const {
179 return (Atomic::load_acquire(&value)) == 0;
180 }
181
182 void set_cond(uint mask, bool val) {
183 if (val) {
184 set(mask);
185 } else {
186 unset(mask);
187 }
188 }
189
190 volatile ShenandoahSharedValue* addr_of() {
191 return &value;
192 }
195 return value;
196 }
197
198 private:
199 volatile ShenandoahSharedValue* operator&() {
200 fatal("Use addr_of() instead");
201 return nullptr;
202 }
203
204 bool operator==(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
205 bool operator!=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
206 bool operator> (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
207 bool operator>=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
208 bool operator< (ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
209 bool operator<=(ShenandoahSharedFlag& other) { fatal("Use is_set() instead"); return false; }
210
211 } ShenandoahSharedBitmap;
212
213 template<class T>
214 struct ShenandoahSharedEnumFlag {
215 typedef uint32_t EnumValueType;
216 shenandoah_padding(0);
217 volatile EnumValueType value;
218 shenandoah_padding(1);
219
220 ShenandoahSharedEnumFlag() {
221 value = 0;
222 }
223
224 void set(T v) {
225 assert (v >= 0, "sanity");
226 assert (v < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
227 Atomic::release_store_fence(&value, (EnumValueType)v);
228 }
229
230 T get() const {
231 return (T)Atomic::load_acquire(&value);
232 }
233
234 T cmpxchg(T new_value, T expected) {
235 assert (new_value >= 0, "sanity");
236 assert (new_value < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
237 return (T)Atomic::cmpxchg(&value, (EnumValueType)expected, (EnumValueType)new_value);
238 }
239
240 T xchg(T new_value) {
241 assert (new_value >= 0, "sanity");
242 assert (new_value < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
243 return (T)Atomic::xchg(&value, (EnumValueType)new_value);
244 }
245
246 volatile EnumValueType* addr_of() {
247 return &value;
248 }
249
250 private:
251 volatile T* operator&() {
252 fatal("Use addr_of() instead");
253 return nullptr;
254 }
255
256 bool operator==(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
257 bool operator!=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
258 bool operator> (ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
259 bool operator>=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
260 bool operator< (ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
261 bool operator<=(ShenandoahSharedEnumFlag& other) { fatal("Use get() instead"); return false; }
262
263 };
264
265 typedef struct ShenandoahSharedSemaphore {
266 shenandoah_padding(0);
|