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/marking_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 MarkingBarrierTest : 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(MarkingBarrierTest,ReadRefField_TEST1)46 HWTEST_F_L0(MarkingBarrierTest, ReadRefField_TEST1)
47 {
48 MockCollector collector;
49 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
50 ASSERT_TRUE(markingBarrier != 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 = markingBarrier->ReadRefField(obj, field);
57 EXPECT_EQ(resultObj, obj);
58 }
59
HWTEST_F_L0(MarkingBarrierTest,ReadRefField_TEST2)60 HWTEST_F_L0(MarkingBarrierTest, ReadRefField_TEST2)
61 {
62 MockCollector collector;
63 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
64 ASSERT_TRUE(markingBarrier != 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 = markingBarrier->ReadRefField(nullptr, field);
71 EXPECT_EQ(resultObj, obj);
72 }
73
HWTEST_F_L0(MarkingBarrierTest,ReadStaticRef_TEST1)74 HWTEST_F_L0(MarkingBarrierTest, ReadStaticRef_TEST1)
75 {
76 MockCollector collector;
77 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
78 ASSERT_TRUE(markingBarrier != 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 = markingBarrier->ReadStaticRef(field);
85 EXPECT_EQ(resultObj, obj);
86 }
87
HWTEST_F_L0(MarkingBarrierTest,ReadStruct_TEST1)88 HWTEST_F_L0(MarkingBarrierTest, ReadStruct_TEST1)
89 {
90 MockCollector collector;
91 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
92 ASSERT_TRUE(markingBarrier != nullptr);
93
94 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
95 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
96 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
97 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
98 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
99 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
100 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
101 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
102 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
103 markingBarrier->ReadStruct(dst, obj, src, sizeof(BaseObject));
104 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
105 }
106
HWTEST_F_L0(MarkingBarrierTest,WriteRefField_TEST1)107 HWTEST_F_L0(MarkingBarrierTest, WriteRefField_TEST1)
108 {
109 MockCollector collector;
110 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
111 ASSERT_TRUE(markingBarrier != nullptr);
112
113 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
114 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
115 constexpr size_t oldSize = 100;
116 oldObj->SetSizeForwarded(oldSize);
117 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
118
119 RefField<false> field(oldObj);
120 BaseObject *target = field.GetTargetObject();
121 EXPECT_TRUE(target != nullptr);
122
123 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
124 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
125 constexpr size_t newSize = 200;
126 newObj->SetSizeForwarded(newSize);
127 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
128
129 markingBarrier->WriteRefField(oldObj, field, newObj);
130
131 MAddress newAddress = field.GetFieldValue();
132 MAddress expectedAddress = RefField<>(newObj).GetFieldValue();
133 EXPECT_EQ(newAddress, expectedAddress);
134 }
135
HWTEST_F_L0(MarkingBarrierTest,WriteRefField_TEST2)136 HWTEST_F_L0(MarkingBarrierTest, WriteRefField_TEST2)
137 {
138 MockCollector collector;
139 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
140 ASSERT_TRUE(markingBarrier != nullptr);
141
142 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
143 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
144 constexpr size_t oldSize = 100;
145 oldObj->SetSizeForwarded(oldSize);
146 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
147
148 RefField<false> field(MAddress(0));
149 BaseObject *target = field.GetTargetObject();
150 EXPECT_TRUE(target == nullptr);
151
152 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
153 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
154 constexpr size_t newSize = 200;
155 newObj->SetSizeForwarded(newSize);
156 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
157
158 markingBarrier->WriteRefField(oldObj, field, newObj);
159
160 MAddress newAddress = field.GetFieldValue();
161 MAddress expectedAddress = RefField<>(newObj).GetFieldValue();
162 EXPECT_EQ(newAddress, expectedAddress);
163 }
164
HWTEST_F_L0(MarkingBarrierTest,WriteBarrier_TEST1)165 HWTEST_F_L0(MarkingBarrierTest, WriteBarrier_TEST1)
166 {
167 MockCollector collector;
168 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
169 ASSERT_TRUE(markingBarrier != nullptr);
170
171 #ifndef ARK_USE_SATB_BARRIER
172 constexpr uint64_t TAG_BITS_SHIFT = 48;
173 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
174 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
175 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
176 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
177
178 RefField<> field(MAddress(0));
179 markingBarrier->WriteBarrier(nullptr, field, nullptr);
180 BaseObject *obj = reinterpret_cast<BaseObject *>(TAG_HEAP_OBJECT_MASK);
181 markingBarrier->WriteBarrier(obj, field, obj);
182 EXPECT_TRUE(obj != nullptr);
183 #endif
184 }
185
HWTEST_F_L0(MarkingBarrierTest,WriteBarrier_TEST2)186 HWTEST_F_L0(MarkingBarrierTest, WriteBarrier_TEST2)
187 {
188 MockCollector collector;
189 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
190 ASSERT_TRUE(markingBarrier != nullptr);
191
192 #ifdef ARK_USE_SATB_BARRIER
193 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
194 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
195 RefField<false> normalField(obj);
196 markingBarrier->WriteBarrier(obj, normalField, obj);
197 EXPECT_TRUE(obj != nullptr);
198
199 BaseObject weakObj;
200 RefField<false> weakField(MAddress(0));
201 markingBarrier->WriteBarrier(&weakObj, weakField, &weakObj);
202 EXPECT_TRUE(weakObj != nullptr);
203
204 BaseObject nonTaggedObj;
205 RefField<false> nonTaggedField(&nonTaggedObj);
206 markingBarrier->WriteBarrier(nullptr, nonTaggedField, &nonTaggedObj);
207 EXPECT_TRUE(nonTaggedObj != nullptr);
208 #endif
209 }
210
HWTEST_F_L0(MarkingBarrierTest,WriteBarrier_TEST3)211 HWTEST_F_L0(MarkingBarrierTest, WriteBarrier_TEST3)
212 {
213 MockCollector collector;
214 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
215 ASSERT_TRUE(markingBarrier != nullptr);
216
217 #ifndef ARK_USE_SATB_BARRIER
218 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
219 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
220 RefField<> field(obj);
221 Heap::GetHeap().SetGCReason(GC_REASON_YOUNG);
222 markingBarrier->WriteBarrier(obj, field, obj);
223 EXPECT_TRUE(obj != nullptr);
224 #endif
225 }
226
HWTEST_F_L0(MarkingBarrierTest,WriteStruct_TEST1)227 HWTEST_F_L0(MarkingBarrierTest, WriteStruct_TEST1)
228 {
229 MockCollector collector;
230 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
231 ASSERT_TRUE(markingBarrier != nullptr);
232
233 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
234 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
235 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
236 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
237 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
238 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
239 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
240 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
241 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
242 markingBarrier->WriteStruct(obj, dst, sizeof(BaseObject), src, sizeof(BaseObject));
243 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
244 }
245
HWTEST_F_L0(MarkingBarrierTest,WriteStruct_TEST2)246 HWTEST_F_L0(MarkingBarrierTest, WriteStruct_TEST2)
247 {
248 MockCollector collector;
249 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
250 ASSERT_TRUE(markingBarrier != nullptr);
251
252 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
253 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
254 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
255 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
256 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
257 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
258 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
259 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
260 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
261
262 auto mutator = ThreadLocal::GetMutator();
263 ThreadLocal::SetMutator(nullptr);
264 markingBarrier->WriteStruct(obj, dst, sizeof(BaseObject), src, sizeof(BaseObject));
265 ThreadLocal::SetMutator(mutator);
266 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
267 }
268
HWTEST_F_L0(MarkingBarrierTest,AtomicReadRefField_TEST1)269 HWTEST_F_L0(MarkingBarrierTest, AtomicReadRefField_TEST1)
270 {
271 MockCollector collector;
272 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
273 ASSERT_TRUE(markingBarrier != nullptr);
274
275 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
276 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
277 constexpr size_t size = 100;
278 obj->SetSizeForwarded(size);
279 EXPECT_EQ(obj->GetSizeForwarded(), size);
280 RefField<true> field(obj);
281
282 BaseObject *resultObj = nullptr;
283 resultObj = markingBarrier->AtomicReadRefField(obj, field, std::memory_order_seq_cst);
284 ASSERT_TRUE(resultObj != nullptr);
285 }
286
HWTEST_F_L0(MarkingBarrierTest,AtomicWriteRefField_TEST1)287 HWTEST_F_L0(MarkingBarrierTest, AtomicWriteRefField_TEST1)
288 {
289 MockCollector collector;
290 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
291 ASSERT_TRUE(markingBarrier != nullptr);
292
293 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
294 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
295 constexpr size_t oldSize = 100;
296 oldObj->SetSizeForwarded(oldSize);
297 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
298 RefField<true> oldField(oldObj);
299 MAddress oldAddress = oldField.GetFieldValue();
300
301 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
302 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
303 constexpr size_t newSize = 200;
304 newObj->SetSizeForwarded(newSize);
305 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
306 RefField<true> newField(newObj);
307 MAddress neWAddress = newField.GetFieldValue();
308 EXPECT_NE(oldAddress, neWAddress);
309
310 markingBarrier->AtomicWriteRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
311 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
312 }
313
HWTEST_F_L0(MarkingBarrierTest,AtomicWriteRefField_TEST2)314 HWTEST_F_L0(MarkingBarrierTest, AtomicWriteRefField_TEST2)
315 {
316 MockCollector collector;
317 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
318 ASSERT_TRUE(markingBarrier != nullptr);
319
320 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
321 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
322 constexpr size_t oldSize = 100;
323 oldObj->SetSizeForwarded(oldSize);
324 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
325 RefField<true> oldField(oldObj);
326 MAddress oldAddress = oldField.GetFieldValue();
327
328 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
329 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
330 constexpr size_t newSize = 200;
331 newObj->SetSizeForwarded(newSize);
332 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
333 RefField<true> newField(newObj);
334 MAddress neWAddress = newField.GetFieldValue();
335 EXPECT_NE(oldAddress, neWAddress);
336
337 markingBarrier->AtomicWriteRefField(nullptr, oldField, newObj, std::memory_order_relaxed);
338 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
339 }
340
HWTEST_F_L0(MarkingBarrierTest,AtomicSwapRefField_TEST1)341 HWTEST_F_L0(MarkingBarrierTest, AtomicSwapRefField_TEST1)
342 {
343 MockCollector collector;
344 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
345 ASSERT_TRUE(markingBarrier != nullptr);
346
347 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
348 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
349 constexpr size_t oldSize = 100;
350 oldObj->SetSizeForwarded(oldSize);
351 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
352 RefField<true> oldField(oldObj);
353 MAddress oldAddress = oldField.GetFieldValue();
354
355 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
356 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
357 constexpr size_t newSize = 200;
358 newObj->SetSizeForwarded(newSize);
359 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
360 RefField<true> newField(newObj);
361 MAddress neWAddress = newField.GetFieldValue();
362 EXPECT_NE(oldAddress, neWAddress);
363
364 BaseObject *resultObj = nullptr;
365 resultObj = markingBarrier->AtomicSwapRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
366 EXPECT_EQ(oldField.GetFieldValue(), newField.GetFieldValue());
367 }
368
HWTEST_F_L0(MarkingBarrierTest,CompareAndSwapRefField_TEST1)369 HWTEST_F_L0(MarkingBarrierTest, CompareAndSwapRefField_TEST1)
370 {
371 MockCollector collector;
372 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
373 ASSERT_TRUE(markingBarrier != nullptr);
374
375 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
376 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
377 constexpr size_t oldSize = 100;
378 oldObj->SetSizeForwarded(oldSize);
379 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
380 RefField<true> oldField(oldObj);
381 MAddress oldAddress = oldField.GetFieldValue();
382
383 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
384 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
385 constexpr size_t newSize = 200;
386 newObj->SetSizeForwarded(newSize);
387 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
388 RefField<true> newField(newObj);
389 MAddress neWAddress = newField.GetFieldValue();
390 EXPECT_NE(oldAddress, neWAddress);
391
392 bool result = markingBarrier->CompareAndSwapRefField(
393 oldObj, oldField, oldObj, newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
394 ASSERT_TRUE(result);
395 }
396
HWTEST_F_L0(MarkingBarrierTest,CompareAndSwapRefField_TEST2)397 HWTEST_F_L0(MarkingBarrierTest, CompareAndSwapRefField_TEST2)
398 {
399 MockCollector collector;
400 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
401 ASSERT_TRUE(markingBarrier != nullptr);
402
403 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
404 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
405 constexpr size_t oldSize = 100;
406 oldObj->SetSizeForwarded(oldSize);
407 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
408 RefField<true> oldField(oldObj);
409
410 bool result = markingBarrier->CompareAndSwapRefField(
411 oldObj, oldField, oldObj, oldObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
412 ASSERT_TRUE(result);
413 }
414
HWTEST_F_L0(MarkingBarrierTest,CompareAndSwapRefField_TEST3)415 HWTEST_F_L0(MarkingBarrierTest, CompareAndSwapRefField_TEST3)
416 {
417 MockCollector collector;
418 auto markingBarrier = std::make_unique<MarkingBarrier>(collector);
419 ASSERT_TRUE(markingBarrier != nullptr);
420
421 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
422 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
423 constexpr size_t oldSize = 100;
424 oldObj->SetSizeForwarded(oldSize);
425 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
426 RefField<true> oldField(oldObj);
427 MAddress oldAddress = oldField.GetFieldValue();
428
429 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
430 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
431 constexpr size_t newSize = 200;
432 newObj->SetSizeForwarded(newSize);
433 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
434 RefField<true> newField(newObj);
435 MAddress neWAddress = newField.GetFieldValue();
436 EXPECT_NE(oldAddress, neWAddress);
437
438 bool result = markingBarrier->CompareAndSwapRefField(
439 oldObj, newField, oldObj, newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
440 ASSERT_FALSE(result);
441 }
442 } // namespace common::test
443