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/ark_collector.h"
17 #include "common_components/tests/test_helper.h"
18 #include "common_components/mutator/mutator_manager.h"
19 #include "common_components/common_runtime/base_runtime.cpp"
20
21 using namespace common;
22
23 namespace common::test {
24 class MutatorManagerTest : public BaseTestWithScope {
25 protected:
SetUp()26 void SetUp() override {}
TearDown()27 void TearDown() override {}
28 };
29
HWTEST_F_L0(MutatorManagerTest,BindMutatorOnly_Test1)30 HWTEST_F_L0(MutatorManagerTest, BindMutatorOnly_Test1)
31 {
32 MutatorManager *managerPtr = new MutatorManager();
33 Mutator mutator;
34 mutator.Init();
35 managerPtr->UnbindMutatorOnly();
36 bool res = managerPtr->BindMutatorOnly(&mutator);
37 ASSERT_TRUE(res);
38 delete managerPtr;
39 }
40
HWTEST_F_L0(MutatorManagerTest,IsRuntimeThread_Test1)41 HWTEST_F_L0(MutatorManagerTest, IsRuntimeThread_Test1)
42 {
43 ThreadLocalData* localData = ThreadLocal::GetThreadLocalData();
44 localData->threadType = ThreadType::HOT_UPDATE_THREAD;
45 bool ret = IsRuntimeThread();
46 EXPECT_TRUE(ret == true);
47
48 localData->threadType = ThreadType::ARK_PROCESSOR;
49 ret = IsRuntimeThread();
50 EXPECT_TRUE(ret == false);
51 }
52
HWTEST_F_L0(MutatorManagerTest,IsGcThread_Test1)53 HWTEST_F_L0(MutatorManagerTest, IsGcThread_Test1)
54 {
55 ThreadLocalData* localData = ThreadLocal::GetThreadLocalData();
56 localData->threadType = ThreadType::GC_THREAD;
57 bool ret = IsGcThread();
58 EXPECT_TRUE(ret == true);
59
60 localData->threadType = ThreadType::ARK_PROCESSOR;
61 ret = IsGcThread();
62 EXPECT_TRUE(ret == false);
63 }
64
HWTEST_F_L0(MutatorManagerTest,BindMutator_Test1)65 HWTEST_F_L0(MutatorManagerTest, BindMutator_Test1)
66 {
67 ThreadLocalData* localData = ThreadLocal::GetThreadLocalData();
68 localData->buffer = nullptr;
69 MutatorManager *managerPtr = new MutatorManager();
70 Mutator mutator;
71 mutator.Init();
72 managerPtr->BindMutator(mutator);
73 EXPECT_TRUE(localData->buffer != nullptr);
74
75 managerPtr->BindMutator(mutator);
76 EXPECT_TRUE(localData->mutator != nullptr);
77 delete managerPtr;
78 }
79
HWTEST_F_L0(MutatorManagerTest,CreateMutator_Test1)80 HWTEST_F_L0(MutatorManagerTest, CreateMutator_Test1)
81 {
82 ThreadLocalData* localData = ThreadLocal::GetThreadLocalData();
83 localData->mutator = new Mutator();
84 MutatorManager *managerPtr = new MutatorManager();
85 BaseRuntime::GetInstance()->Init();
86 Mutator* ptr = managerPtr->CreateMutator();
87 EXPECT_TRUE(ptr != nullptr);
88
89 delete managerPtr;
90 delete localData->mutator;
91 }
92
HWTEST_F_L0(MutatorManagerTest,CreateRuntimeMutato_Test1)93 HWTEST_F_L0(MutatorManagerTest, CreateRuntimeMutato_Test1)
94 {
95 ThreadType threadType = ThreadType::FP_THREAD;
96 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
97 EXPECT_TRUE(ptr != nullptr);
98
99 threadType = ThreadType::GC_THREAD;
100 ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
101 EXPECT_TRUE(ptr != nullptr);
102 }
103
HWTEST_F_L0(MutatorManagerTest,DestroyRuntimeMutator_Test1)104 HWTEST_F_L0(MutatorManagerTest, DestroyRuntimeMutator_Test1)
105 {
106 ThreadType threadType = ThreadType::GC_THREAD;
107 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
108 EXPECT_NE(ptr, nullptr);
109
110 MutatorManager::Instance().DestroyRuntimeMutator(threadType);
111 ptr = ThreadLocal::GetMutator();
112 EXPECT_EQ(ptr, nullptr);
113 }
114
HWTEST_F_L0(MutatorManagerTest,DestroyMutator_Test1)115 HWTEST_F_L0(MutatorManagerTest, DestroyMutator_Test1)
116 {
117 ThreadType threadType = ThreadType::GC_THREAD;
118 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
119
120 MutatorManager::Instance().DestroyMutator(ptr);
121 EXPECT_TRUE(MutatorManager::Instance().TryAcquireMutatorManagementRLock());
122 MutatorManager::Instance().MutatorManagementRUnlock();
123
124 MutatorManager::Instance().MutatorManagementWLock();
125 MutatorManager::Instance().DestroyMutator(ptr);
126 EXPECT_FALSE(MutatorManager::Instance().TryAcquireMutatorManagementRLock());
127 MutatorManager::Instance().MutatorManagementWUnlock();
128 }
129
HWTEST_F_L0(MutatorManagerTest,AcquireMutatorManagementWLockForCpuProfile_Test1)130 HWTEST_F_L0(MutatorManagerTest, AcquireMutatorManagementWLockForCpuProfile_Test1)
131 {
132 std::atomic<bool> threadStarted{false};
133 std::thread testthread([&]() {
134 threadStarted = true;
135 MutatorManager::Instance().MutatorManagementWLock();
136 MutatorManager::Instance().AcquireMutatorManagementWLockForCpuProfile();
137 });
138 while (!threadStarted) {}
139 std::this_thread::sleep_for(std::chrono::milliseconds(3));
140 MutatorManager::Instance().MutatorManagementWUnlock();
141 testthread.join();
142 EXPECT_FALSE(MutatorManager::Instance().TryAcquireMutatorManagementRLock());
143 MutatorManager::Instance().MutatorManagementWUnlock();
144 }
145
HWTEST_F_L0(MutatorManagerTest,EnsureCpuProfileFinish_Test1)146 HWTEST_F_L0(MutatorManagerTest, EnsureCpuProfileFinish_Test1)
147 {
148 std::list<Mutator*> undoneMutators;
149 ThreadType threadType = ThreadType::GC_THREAD;
150 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
151 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::FINISH_CPUPROFILE);
152 undoneMutators.push_back(ptr);
153 MutatorManager::Instance().EnsureCpuProfileFinish(undoneMutators);
154 EXPECT_EQ(undoneMutators.size(), 0);
155 }
156
HWTEST_F_L0(MutatorManagerTest,EnsureCpuProfileFinish_Test2)157 HWTEST_F_L0(MutatorManagerTest, EnsureCpuProfileFinish_Test2)
158 {
159 std::list<Mutator*> Mutators;
160 ThreadType threadType = ThreadType::GC_THREAD;
161 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
162 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::NO_CPUPROFILE);
163 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_TRUE);
164 Mutators.push_back(ptr);
165 MutatorManager::Instance().EnsureCpuProfileFinish(Mutators);
166 EXPECT_EQ(Mutators.size(), 0);
167 }
168
HWTEST_F_L0(MutatorManagerTest,EnsureCpuProfileFinish_Test3)169 HWTEST_F_L0(MutatorManagerTest, EnsureCpuProfileFinish_Test3)
170 {
171 std::list<Mutator*> Mutators;
172 ThreadType threadType = ThreadType::GC_THREAD;
173 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
174 std::thread testthread([&]() {
175 std::this_thread::sleep_for(std::chrono::milliseconds(3));
176 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::NO_CPUPROFILE);
177 });
178 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::IN_CPUPROFILING);
179 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_TRUE);
180 Mutators.push_back(ptr);
181 MutatorManager::Instance().EnsureCpuProfileFinish(Mutators);
182 testthread.join();
183 EXPECT_EQ(Mutators.size(), 0);
184 }
185
HWTEST_F_L0(MutatorManagerTest,EnsureCpuProfileFinish_Test4)186 HWTEST_F_L0(MutatorManagerTest, EnsureCpuProfileFinish_Test4)
187 {
188 std::list<Mutator*> Mutators;
189 ThreadType threadType = ThreadType::GC_THREAD;
190 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
191 std::thread testthread([&]() {
192 std::this_thread::sleep_for(std::chrono::milliseconds(3));
193 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_TRUE);
194 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::NO_CPUPROFILE);
195 });
196 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::IN_CPUPROFILING);
197 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_FALSE);
198 Mutators.push_back(ptr);
199 MutatorManager::Instance().EnsureCpuProfileFinish(Mutators);
200 testthread.join();
201 EXPECT_EQ(Mutators.size(), 0);
202 }
203
HWTEST_F_L0(MutatorManagerTest,EnsureCpuProfileFinish_Test5)204 HWTEST_F_L0(MutatorManagerTest, EnsureCpuProfileFinish_Test5)
205 {
206 std::list<Mutator*> Mutators;
207 ThreadType threadType = ThreadType::GC_THREAD;
208 Mutator* ptr = MutatorManager::Instance().CreateRuntimeMutator(threadType);
209 std::thread testthread([&]() {
210 std::this_thread::sleep_for(std::chrono::milliseconds(3));
211 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_TRUE);
212
213 });
214 ptr->SetCpuProfileState(MutatorBase::CpuProfileState::NO_CPUPROFILE);
215 ptr->SetInSaferegion(MutatorBase::SaferegionState::SAFE_REGION_FALSE);
216 Mutators.push_back(ptr);
217 MutatorManager::Instance().EnsureCpuProfileFinish(Mutators);
218 testthread.join();
219 EXPECT_EQ(Mutators.size(), 0);
220 }
221 } // namespace common::test
222