1 /*
2 * Copyright (c) 2024 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 "ecmascript/ecma_vm.h"
17 #include "ecmascript/mem/idle_gc_trigger.h"
18 #include "ecmascript/mem/heap.h"
19 #include "ecmascript/mem/heap-inl.h"
20 #include "ecmascript/tests/test_helper.h"
21 #include "ecmascript/mem/concurrent_marker.h"
22 #include "ecmascript/mem/partial_gc.h"
23 #include "ecmascript/mem/shared_heap/shared_concurrent_marker.h"
24 #include "ecmascript/napi/include/jsnapi_expo.h"
25
26 using namespace panda::ecmascript;
27 using namespace panda::ecmascript::base;
28 using TRIGGER_IDLE_GC_TYPE = panda::JSNApi::TRIGGER_IDLE_GC_TYPE;
29 using TriggerGCData = std::pair<void*, uint8_t>;
30 using TriggerGCTaskCallback = std::function<void(TriggerGCData& data)>;
31
32 namespace panda::test {
33 class IdleGCTriggerTest : public BaseTestWithScope<false> {
34 public:
SetUp()35 void SetUp() override
36 {
37 JSRuntimeOptions options;
38 instance = JSNApi::CreateEcmaVM(options);
39 ASSERT_TRUE(instance != nullptr) << "Cannot create EcmaVM";
40 thread = instance->GetJSThread();
41 thread->ManagedCodeBegin();
42 scope = new EcmaHandleScope(thread);
43 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
44 heap->GetConcurrentMarker()->EnableConcurrentMarking(EnableConcurrentMarkType::ENABLE);
45 heap->GetSweeper()->EnableConcurrentSweep(EnableConcurrentSweepType::ENABLE);
46 auto idleGCTrigger = heap->GetIdleGCTrigger();
47 idleGCTrigger->SetTriggerGCTaskCallback([idleGCTrigger](TriggerGCData& data) {
48 idleGCTrigger->ClearPostGCTask(static_cast<panda::JSNApi::TRIGGER_IDLE_GC_TYPE>(data.second));
49 });
50 }
51 };
52
HWTEST_F_L0(IdleGCTriggerTest,NotifyLooperIdleStartTest001)53 HWTEST_F_L0(IdleGCTriggerTest, NotifyLooperIdleStartTest001)
54 {
55 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
56 SharedHeap *sheap = SharedHeap::GetInstance();
57 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
58 trigger->NotifyLooperIdleStart(1, 1);
59 }
60
HWTEST_F_L0(IdleGCTriggerTest,NotifyLooperIdleStartTest002)61 HWTEST_F_L0(IdleGCTriggerTest, NotifyLooperIdleStartTest002)
62 {
63 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
64 SharedHeap *sheap = SharedHeap::GetInstance();
65 heap->GetConcurrentMarker()->Mark();
66 heap->GetJSThread()->SetMarkStatus(MarkStatus::MARK_FINISHED);
67 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
68 trigger->ClearPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
69 trigger->SetPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
70 trigger->NotifyLooperIdleStart(1, 1);
71 }
72
HWTEST_F_L0(IdleGCTriggerTest,NotifyLooperIdleEndTest001)73 HWTEST_F_L0(IdleGCTriggerTest, NotifyLooperIdleEndTest001)
74 {
75 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
76 SharedHeap *sheap = SharedHeap::GetInstance();
77 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
78 trigger->NotifyLooperIdleEnd(1);
79 }
80
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerHandleMarkFinishedTest001)81 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerHandleMarkFinishedTest001)
82 {
83 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
84 SharedHeap *sheap = SharedHeap::GetInstance();
85
86 heap->GetConcurrentMarker()->Mark();
87 heap->GetConcurrentMarker()->ProcessConcurrentMarkTask(0);
88
89 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
90 trigger->TryTriggerHandleMarkFinished();
91 }
92
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerLocalConcurrentMarkTest001)93 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerLocalConcurrentMarkTest001)
94 {
95 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
96 SharedHeap *sheap = SharedHeap::GetInstance();
97 heap->SetIdleTask(IdleTaskType::NO_TASK);
98
99 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
100 trigger->TryTriggerLocalConcurrentMark(MarkType::MARK_FULL);
101 }
102
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerLocalConcurrentMarkTest002)103 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerLocalConcurrentMarkTest002)
104 {
105 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
106 SharedHeap *sheap = SharedHeap::GetInstance();
107 heap->SetIdleTask(IdleTaskType::NO_TASK);
108 heap->GetConcurrentMarker()->ConfigConcurrentMark(false);
109 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
110 trigger->TryTriggerLocalConcurrentMark(MarkType::MARK_FULL);
111 }
112
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerLocalConcurrentMarkTest003)113 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerLocalConcurrentMarkTest003)
114 {
115 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
116 SharedHeap *sheap = SharedHeap::GetInstance();
117 heap->SetIdleTask(IdleTaskType::NO_TASK);
118 thread->SetMarkStatus(MarkStatus::MARK_FINISHED);
119 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
120 trigger->TryTriggerLocalConcurrentMark(MarkType::MARK_FULL);
121 }
122
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleSharedOldGCTest001)123 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleSharedOldGCTest001)
124 {
125 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
126 SharedHeap *sheap = SharedHeap::GetInstance();
127
128 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
129 ASSERT_EQ(trigger->TryTriggerIdleSharedOldGC(), false);
130 }
131
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleSharedOldGCTest002)132 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleSharedOldGCTest002)
133 {
134 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
135 SharedHeap *sheap = SharedHeap::GetInstance();
136 sheap->GetOldSpace()->SetInitialCapacity(10000);
137 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
138 sheap->NotifyHeapAliveSizeAfterGC(1);
139 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
140 ASSERT_EQ(trigger->TryTriggerIdleSharedOldGC(), false);
141 }
142
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleSharedOldGCTest003)143 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleSharedOldGCTest003)
144 {
145 constexpr size_t LIVE_SIZE = 5242889;
146 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
147 SharedHeap *sheap = SharedHeap::GetInstance();
148 sheap->GetOldSpace()->IncreaseLiveObjectSize(LIVE_SIZE);
149 sheap->NotifyHeapAliveSizeAfterGC(1);
150 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
151 trigger->ClearPostGCTask(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
152 trigger->SetPostGCTask(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
153 ASSERT_EQ(trigger->TryTriggerIdleSharedOldGC(), false);
154 }
155
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleSharedOldGCTest004)156 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleSharedOldGCTest004)
157 {
158 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
159 SharedHeap *sheap = SharedHeap::GetInstance();
160 heap->SetOnSerializeEvent(true);
161
162 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
163 ASSERT_EQ(trigger->TryTriggerIdleSharedOldGC(), false);
164 }
165
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest001)166 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest001)
167 {
168 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
169 SharedHeap *sheap = SharedHeap::GetInstance();
170 heap->SetIdleTask(IdleTaskType::NO_TASK);
171 heap->GetOldSpace()->SetInitialCapacity(10000);
172 heap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
173 heap->NotifyHeapAliveSizeAfterGC(1);
174 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
175 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), false);
176 }
177
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest002)178 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest002)
179 {
180 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
181 SharedHeap *sheap = SharedHeap::GetInstance();
182 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
183 trigger->ClearPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
184 trigger->SetPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
185 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), false);
186 }
187
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest003)188 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest003)
189 {
190 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
191 SharedHeap *sheap = SharedHeap::GetInstance();
192 heap->GetConcurrentMarker()->Mark();
193 heap->GetJSThread()->SetMarkStatus(MarkStatus::MARK_FINISHED);
194 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
195 trigger->ClearPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_REMARK);
196 trigger->SetPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_REMARK);
197 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), false);
198 }
199
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest004)200 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest004)
201 {
202 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
203 SharedHeap *sheap = SharedHeap::GetInstance();
204 heap->SetIdleTask(IdleTaskType::NO_TASK);
205 heap->GetOldSpace()->SetInitialCapacity(10000);
206 heap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
207 heap->NotifyHeapAliveSizeAfterGC(1);
208 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
209 TriggerGCTaskCallback callback = [](TriggerGCData& data) {
210 data.second = 1;
211 };
212 trigger->SetTriggerGCTaskCallback(callback);
213 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), true);
214 }
215
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest005)216 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest005)
217 {
218 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
219 SharedHeap *sheap = SharedHeap::GetInstance();
220 heap->GetConcurrentMarker()->Mark();
221 heap->GetJSThread()->SetMarkStatus(MarkStatus::MARK_FINISHED);
222 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
223 trigger->ClearPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
224 trigger->SetPostGCTask(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
225 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), false);
226 }
227
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleLocalOldGCTest006)228 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleLocalOldGCTest006)
229 {
230 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
231 SharedHeap *sheap = SharedHeap::GetInstance();
232 heap->SetIdleTask(IdleTaskType::FINISH_MARKING);
233 heap->GetOldSpace()->SetInitialCapacity(10000);
234 heap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
235 heap->NotifyHeapAliveSizeAfterGC(1);
236 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
237 TriggerGCTaskCallback callback = [](TriggerGCData& data) {
238 data.second = 1;
239 };
240 trigger->SetTriggerGCTaskCallback(callback);
241 ASSERT_EQ(trigger->TryTriggerIdleLocalOldGC(), true);
242 }
243
HWTEST_F_L0(IdleGCTriggerTest,ReachIdleLocalOldGCThresholdsTest001)244 HWTEST_F_L0(IdleGCTriggerTest, ReachIdleLocalOldGCThresholdsTest001)
245 {
246 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
247 SharedHeap *sheap = SharedHeap::GetInstance();
248 heap->GetNativeAreaAllocator()->IncreaseNativeMemoryUsage(83886100);
249 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
250 ASSERT_EQ(trigger->ReachIdleLocalOldGCThresholds(), true);
251 }
252
HWTEST_F_L0(IdleGCTriggerTest,ReachIdleLocalOldGCThresholdsTest002)253 HWTEST_F_L0(IdleGCTriggerTest, ReachIdleLocalOldGCThresholdsTest002)
254 {
255 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
256 SharedHeap *sheap = SharedHeap::GetInstance();
257 heap->GetNativeAreaAllocator()->IncreaseNativeMemoryUsage(1);
258 heap->GetOldSpace()->IncreaseCommitted(83886100);
259 heap->GetOldSpace()->SetMaximumCapacity(100000);
260 heap->GetOldSpace()->SetOvershootSize(100000);
261 heap->GetOldSpace()->SetOvershootSize(100000);
262 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
263 ASSERT_EQ(trigger->ReachIdleLocalOldGCThresholds(), true);
264 }
265
HWTEST_F_L0(IdleGCTriggerTest,TryPostHandleMarkFinishedTest001)266 HWTEST_F_L0(IdleGCTriggerTest, TryPostHandleMarkFinishedTest001)
267 {
268 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
269 SharedHeap *sheap = SharedHeap::GetInstance();
270 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
271 trigger->NotifyLooperIdleStart(1, 1);
272 trigger->TryPostHandleMarkFinished();
273 }
274
HWTEST_F_L0(IdleGCTriggerTest,TryPostHandleMarkFinishedTest002)275 HWTEST_F_L0(IdleGCTriggerTest, TryPostHandleMarkFinishedTest002)
276 {
277 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
278 SharedHeap *sheap = SharedHeap::GetInstance();
279 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
280 trigger->TryPostHandleMarkFinished();
281 }
282
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest002)283 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest002)
284 {
285 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
286 SharedHeap *sheap = SharedHeap::GetInstance();
287 sheap->NotifyHeapAliveSizeAfterGC(1);
288 sheap->GetOldSpace()->SetInitialCapacity(10000);
289 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
290 auto idleGCTrigger = heap->GetIdleGCTrigger();
291 idleGCTrigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
292 }
293
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest003)294 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest003)
295 {
296 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
297 heap->NotifyHeapAliveSizeAfterGC(1);
298 heap->GetOldSpace()->SetInitialCapacity(10000);
299 heap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
300 auto idleGCTrigger = heap->GetIdleGCTrigger();
301 idleGCTrigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
302 }
303
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest004)304 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest004)
305 {
306 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
307 SharedHeap *sheap = SharedHeap::GetInstance();
308 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
309 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::LOCAL_REMARK);
310 }
311
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest011)312 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest011)
313 {
314 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
315 SharedHeap *sheap = SharedHeap::GetInstance();
316 heap->SetOnSerializeEvent(true);
317 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
318 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::LOCAL_REMARK);
319 }
320
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest012)321 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest012)
322 {
323 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
324 SharedHeap *sheap = SharedHeap::GetInstance();
325 sheap->NotifyHeapAliveSizeAfterGC(0);
326 sheap->GetOldSpace()->SetInitialCapacity(10000);
327 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
328 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
329 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::FULL_GC);
330 }
331
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest013)332 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest013)
333 {
334 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
335 SharedHeap *sheap = SharedHeap::GetInstance();
336 sheap->NotifyHeapAliveSizeAfterGC(0);
337 sheap->GetOldSpace()->SetInitialCapacity(10000);
338 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
339 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
340 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_FULL_GC);
341 }
342
HWTEST_F_L0(IdleGCTriggerTest,ShouldCheckIdleOldGCTest001)343 HWTEST_F_L0(IdleGCTriggerTest, ShouldCheckIdleOldGCTest001)
344 {
345 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
346 SharedHeap *sheap = SharedHeap::GetInstance();
347 heap->NotifyHeapAliveSizeAfterGC(0);
348 heap->GetOldSpace()->SetInitialCapacity(10000);
349 heap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
350 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
351 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::LOCAL_CONCURRENT_FULL_MARK);
352 }
353
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest014)354 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest014)
355 {
356 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
357 SharedHeap *sheap = SharedHeap::GetInstance();
358 sheap->NotifyHeapAliveSizeAfterGC(0);
359 sheap->GetOldSpace()->SetInitialCapacity(10000);
360 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
361 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
362 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
363 }
364
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest015)365 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest015)
366 {
367 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
368 SharedHeap *sheap = SharedHeap::GetInstance();
369 sheap->GetConcurrentMarker()->ConfigConcurrentMark(false);
370 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
371 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
372 }
373
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest016)374 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest016)
375 {
376 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
377 SharedHeap *sheap = SharedHeap::GetInstance();
378 sheap->NotifyHeapAliveSizeAfterGC(1);
379 sheap->GetOldSpace()->IncreaseLiveObjectSize(5245000);
380 sheap->GetConcurrentMarker()->ConfigConcurrentMark(false);
381 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
382 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
383 }
384
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest017)385 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest017)
386 {
387 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
388 SharedHeap *sheap = SharedHeap::GetInstance();
389 sheap->NotifyHeapAliveSizeAfterGC(1);
390 sheap->GetOldSpace()->IncreaseLiveObjectSize(5245000);
391 sheap->GetConcurrentMarker()->ConfigConcurrentMark(false);
392 sheap->SetSensitiveStatus(AppSensitiveStatus::ENTER_HIGH_SENSITIVE);
393 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
394 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_MARK);
395 }
396
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest018)397 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest018)
398 {
399 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
400 SharedHeap *sheap = SharedHeap::GetInstance();
401 sheap->NotifyHeapAliveSizeAfterGC(1);
402 sheap->GetOldSpace()->IncreaseLiveObjectSize(5245000);
403 sheap->GetConcurrentMarker()->ConfigConcurrentMark(false);
404 sheap->SetSensitiveStatus(AppSensitiveStatus::ENTER_HIGH_SENSITIVE);
405 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
406 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_FULL_GC);
407 }
408
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest019)409 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest019)
410 {
411 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
412 SharedHeap *sheap = SharedHeap::GetInstance();
413 sheap->NotifyHeapAliveSizeAfterGC(1);
414 sheap->GetConcurrentMarker()->ConfigConcurrentMark(false);
415 sheap->SetSensitiveStatus(AppSensitiveStatus::ENTER_HIGH_SENSITIVE);
416 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
417 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_FULL_GC);
418 }
419
HWTEST_F_L0(IdleGCTriggerTest,TryTriggerIdleGCTest020)420 HWTEST_F_L0(IdleGCTriggerTest, TryTriggerIdleGCTest020)
421 {
422 auto heap = const_cast<Heap *>(thread->GetEcmaVM()->GetHeap());
423 SharedHeap *sheap = SharedHeap::GetInstance();
424 sheap->NotifyHeapAliveSizeAfterGC(1);
425 sheap->GetOldSpace()->SetInitialCapacity(10000);
426 sheap->GetOldSpace()->IncreaseLiveObjectSize(5242889);
427 IdleGCTrigger *trigger = new IdleGCTrigger(heap, sheap, thread);
428 trigger->TryTriggerIdleGC(TRIGGER_IDLE_GC_TYPE::SHARED_CONCURRENT_PARTIAL_MARK);
429 }
430 } // namespace panda::test