1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "common_components/heap/ark_collector/remark_barrier.h"
17 #include "common_components/heap/ark_collector/tests/mock_barrier_collector.h"
18 #include "common_components/mutator/mutator_manager.h"
19 #include "common_components/tests/test_helper.h"
20 #include "common_components/heap/heap_manager.h"
21 #include "common_interfaces/base_runtime.h"
22
23 using namespace common;
24
25 namespace common::test {
26 class RemarkBarrierTest : public BaseTestWithScope {
27 protected:
SetUpTestCase()28 static void SetUpTestCase()
29 {
30 BaseRuntime::GetInstance()->Init();
31 }
32
TearDownTestCase()33 static void TearDownTestCase() {}
34
SetUp()35 void SetUp() override
36 {
37 MutatorManager::Instance().CreateRuntimeMutator(ThreadType::ARK_PROCESSOR);
38 }
39
TearDown()40 void TearDown() override
41 {
42 MutatorManager::Instance().DestroyRuntimeMutator(ThreadType::ARK_PROCESSOR);
43 }
44 };
45
HWTEST_F_L0(RemarkBarrierTest,ReadRefField_TEST1)46 HWTEST_F_L0(RemarkBarrierTest, ReadRefField_TEST1)
47 {
48 MockCollector collector;
49 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
50 ASSERT_TRUE(remarkBarrier != nullptr);
51
52 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
53 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
54 RefField<false> field(obj);
55
56 BaseObject *resultObj = remarkBarrier->ReadRefField(obj, field);
57 EXPECT_EQ(resultObj, obj);
58 }
59
HWTEST_F_L0(RemarkBarrierTest,ReadRefField_TEST2)60 HWTEST_F_L0(RemarkBarrierTest, ReadRefField_TEST2)
61 {
62 MockCollector collector;
63 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
64 ASSERT_TRUE(remarkBarrier != nullptr);
65
66 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
67 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
68 RefField<false> field(obj);
69
70 BaseObject *resultObj = remarkBarrier->ReadRefField(nullptr, field);
71 EXPECT_EQ(resultObj, obj);
72 }
73
HWTEST_F_L0(RemarkBarrierTest,ReadStaticRef_TEST1)74 HWTEST_F_L0(RemarkBarrierTest, ReadStaticRef_TEST1)
75 {
76 MockCollector collector;
77 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
78 ASSERT_TRUE(remarkBarrier != nullptr);
79
80 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
81 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
82 RefField<false> field(obj);
83
84 BaseObject *resultObj = remarkBarrier->ReadStaticRef(field);
85 EXPECT_EQ(resultObj, obj);
86 }
87
HWTEST_F_L0(RemarkBarrierTest,ReadStringTableStaticRef_TEST1)88 HWTEST_F_L0(RemarkBarrierTest, ReadStringTableStaticRef_TEST1)
89 {
90 MockCollector collector;
91 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
92 ASSERT_TRUE(remarkBarrier != nullptr);
93
94 RefField<false> field(nullptr);
95
96 BaseObject* resultObj = remarkBarrier->ReadStringTableStaticRef(field);
97 ASSERT_TRUE(resultObj == nullptr);
98 }
99
HWTEST_F_L0(RemarkBarrierTest,ReadStringTableStaticRef_TEST2)100 HWTEST_F_L0(RemarkBarrierTest, ReadStringTableStaticRef_TEST2)
101 {
102 MockCollector collector;
103 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
104 ASSERT_TRUE(remarkBarrier != nullptr);
105
106 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
107 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
108 RegionDesc *regionInfo = RegionDesc::GetRegionDescAt(addr);
109 regionInfo->SetRegionAllocPtr(addr - 1);
110 regionInfo->SetMarkingLine();
111 RefField<false> field(obj);
112
113 BaseObject* resultObj = remarkBarrier->ReadStringTableStaticRef(field);
114 ASSERT_TRUE(resultObj != nullptr);
115 }
116
HWTEST_F_L0(RemarkBarrierTest,ReadStringTableStaticRef_TEST3)117 HWTEST_F_L0(RemarkBarrierTest, ReadStringTableStaticRef_TEST3)
118 {
119 MockCollector collector;
120 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
121 ASSERT_TRUE(remarkBarrier != nullptr);
122
123 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
124 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
125 RegionDesc *regionInfo = RegionDesc::GetRegionDescAt(addr);
126 regionInfo->SetRegionType(RegionDesc::RegionType::ALIVE_REGION_FIRST);
127 RefField<false> field(obj);
128
129 BaseObject* resultObj = remarkBarrier->ReadStringTableStaticRef(field);
130 ASSERT_TRUE(resultObj == nullptr);
131 }
132
HWTEST_F_L0(RemarkBarrierTest,ReadStringTableStaticRef_TEST4)133 HWTEST_F_L0(RemarkBarrierTest, ReadStringTableStaticRef_TEST4)
134 {
135 MockCollector collector;
136 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
137 ASSERT_TRUE(remarkBarrier != nullptr);
138
139 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
140 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
141 RefField<false> field(obj);
142
143 Heap::GetHeap().SetGCReason(GC_REASON_YOUNG);
144 BaseObject* resultObj = remarkBarrier->ReadStringTableStaticRef(field);
145 ASSERT_TRUE(resultObj != nullptr);
146 }
147
HWTEST_F_L0(RemarkBarrierTest,ReadStruct_TEST1)148 HWTEST_F_L0(RemarkBarrierTest, ReadStruct_TEST1)
149 {
150 MockCollector collector;
151 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
152 ASSERT_TRUE(remarkBarrier != nullptr);
153
154 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
155 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
156 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
157 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
158 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
159 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
160 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
161 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
162 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
163 remarkBarrier->ReadStruct(dst, obj, src, sizeof(BaseObject));
164 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
165 }
166
HWTEST_F_L0(RemarkBarrierTest,WriteRefField_TEST1)167 HWTEST_F_L0(RemarkBarrierTest, WriteRefField_TEST1)
168 {
169 MockCollector collector;
170 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
171 ASSERT_TRUE(remarkBarrier != nullptr);
172
173 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
174 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
175 constexpr size_t oldSize = 100;
176 oldObj->SetSizeForwarded(oldSize);
177 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
178
179 RefField<false> field(oldObj);
180 BaseObject *target = field.GetTargetObject();
181 EXPECT_TRUE(target != nullptr);
182
183 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
184 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
185 constexpr size_t newSize = 200;
186 newObj->SetSizeForwarded(newSize);
187 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
188
189 remarkBarrier->WriteRefField(oldObj, field, newObj);
190
191 MAddress newAddress = field.GetFieldValue();
192 MAddress expectedAddress = RefField<>(newObj).GetFieldValue();
193 EXPECT_EQ(newAddress, expectedAddress);
194 }
195
HWTEST_F_L0(RemarkBarrierTest,WriteRefField_TEST2)196 HWTEST_F_L0(RemarkBarrierTest, WriteRefField_TEST2)
197 {
198 MockCollector collector;
199 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
200 ASSERT_TRUE(remarkBarrier != nullptr);
201
202 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
203 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
204 constexpr size_t oldSize = 100;
205 oldObj->SetSizeForwarded(oldSize);
206 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
207
208 RefField<false> field(MAddress(0));
209 BaseObject *target = field.GetTargetObject();
210 EXPECT_TRUE(target == nullptr);
211
212 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
213 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
214 constexpr size_t newSize = 200;
215 newObj->SetSizeForwarded(newSize);
216 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
217
218 remarkBarrier->WriteRefField(oldObj, field, newObj);
219
220 MAddress newAddress = field.GetFieldValue();
221 MAddress expectedAddress = RefField<>(newObj).GetFieldValue();
222 EXPECT_EQ(newAddress, expectedAddress);
223 }
224
HWTEST_F_L0(RemarkBarrierTest,WriteBarrier_TEST1)225 HWTEST_F_L0(RemarkBarrierTest, WriteBarrier_TEST1)
226 {
227 MockCollector collector;
228 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
229 ASSERT_TRUE(remarkBarrier != nullptr);
230
231 #ifndef ARK_USE_SATB_BARRIER
232 constexpr uint64_t TAG_BITS_SHIFT = 48;
233 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
234 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
235 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
236 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
237
238 RefField<> field(MAddress(0));
239 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
240 addr |= TAG_HEAP_OBJECT_MASK;
241 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
242 remarkBarrier->WriteBarrier(obj, field, obj);
243 EXPECT_TRUE(obj != nullptr);
244 #endif
245 }
246
HWTEST_F_L0(RemarkBarrierTest,WriteBarrier_TEST2)247 HWTEST_F_L0(RemarkBarrierTest, WriteBarrier_TEST2)
248 {
249 MockCollector collector;
250 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
251 ASSERT_TRUE(remarkBarrier != nullptr);
252
253 #ifdef ARK_USE_SATB_BARRIER
254 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
255 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
256 RefField<false> normalField(obj);
257 remarkBarrier->WriteBarrier(obj, normalField, obj);
258 EXPECT_TRUE(obj != nullptr);
259
260 BaseObject weakObj;
261 RefField<false> weakField(MAddress(0));
262 remarkBarrier->WriteBarrier(&weakObj, weakField, &weakObj);
263 EXPECT_TRUE(weakObj != nullptr);
264
265 BaseObject nonTaggedObj;
266 RefField<false> nonTaggedField(&nonTaggedObj);
267 remarkBarrier->WriteBarrier(nullptr, nonTaggedField, &nonTaggedObj);
268 EXPECT_TRUE(nonTaggedObj != nullptr);
269 #endif
270 }
271
HWTEST_F_L0(RemarkBarrierTest,WriteBarrier_TEST3)272 HWTEST_F_L0(RemarkBarrierTest, WriteBarrier_TEST3)
273 {
274 MockCollector collector;
275 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
276 ASSERT_TRUE(remarkBarrier != nullptr);
277
278 #ifndef ARK_USE_SATB_BARRIER
279 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
280 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
281 RefField<> field(obj);
282 remarkBarrier->WriteBarrier(obj, field, obj);
283 EXPECT_TRUE(obj != nullptr);
284 #endif
285 }
286
HWTEST_F_L0(RemarkBarrierTest,WriteStruct_TEST1)287 HWTEST_F_L0(RemarkBarrierTest, WriteStruct_TEST1)
288 {
289 MockCollector collector;
290 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
291 ASSERT_TRUE(remarkBarrier != nullptr);
292
293 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
294 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
295 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
296 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
297 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
298 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
299 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
300 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
301 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
302 remarkBarrier->WriteStruct(obj, dst, sizeof(BaseObject), src, sizeof(BaseObject));
303 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
304 }
305
HWTEST_F_L0(RemarkBarrierTest,WriteStruct_TEST2)306 HWTEST_F_L0(RemarkBarrierTest, WriteStruct_TEST2)
307 {
308 MockCollector collector;
309 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
310 ASSERT_TRUE(remarkBarrier != nullptr);
311
312 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
313 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
314 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
315 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
316 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
317 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
318 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
319 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
320 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
321
322 auto mutator = ThreadLocal::GetMutator();
323 ThreadLocal::SetMutator(nullptr);
324 remarkBarrier->WriteStruct(obj, dst, sizeof(BaseObject), src, sizeof(BaseObject));
325 ThreadLocal::SetMutator(mutator);
326 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
327 }
328
HWTEST_F_L0(RemarkBarrierTest,AtomicReadRefField_TEST1)329 HWTEST_F_L0(RemarkBarrierTest, AtomicReadRefField_TEST1)
330 {
331 MockCollector collector;
332 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
333 ASSERT_TRUE(remarkBarrier != nullptr);
334
335 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
336 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
337 constexpr size_t size = 100;
338 obj->SetSizeForwarded(size);
339 EXPECT_EQ(obj->GetSizeForwarded(), size);
340 RefField<true> field(obj);
341
342 BaseObject *resultObj = nullptr;
343 resultObj = remarkBarrier->AtomicReadRefField(obj, field, std::memory_order_seq_cst);
344 ASSERT_TRUE(resultObj != nullptr);
345 }
346
HWTEST_F_L0(RemarkBarrierTest,AtomicWriteRefField_TEST1)347 HWTEST_F_L0(RemarkBarrierTest, AtomicWriteRefField_TEST1)
348 {
349 MockCollector collector;
350 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
351 ASSERT_TRUE(remarkBarrier != nullptr);
352
353 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
354 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
355 constexpr size_t oldSize = 100;
356 oldObj->SetSizeForwarded(oldSize);
357 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
358 RefField<true> oldField(oldObj);
359 MAddress oldAddress = oldField.GetFieldValue();
360
361 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
362 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
363 constexpr size_t newSize = 200;
364 newObj->SetSizeForwarded(newSize);
365 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
366 RefField<true> newField(newObj);
367 MAddress neWAddress = newField.GetFieldValue();
368 EXPECT_NE(oldAddress, neWAddress);
369
370 remarkBarrier->AtomicWriteRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
371 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
372 }
373
HWTEST_F_L0(RemarkBarrierTest,AtomicWriteRefField_TEST2)374 HWTEST_F_L0(RemarkBarrierTest, AtomicWriteRefField_TEST2)
375 {
376 MockCollector collector;
377 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
378 ASSERT_TRUE(remarkBarrier != nullptr);
379
380 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
381 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
382 constexpr size_t oldSize = 100;
383 oldObj->SetSizeForwarded(oldSize);
384 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
385 RefField<true> oldField(oldObj);
386 MAddress oldAddress = oldField.GetFieldValue();
387
388 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
389 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
390 constexpr size_t newSize = 200;
391 newObj->SetSizeForwarded(newSize);
392 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
393 RefField<true> newField(newObj);
394 MAddress neWAddress = newField.GetFieldValue();
395 EXPECT_NE(oldAddress, neWAddress);
396
397 remarkBarrier->AtomicWriteRefField(nullptr, oldField, newObj, std::memory_order_relaxed);
398 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
399 }
400
HWTEST_F_L0(RemarkBarrierTest,AtomicSwapRefField_TEST1)401 HWTEST_F_L0(RemarkBarrierTest, AtomicSwapRefField_TEST1)
402 {
403 MockCollector collector;
404 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
405 ASSERT_TRUE(remarkBarrier != nullptr);
406
407 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
408 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
409 constexpr size_t oldSize = 100;
410 oldObj->SetSizeForwarded(oldSize);
411 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
412 RefField<true> oldField(oldObj);
413 MAddress oldAddress = oldField.GetFieldValue();
414
415 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
416 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
417 constexpr size_t newSize = 200;
418 newObj->SetSizeForwarded(newSize);
419 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
420 RefField<true> newField(newObj);
421 MAddress neWAddress = newField.GetFieldValue();
422 EXPECT_NE(oldAddress, neWAddress);
423
424 BaseObject *resultObj = nullptr;
425 resultObj = remarkBarrier->AtomicSwapRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
426 EXPECT_EQ(oldField.GetFieldValue(), newField.GetFieldValue());
427 }
428
HWTEST_F_L0(RemarkBarrierTest,CompareAndSwapRefField_TEST1)429 HWTEST_F_L0(RemarkBarrierTest, CompareAndSwapRefField_TEST1)
430 {
431 MockCollector collector;
432 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
433 ASSERT_TRUE(remarkBarrier != nullptr);
434
435 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
436 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
437 constexpr size_t oldSize = 100;
438 oldObj->SetSizeForwarded(oldSize);
439 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
440 RefField<true> oldField(oldObj);
441 MAddress oldAddress = oldField.GetFieldValue();
442
443 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
444 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
445 constexpr size_t newSize = 200;
446 newObj->SetSizeForwarded(newSize);
447 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
448 RefField<true> newField(newObj);
449 MAddress neWAddress = newField.GetFieldValue();
450 EXPECT_NE(oldAddress, neWAddress);
451
452 bool result = remarkBarrier->CompareAndSwapRefField(
453 oldObj, oldField, oldObj, newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
454 ASSERT_TRUE(result);
455 }
456
HWTEST_F_L0(RemarkBarrierTest,CompareAndSwapRefField_TEST2)457 HWTEST_F_L0(RemarkBarrierTest, CompareAndSwapRefField_TEST2)
458 {
459 MockCollector collector;
460 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
461 ASSERT_TRUE(remarkBarrier != nullptr);
462
463 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
464 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
465 constexpr size_t oldSize = 100;
466 oldObj->SetSizeForwarded(oldSize);
467 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
468 RefField<true> oldField(oldObj);
469
470 bool result = remarkBarrier->CompareAndSwapRefField(
471 oldObj, oldField, oldObj, oldObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
472 ASSERT_TRUE(result);
473 }
474
HWTEST_F_L0(RemarkBarrierTest,CompareAndSwapRefField_TEST3)475 HWTEST_F_L0(RemarkBarrierTest, CompareAndSwapRefField_TEST3)
476 {
477 MockCollector collector;
478 auto remarkBarrier = std::make_unique<RemarkBarrier>(collector);
479 ASSERT_TRUE(remarkBarrier != nullptr);
480
481 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
482 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
483 constexpr size_t oldSize = 100;
484 oldObj->SetSizeForwarded(oldSize);
485 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
486 RefField<true> oldField(oldObj);
487 MAddress oldAddress = oldField.GetFieldValue();
488
489 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
490 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
491 constexpr size_t newSize = 200;
492 newObj->SetSizeForwarded(newSize);
493 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
494 RefField<true> newField(newObj);
495 MAddress neWAddress = newField.GetFieldValue();
496 EXPECT_NE(oldAddress, neWAddress);
497
498 bool result = remarkBarrier->CompareAndSwapRefField(
499 oldObj, newField, oldObj, newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
500 ASSERT_FALSE(result);
501 }
502 } // namespace common::test
503