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 "test.h"
17
18 #include "async_runner.h"
19 #include "napi/native_api.h"
20 #include "napi/native_node_api.h"
21 #include "sequence_runner.h"
22 #include "sequence_runner_manager.h"
23 #include "task.h"
24 #include "task_group.h"
25 #include "task_group_manager.h"
26 #include "task_manager.h"
27 #include "taskpool.h"
28 #include "utils.h"
29 #include "uv.h"
30 #include "worker.h"
31
32 namespace Commonlibrary::Concurrent::TaskPoolModule {
33
34 static constexpr uint32_t MAX_TIMEOUT_TIME = 600000;
35 static constexpr uint32_t FINSHED_TASK = 5;
36 static constexpr uint32_t TASK_NUMS = 7;
37 static constexpr uint64_t UINT64_ZERO = 0;
38 static constexpr uint32_t UINT32_ZERO = 0;
39 static constexpr uint32_t UINT32_ONE = 1;
40 static constexpr size_t SIZE_TWO = 2;
41 static constexpr size_t SIZE_THREE = 3;
42
CreateReference(napi_env env)43 napi_ref CreateReference(napi_env env)
44 {
45 napi_value obj = NapiHelper::CreateObject(env);
46 return NapiHelper::CreateReference(env, obj, 1);
47 }
48
CreateSendableClass(napi_env env)49 napi_value SendableUtils::CreateSendableClass(napi_env env)
50 {
51 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
52 napi_value thisVar = nullptr;
53 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
54 return thisVar;
55 };
56
57 napi_property_descriptor props[] = {
58 DECLARE_NAPI_FUNCTION("foo", Foo),
59 DECLARE_NAPI_FUNCTION("bar", Bar),
60 };
61
62 napi_value sendableClass = nullptr;
63 napi_define_sendable_class(env, "SendableClass", NAPI_AUTO_LENGTH, constructor, nullptr,
64 sizeof(props) / sizeof(props[0]), props, nullptr, &sendableClass);
65 return sendableClass;
66 }
67
CreateSendableInstance(napi_env env)68 napi_value SendableUtils::CreateSendableInstance(napi_env env)
69 {
70 napi_value cls = SendableUtils::CreateSendableClass(env);
71 napi_value instance = nullptr;
72 napi_new_instance(env, cls, 0, nullptr, &instance);
73 return instance;
74 }
75
Foo(napi_env env,napi_callback_info info)76 napi_value SendableUtils::Foo(napi_env env, napi_callback_info info)
77 {
78 return nullptr;
79 }
80
Bar(napi_env env,napi_callback_info info)81 napi_value SendableUtils::Bar(napi_env env, napi_callback_info info)
82 {
83 return nullptr;
84 }
85
IsConcurrent(napi_env env,napi_value argv[],size_t argc)86 napi_value NativeEngineTest::IsConcurrent(napi_env env, napi_value argv[], size_t argc)
87 {
88 std::string funcName = "IsConcurrent";
89 napi_value cb = nullptr;
90 napi_value result = nullptr;
91 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::IsConcurrent, nullptr, &cb);
92 napi_call_function(env, nullptr, cb, argc, argv, &result);
93 return result;
94 }
95
GetTaskPoolInfo(napi_env env,napi_value argv[],size_t argc)96 napi_value NativeEngineTest::GetTaskPoolInfo(napi_env env, napi_value argv[], size_t argc)
97 {
98 std::string funcName = "GetTaskPoolInfo";
99 napi_value cb = nullptr;
100 napi_value result = nullptr;
101 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::GetTaskPoolInfo, nullptr, &cb);
102 napi_call_function(env, nullptr, cb, argc, argv, &result);
103 return result;
104 }
105
TerminateTask(napi_env env,napi_value argv[],size_t argc)106 napi_value NativeEngineTest::TerminateTask(napi_env env, napi_value argv[], size_t argc)
107 {
108 std::string funcName = "TerminateTask";
109 napi_value cb = nullptr;
110 napi_value result = nullptr;
111 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::TerminateTask, nullptr, &cb);
112 napi_call_function(env, nullptr, cb, argc, argv, &result);
113 return result;
114 }
115
Execute(napi_env env,napi_value argv[],size_t argc)116 napi_value NativeEngineTest::Execute(napi_env env, napi_value argv[], size_t argc)
117 {
118 std::string funcName = "Execute";
119 napi_value cb = nullptr;
120 napi_value result = nullptr;
121 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::Execute, nullptr, &cb);
122 napi_call_function(env, nullptr, cb, argc, argv, &result);
123 return result;
124 }
125
ExecuteDelayed(napi_env env,napi_value argv[],size_t argc)126 napi_value NativeEngineTest::ExecuteDelayed(napi_env env, napi_value argv[], size_t argc)
127 {
128 std::string funcName = "ExecuteDelayed";
129 napi_value cb = nullptr;
130 napi_value result = nullptr;
131 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::ExecuteDelayed, nullptr, &cb);
132 napi_call_function(env, nullptr, cb, argc, argv, &result);
133 return result;
134 }
135
Cancel(napi_env env,napi_value argv[],size_t argc)136 napi_value NativeEngineTest::Cancel(napi_env env, napi_value argv[], size_t argc)
137 {
138 std::string funcName = "Cancel";
139 napi_value cb = nullptr;
140 napi_value result = nullptr;
141 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::Cancel, nullptr, &cb);
142 napi_call_function(env, nullptr, cb, argc, argv, &result);
143 return result;
144 }
145
TaskGroupDestructor(napi_env env,void * data)146 void NativeEngineTest::TaskGroupDestructor(napi_env env, void* data)
147 {
148 void* hint = nullptr;
149 TaskGroup::TaskGroupDestructor(env, data, hint);
150 }
151
SequenceRunnerDestructor(napi_env env,void * data)152 void NativeEngineTest::SequenceRunnerDestructor(napi_env env, void* data)
153 {
154 void* hint = nullptr;
155 SequenceRunner::SequenceRunnerDestructor(env, data, hint);
156 }
157
ExecutePeriodically(napi_env env,napi_value argv[],size_t argc)158 napi_value NativeEngineTest::ExecutePeriodically(napi_env env, napi_value argv[], size_t argc)
159 {
160 std::string funcName = "ExecutePeriodically";
161 napi_value cb = nullptr;
162 napi_value result = nullptr;
163 napi_create_function(env, funcName.c_str(), funcName.size(), TaskPool::ExecutePeriodically, nullptr, &cb);
164 napi_call_function(env, nullptr, cb, argc, argv, &result);
165 return result;
166 }
167
ExecuteGroup(napi_env env,napi_value taskGroup)168 napi_value NativeEngineTest::ExecuteGroup(napi_env env, napi_value taskGroup)
169 {
170 return TaskPool::ExecuteGroup(env, taskGroup, Priority::DEFAULT);
171 }
172
DelayTask(uv_timer_t * handle)173 void NativeEngineTest::DelayTask(uv_timer_t* handle)
174 {
175 TaskPool::DelayTask(handle);
176 }
177
PeriodicTaskCallback(uv_timer_t * handle)178 void NativeEngineTest::PeriodicTaskCallback(uv_timer_t* handle)
179 {
180 TaskPool::PeriodicTaskCallback(handle);
181 }
182
UpdateGroupInfoByResult(napi_env env,uv_timer_t * handle,napi_value res,bool success)183 void NativeEngineTest::UpdateGroupInfoByResult(napi_env env, uv_timer_t* handle, napi_value res, bool success)
184 {
185 Task* task = reinterpret_cast<Task*>(handle->data);
186 TaskPool::UpdateGroupInfoByResult(env, task, res, success);
187 }
188
TryTriggerExpand()189 void NativeEngineTest::TryTriggerExpand()
190 {
191 TaskManager& taskManager = TaskManager::GetInstance();
192 taskManager.isHandleInited_ = false;
193 taskManager.TryTriggerExpand();
194 taskManager.isHandleInited_ = true;
195 taskManager.needChecking_ = false;
196 }
197
CheckForBlockedWorkers(napi_env env)198 void NativeEngineTest::CheckForBlockedWorkers(napi_env env)
199 {
200 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
201 worker->workerEnv_ = nullptr;
202 TaskManager& taskManager = TaskManager::GetInstance();
203 taskManager.workers_.clear();
204 taskManager.workers_.insert(worker);
205 taskManager.GetThreadInfos(env);
206
207 worker->workerEnv_ = env;
208 worker->state_ = WorkerState::RUNNING;
209 worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;
210 worker->idleState_ = true;
211 taskManager.CheckForBlockedWorkers();
212
213 worker->state_ = WorkerState::RUNNING;
214 worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;
215 worker->idleState_ = false;
216 worker->hasLongTask_ = true;
217 taskManager.CheckForBlockedWorkers();
218
219 worker->state_ = WorkerState::RUNNING;
220 worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;
221 worker->idleState_ = false;
222 worker->hasLongTask_ = false;
223 taskManager.idleWorkers_.insert(worker);
224 taskManager.CheckForBlockedWorkers();
225 taskManager.timeoutWorkers_.clear();
226 }
227
foo(const uv_async_t * req)228 void NativeEngineTest::foo(const uv_async_t* req)
229 {
230 return;
231 }
232
TriggerShrink(napi_env env)233 void NativeEngineTest::TriggerShrink(napi_env env)
234 {
235 uint32_t step = 1;
236 TaskManager& taskManager = TaskManager::GetInstance();
237 taskManager.idleWorkers_.clear();
238 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
239 worker->workerEnv_ = env;
240 taskManager.idleWorkers_.insert(worker);
241
242 taskManager.freeList_.emplace_back(worker);
243 worker->state_ = WorkerState::RUNNING;
244 taskManager.TriggerShrink(step);
245
246 taskManager.idleWorkers_.clear();
247 taskManager.idleWorkers_.insert(worker);
248 taskManager.freeList_.emplace_back(worker);
249 worker->idlePoint_ = ConcurrentHelper::GetMilliseconds();
250 worker->state_ = WorkerState::IDLE;
251 worker->hasLongTask_ = false;
252 taskManager.TriggerShrink(step);
253
254 taskManager.idleWorkers_.clear();
255 taskManager.idleWorkers_.insert(worker);
256 taskManager.freeList_.emplace_back(worker);
257 worker->idlePoint_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;
258 worker->state_ = WorkerState::IDLE;
259 worker->hasLongTask_ = false;
260 uv_loop_t* loop = worker->GetWorkerLoop();
261 ConcurrentHelper::UvHandleInit(loop, worker->clearWorkerSignal_, NativeEngineTest::foo, worker);
262 taskManager.TriggerShrink(step);
263 taskManager.idleWorkers_.clear();
264 taskManager.globalEnableFfrtFlag_ = false;
265 }
266
NotifyShrink(napi_env env)267 void NativeEngineTest::NotifyShrink(napi_env env)
268 {
269 uint32_t step = 1;
270 TaskManager& taskManager = TaskManager::GetInstance();
271 taskManager.workers_.clear();
272 taskManager.timeoutWorkers_.clear();
273
274 Worker* worker1 = reinterpret_cast<Worker*>(WorkerConstructor(env));
275 Worker* worker2 = reinterpret_cast<Worker*>(WorkerConstructor(env));
276 worker1->workerEnv_ = env;
277 worker2->workerEnv_ = env;
278 uv_loop_t* loop1 = worker1->GetWorkerLoop();
279 ConcurrentHelper::UvHandleInit(loop1, worker1->clearWorkerSignal_, NativeEngineTest::foo, worker1);
280 uv_loop_t* loop2 = worker2->GetWorkerLoop();
281 ConcurrentHelper::UvHandleInit(loop2, worker2->clearWorkerSignal_, NativeEngineTest::foo, worker2);
282 taskManager.workers_.insert(worker1);
283 taskManager.workers_.insert(worker2);
284 taskManager.timeoutWorkers_.insert(worker1);
285 taskManager.timeoutWorkers_.insert(worker2);
286 taskManager.NotifyShrink(step);
287
288 taskManager.workers_.clear();
289 taskManager.timeoutWorkers_.clear();
290 taskManager.workers_.insert(worker1);
291 taskManager.idleWorkers_.insert(nullptr);
292 taskManager.NotifyShrink(step);
293
294 taskManager.idleWorkers_.clear();
295 taskManager.idleWorkers_.insert(worker2);
296 worker2->hasLongTask_ = true;
297 taskManager.NotifyShrink(step);
298
299 worker2->hasLongTask_ = false;
300 worker2->hasExecuted_ = true;
301 taskManager.NotifyShrink(step);
302
303 worker2->hasExecuted_ = false;
304 taskManager.workers_.clear();
305 taskManager.NotifyShrink(step);
306 }
307
TryExpand(napi_env env)308 void NativeEngineTest::TryExpand(napi_env env)
309 {
310 TaskManager& taskManager = TaskManager::GetInstance();
311 taskManager.workers_.clear();
312 taskManager.timeoutWorkers_.clear();
313 taskManager.idleWorkers_.clear();
314 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
315 worker->workerEnv_ = env;
316 uv_loop_t* loop = worker->GetWorkerLoop();
317 ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);
318 taskManager.idleWorkers_.insert(worker);
319 taskManager.TryExpand();
320 taskManager.nonIdleTaskNum_ = 1;
321 taskManager.TryExpand();
322 taskManager.nonIdleTaskNum_ = 0;
323 taskManager.TryExpand();
324 taskManager.idleWorkers_.clear();
325 taskManager.suspend_ = true;
326 taskManager.TryExpand();
327 }
328
CancelTask(napi_env env)329 void NativeEngineTest::CancelTask(napi_env env)
330 {
331 TaskManager& taskManager = TaskManager::GetInstance();
332 Task* task = new Task();
333 task->taskType_ = TaskType::COMMON_TASK;
334 taskManager.StoreTask(task);
335 napi_value val = NapiHelper::CreateObject(env);
336 napi_ref ref = NapiHelper::CreateReference(env, val, 0);
337 task->taskRef_ = ref;
338 task->taskState_ = ExecuteState::CANCELED;
339 taskManager.CancelTask(env, task->taskId_);
340
341 task->taskState_ = ExecuteState::RUNNING;
342 task->isPeriodicTask_ = true;
343 taskManager.CancelTask(env, task->taskId_);
344
345 task->isPeriodicTask_ = false;
346 task->taskType_ = TaskType::SEQRUNNER_TASK;
347 taskManager.CancelTask(env, task->taskId_);
348
349 task->taskState_ = ExecuteState::FINISHED;
350 taskManager.CancelTask(env, task->taskId_);
351
352 TaskInfo* taskInfo = new TaskInfo();
353 task->taskState_ = ExecuteState::WAITING;
354 task->currentTaskInfo_ = taskInfo;
355 taskManager.CancelTask(env, task->taskId_);
356 taskManager.tasks_.clear();
357 delete task;
358 }
359
NotifyWorkerIdle(napi_env env)360 void NativeEngineTest::NotifyWorkerIdle(napi_env env)
361 {
362 TaskManager& taskManager = TaskManager::GetInstance();
363 Task* task = new Task();
364 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
365 taskManager.taskQueues_[Priority::DEFAULT]->EnqueueTaskId(task->taskId_);
366 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
367 worker->workerEnv_ = env;
368 uv_loop_t* loop = worker->GetWorkerLoop();
369 ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);
370 worker->state_ = WorkerState::BLOCKED;
371 taskManager.NotifyWorkerIdle(worker);
372 worker->state_ = WorkerState::IDLE;
373 taskManager.NotifyWorkerIdle(worker);
374 delete task;
375 }
376
EnqueueTaskId(napi_env env)377 void NativeEngineTest::EnqueueTaskId(napi_env env)
378 {
379 TaskManager& taskManager = TaskManager::GetInstance();
380 Task* task = new Task();
381 taskManager.StoreTask(task);
382 napi_value obj = Helper::NapiHelper::CreateObject(env);
383 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, obj, 1);
384 task->onEnqueuedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
385 taskManager.EnqueueTaskId(task->taskId_);
386
387 taskManager.workers_.clear();
388 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
389 worker->state_ = WorkerState::RUNNING;
390 taskManager.workers_.insert(worker);
391 taskManager.IsChooseIdle();
392 taskManager.workers_.clear();
393 Helper::NapiHelper::DeleteReference(env, callbackRef);
394 delete task;
395 }
396
GetTaskByPriority(napi_env env)397 void NativeEngineTest::GetTaskByPriority(napi_env env)
398 {
399 TaskManager& taskManager = TaskManager::GetInstance();
400 Task* task = new Task();
401 taskManager.StoreTask(task);
402 auto& mediumTaskQueue = taskManager.taskQueues_[Priority::DEFAULT];
403 uint32_t id = mediumTaskQueue->DequeueTaskId();
404 while (id != 0) {
405 id = mediumTaskQueue->DequeueTaskId();
406 }
407 taskManager.EnqueueTaskId(task->taskId_);
408 std::set<uint32_t> set{task->taskId_};
409 taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));
410 taskManager.GetTaskByPriority(mediumTaskQueue, Priority::DEFAULT);
411 taskManager.dependTaskInfos_.clear();
412 taskManager.tasks_.clear();
413 delete task;
414 }
415
RestoreWorker(napi_env env)416 void NativeEngineTest::RestoreWorker(napi_env env)
417 {
418 TaskManager& taskManager = TaskManager::GetInstance();
419 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
420 taskManager.suspend_ = false;
421 worker->state_ = WorkerState::BLOCKED;
422 taskManager.RestoreWorker(worker);
423
424 Task* task = new Task();
425 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
426 taskManager.EnqueueTaskId(task->taskId_);
427 worker->state_ = WorkerState::IDLE;
428 worker->workerEnv_ = env;
429 uv_loop_t* loop = worker->GetWorkerLoop();
430 ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);
431 taskManager.RestoreWorker(worker);
432 }
433
StoreDependentId(uint32_t taskId,uint32_t dependentId)434 void NativeEngineTest::StoreDependentId(uint32_t taskId, uint32_t dependentId)
435 {
436 TaskManager& taskManager = TaskManager::GetInstance();
437 std::set<uint32_t> set{ dependentId };
438 taskManager.dependTaskInfos_.emplace(taskId, std::move(set));
439 }
440
StoreDependentTaskId(uint32_t taskId,uint32_t dependentId)441 void NativeEngineTest::StoreDependentTaskId(uint32_t taskId, uint32_t dependentId)
442 {
443 TaskManager& taskManager = TaskManager::GetInstance();
444 std::set<uint32_t> set{ dependentId };
445 taskManager.dependentTaskInfos_.emplace(taskId, std::move(set));
446 }
447
StoreTaskDuration(uint32_t taskId)448 void NativeEngineTest::StoreTaskDuration(uint32_t taskId)
449 {
450 TaskManager& taskManager = TaskManager::GetInstance();
451 uint64_t durationId = taskId + MAX_TIMEOUT_TIME;
452 std::pair<uint64_t, uint64_t> durationData = std::make_pair(taskId, durationId);
453 taskManager.taskDurationInfos_.emplace(taskId, std::move(durationData));
454 }
455
InitTaskManager(napi_env env)456 void NativeEngineTest::InitTaskManager(napi_env env)
457 {
458 napi_env taskEnv = nullptr;
459 napi_create_runtime(env, &taskEnv);
460 NativeEngine* taskEngine = reinterpret_cast<NativeEngine*>(taskEnv);
461 taskEngine->MarkTaskPoolThread();
462 TaskManager& taskManager = TaskManager::GetInstance();
463 taskManager.globalEnableFfrtFlag_ = true;
464 taskManager.InitTaskManager(taskEnv);
465 taskManager.DecreaseSendDataRefCount(env, 0);
466 napi_value exception = nullptr;
467 napi_get_and_clear_last_exception(env, &exception);
468 }
469
NotifyDependencyTaskInfo(napi_env env)470 void NativeEngineTest::NotifyDependencyTaskInfo(napi_env env)
471 {
472 TaskManager& taskManager = TaskManager::GetInstance();
473 Task* task = new Task();
474 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
475 task->env_ = env;
476 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
477 worker->workerEnv_ = env;
478 task->worker_ = worker;
479 uint32_t id = task->taskId_ + MAX_TIMEOUT_TIME;
480 std::set<uint32_t> set{ task->taskId_, id };
481 taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set));
482 taskManager.NotifyDependencyTaskInfo(task->taskId_);
483 std::set<uint32_t> set1{ task->taskId_, id };
484 taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set1));
485 taskManager.EnqueuePendingTaskInfo(0, Priority::DEFAULT);
486 taskManager.EnqueuePendingTaskInfo(id, Priority::DEFAULT);
487 taskManager.EnqueuePendingTaskInfo(task->taskId_, Priority::DEFAULT);
488 taskManager.NotifyDependencyTaskInfo(task->taskId_);
489 std::set<uint32_t> set2{ task->taskId_, id };
490 taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set2));
491 taskManager.IsDependentByTaskId(task->taskId_);
492 }
493
StoreTaskDependency(napi_env env)494 void NativeEngineTest::StoreTaskDependency(napi_env env)
495 {
496 TaskManager& taskManager = TaskManager::GetInstance();
497 Task* task = new Task();
498 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
499 task->env_ = env;
500 Task* task1 = new Task();
501 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
502 task1->env_ = env;
503 Task* task2 = new Task();
504 task2->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task2));
505 task2->env_ = env;
506 taskManager.dependTaskInfos_.clear();
507 uint32_t id1 = task->taskId_;
508 uint32_t id2 = task->taskId_ + MAX_TIMEOUT_TIME;
509 uint32_t id3 = task1->taskId_;
510 uint32_t id4 = task1->taskId_ + MAX_TIMEOUT_TIME;
511 uint32_t id5 = task2->taskId_;
512 uint32_t id6 = task2->taskId_ + MAX_TIMEOUT_TIME;
513 std::set<uint32_t> set{ id2, id3 };
514 taskManager.dependTaskInfos_.emplace(id1, std::move(set));
515 std::set<uint32_t> taskId{ id1, id2 };
516 taskManager.StoreTaskDependency(id3, taskId);
517 taskManager.StoreTaskDependency(id5, taskId);
518 std::set<uint32_t> set1{ id4, id5 };
519 taskManager.dependTaskInfos_.emplace(id3, std::move(set1));
520 taskManager.StoreTaskDependency(id1, taskId);
521 std::set<uint32_t> set2{ id6 };
522 std::set<uint32_t> set3{ id1 };
523 taskManager.dependTaskInfos_.emplace(id5, std::move(set3));
524 taskManager.StoreTaskDependency(id1, taskId);
525 taskManager.dependTaskInfos_.emplace(id5, std::move(set2));
526 taskManager.StoreTaskDependency(id1, taskId);
527 taskManager.dependTaskInfos_.clear();
528 napi_value exception = nullptr;
529 napi_get_and_clear_last_exception(env, &exception);
530 }
531
RemoveTaskDependency(napi_env env)532 void NativeEngineTest::RemoveTaskDependency(napi_env env)
533 {
534 TaskManager& taskManager = TaskManager::GetInstance();
535 Task* task = new Task();
536 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
537 uint32_t id = task->taskId_ + MAX_TIMEOUT_TIME;
538 Task* task1 = new Task();
539 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
540 uint32_t id2 = task1->taskId_ + MAX_TIMEOUT_TIME;
541 taskManager.dependTaskInfos_.clear();
542 std::set<uint32_t> set{ id };
543 taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));
544 taskManager.RemoveTaskDependency(task->taskId_, task1->taskId_);
545 taskManager.RemoveTaskDependency(task->taskId_, id);
546 std::set<uint32_t> set2{ id };
547 taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set2));
548 std::set<uint32_t> dependentTaskIdSet{ task->taskId_ };
549 taskManager.StoreDependentTaskInfo(dependentTaskIdSet, task1->taskId_);
550 taskManager.RemoveDependentTaskInfo(task->taskId_, id2);
551 taskManager.RemoveDependentTaskInfo(task->taskId_, id);
552 taskManager.GetTaskDependInfoToString(task1->taskId_);
553 taskManager.taskDurationInfos_.emplace(task->taskId_, std::make_pair(UINT64_ZERO, task1->taskId_));
554 taskManager.StoreTaskDuration(task->taskId_, UINT64_ZERO, UINT64_ZERO);
555 taskManager.GetTaskDuration(task->taskId_, "");
556 taskManager.RemoveTaskDuration(task->taskId_);
557 }
558
ReleaseTaskData(napi_env env)559 void NativeEngineTest::ReleaseTaskData(napi_env env)
560 {
561 TaskManager& taskManager = TaskManager::GetInstance();
562 Task* task = new Task();
563 task->taskType_ = TaskType::FUNCTION_TASK;
564 taskManager.StoreTask(task);
565 taskManager.ReleaseTaskData(env, task);
566 task->taskType_ = TaskType::GROUP_FUNCTION_TASK;
567 taskManager.StoreTask(task);
568 taskManager.ReleaseTaskData(env, task);
569 std::set<uint32_t> set{ task->taskId_ };
570 taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));
571 task->taskType_ = TaskType::COMMON_TASK;
572 taskManager.StoreTask(task);
573 taskManager.ReleaseTaskData(env, task);
574 Task* task1 = new Task();
575 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
576 task1->onEnqueuedCallBackInfo_ = new ListenerCallBackInfo(env, nullptr, nullptr);
577 task1->onStartExecutionCallBackInfo_ = new ListenerCallBackInfo(env, nullptr, nullptr);
578 task1->onExecutionFailedCallBackInfo_ = new ListenerCallBackInfo(env, nullptr, nullptr);
579 task1->onExecutionSucceededCallBackInfo_ = new ListenerCallBackInfo(env, nullptr, nullptr);
580 taskManager.ReleaseCallBackInfo(task1);
581 Task* task2 = new Task();
582 task2->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task2));
583 task2->isMainThreadTask_ = true;
584 taskManager.ReleaseCallBackInfo(task2);
585 task2->isMainThreadTask_ = false;
586 taskManager.ReleaseCallBackInfo(task2);
587 auto loop = NapiHelper::GetLibUV(env);
588 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_, NativeEngineTest::foo, task2);
589 taskManager.ReleaseCallBackInfo(task2);
590 }
591
CheckTask(napi_env env)592 void NativeEngineTest::CheckTask(napi_env env)
593 {
594 TaskManager& taskManager = TaskManager::GetInstance();
595 Task* task = new Task();
596 taskManager.StoreTask(task);
597 Task* task1 = new Task();
598 taskManager.StoreTask(task1);
599 taskManager.RemoveTask(task1->taskId_);
600
601 TaskGroupManager& groupManager = TaskGroupManager::GetInstance();
602 TaskGroup* group = new TaskGroup();
603 napi_value obj = NapiHelper::CreateObject(env);
604 napi_ref ref = NapiHelper::CreateReference(env, obj, 1);
605 group->groupRef_ = ref;
606 uint64_t groupId = reinterpret_cast<uint64_t>(group);
607 groupManager.StoreTaskGroup(groupId, nullptr);
608 groupManager.AddTask(groupId, nullptr, task->taskId_);
609 groupManager.taskGroups_.clear();
610 groupManager.StoreTaskGroup(groupId, group);
611 group->groupState_ = ExecuteState::CANCELED;
612 groupManager.CancelGroup(env, groupId);
613
614 group->groupState_ = ExecuteState::WAITING;
615 groupManager.CancelGroup(env, groupId);
616
617 GroupInfo* groupInfo = new GroupInfo();
618 groupInfo->finishedTaskNum = FINSHED_TASK;
619 group->currentGroupInfo_ = groupInfo;
620 group->groupState_ = ExecuteState::NOT_FOUND;
621 groupManager.CancelGroup(env, groupId);
622
623 group->groupState_ = ExecuteState::FINISHED;
624 groupManager.CancelGroup(env, groupId);
625
626 group->groupState_ = ExecuteState::RUNNING;
627 group->taskNum_ = FINSHED_TASK;
628 group->taskIds_.push_back(task->taskId_);
629 groupManager.CancelGroup(env, groupId);
630
631 group->taskNum_ = TASK_NUMS;
632 group->groupState_ = ExecuteState::WAITING;
633 napi_value resArr;
634 napi_create_array_with_length(env, group->taskIds_.size(), &resArr);
635 napi_ref arrRef = NapiHelper::CreateReference(env, resArr, 1);
636 groupInfo->resArr = arrRef;
637 napi_value promise = NapiHelper::CreatePromise(env, &groupInfo->deferred);
638 groupManager.CancelGroup(env, groupId);
639 }
640
CancelGroupTask(napi_env env)641 void NativeEngineTest::CancelGroupTask(napi_env env)
642 {
643 TaskGroupManager& groupManager = TaskGroupManager::GetInstance();
644 SequenceRunnerManager& sequenceRunnerManager = SequenceRunnerManager::GetInstance();
645 TaskManager& taskManager = TaskManager::GetInstance();
646 TaskGroup* group = new TaskGroup();
647 group->currentGroupInfo_ = new GroupInfo();
648 Task* task = new Task();
649 taskManager.StoreTask(task);
650 task->taskState_ = ExecuteState::RUNNING;
651 groupManager.CancelGroupTask(env, task->taskId_, group);
652 task->taskState_ = ExecuteState::WAITING;
653 groupManager.CancelGroupTask(env, task->taskId_, group);
654 task->taskState_ = ExecuteState::WAITING;
655 TaskInfo* taskInfo = new TaskInfo();
656 task->currentTaskInfo_ = taskInfo;
657 groupManager.CancelGroupTask(env, task->taskId_, group);
658
659 Task* task1 = new Task();
660 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
661 SequenceRunner* seqRunner = new SequenceRunner();
662 uint64_t seqRunnerId = reinterpret_cast<uint64_t>(seqRunner);
663 sequenceRunnerManager.StoreSequenceRunner(seqRunnerId, seqRunner);
664 sequenceRunnerManager.AddTaskToSeqRunner(seqRunnerId, task1);
665 }
666
TriggerSeqRunner(napi_env env)667 void NativeEngineTest::TriggerSeqRunner(napi_env env)
668 {
669 TaskGroupManager& groupManager = TaskGroupManager::GetInstance();
670 SequenceRunnerManager& sequenceRunnerManager = SequenceRunnerManager::GetInstance();
671 Task* task = new Task();
672 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
673 Task* task1 = new Task();
674 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
675 SequenceRunner* seqRunner = new SequenceRunner();
676 uint64_t seqRunnerId = reinterpret_cast<uint64_t>(seqRunner);
677 seqRunner->priority_ = Priority::DEFAULT;
678 task->seqRunnerId_ = seqRunnerId;
679 sequenceRunnerManager.StoreSequenceRunner(seqRunnerId, seqRunner);
680 seqRunner->isGlobalRunner_ = true;
681 seqRunner->IncreaseSeqCount();
682 bool res = sequenceRunnerManager.TriggerSeqRunner(env, task);
683 ASSERT_FALSE(res);
684 seqRunner->currentTaskId_ = task1->taskId_;
685 seqRunner->IncreaseSeqCount();
686 sequenceRunnerManager.TriggerSeqRunner(env, task);
687 seqRunner->isGlobalRunner_ = false;
688 seqRunner->currentTaskId_ = task->taskId_;
689 seqRunner->IncreaseSeqCount();
690 sequenceRunnerManager.TriggerSeqRunner(env, task);
691 seqRunner->IncreaseSeqCount();
692 task1->taskState_ = ExecuteState::CANCELED;
693 task1->env_ = env;
694 seqRunner->seqRunnerTasks_.push_back(task1);
695 TaskInfo* taskInfo = new TaskInfo();
696 task1->currentTaskInfo_ = taskInfo;
697 seqRunner->currentTaskId_ = task->taskId_;
698 sequenceRunnerManager.TriggerSeqRunner(env, task);
699 seqRunner->refCount_ = SIZE_TWO;
700 TaskInfo* taskInfo1 = new TaskInfo();
701 task1->currentTaskInfo_ = taskInfo1;
702 seqRunner->seqRunnerTasks_.push_back(task1);
703 seqRunner->seqRunnerTasks_.push_back(task);
704 task->taskState_ = ExecuteState::RUNNING;
705 seqRunner->currentTaskId_ = task->taskId_;
706 sequenceRunnerManager.TriggerSeqRunner(env, task);
707 }
708
UpdateGroupState(napi_env env)709 void NativeEngineTest::UpdateGroupState(napi_env env)
710 {
711 TaskGroupManager& groupManager = TaskGroupManager::GetInstance();
712 TaskGroup* group = new TaskGroup();
713 uint64_t groupId = reinterpret_cast<uint64_t>(group);
714 Task* task = new Task();
715 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
716 groupManager.StoreTaskGroup(groupId, group);
717 groupManager.UpdateGroupState(task->taskId_);
718 group->groupState_ = ExecuteState::CANCELED;
719 groupManager.UpdateGroupState(groupId);
720 group->groupState_ = ExecuteState::WAITING;
721 groupManager.UpdateGroupState(groupId);
722
723 SequenceRunnerManager& runnerManager = SequenceRunnerManager::GetInstance();
724 napi_value obj = NapiHelper::CreateObject(env);
725 SequenceRunner* seqRunner = runnerManager.CreateOrGetGlobalRunner(env, obj, SIZE_THREE, "test", UINT32_ONE);
726 seqRunner->priority_ = Priority::MEDIUM;
727 runnerManager.CreateOrGetGlobalRunner(env, obj, SIZE_TWO, "test", UINT32_ZERO);
728 runnerManager.CreateOrGetGlobalRunner(env, obj, SIZE_TWO, "test", UINT32_ONE);
729 NativeEngineTest::RemoveSequenceRunnerByName("func");
730 NativeEngineTest::RemoveSequenceRunnerByName("test");
731 }
732
ReleaseWorkerHandles(napi_env env)733 void NativeEngineTest::ReleaseWorkerHandles(napi_env env)
734 {
735 ExceptionScope scope(env);
736 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
737 napi_env workerEnv = nullptr;
738 napi_create_runtime(env, &workerEnv);
739 worker->workerEnv_ = workerEnv;
740 NativeEngine* workerEngine = reinterpret_cast<NativeEngine*>(workerEnv);
741 uv_loop_t* loop = worker->GetWorkerLoop();
742 ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_,
743 NativeEngineTest::foo, worker);
744 ConcurrentHelper::UvHandleInit(loop, worker->debuggerOnPostTaskSignal_,
745 NativeEngineTest::foo, worker);
746 ConcurrentHelper::UvHandleInit(loop, worker->clearWorkerSignal_,
747 NativeEngineTest::foo, worker);
748 uv_async_t* req = new uv_async_t;
749 req->data = worker;
750 Worker::ReleaseWorkerHandles(req);
751 }
752
DebuggerOnPostTask(napi_env env)753 void NativeEngineTest::DebuggerOnPostTask(napi_env env)
754 {
755 ExceptionScope scope(env);
756 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
757 uv_loop_t* loop = worker->GetWorkerLoop();
758 ConcurrentHelper::UvHandleInit(loop, worker->debuggerOnPostTaskSignal_,
759 NativeEngineTest::foo, worker);
760 std::function<void()> myTask = []() {
761 return;
762 };
763 worker->DebuggerOnPostTask(std::move(myTask));
764 uv_async_t* req = new uv_async_t;
765 std::function<void()> myTask1 = []() {
766 return;
767 };
768 worker->debuggerQueue_.push(myTask1);
769 req->data = worker;
770 worker->debuggerMutex_.unlock();
771 Worker::HandleDebuggerTask(req);
772 worker->workerEnv_ = nullptr;
773 worker->ReleaseWorkerThreadContent();
774 napi_env workerEnv = nullptr;
775 napi_create_runtime(env, &workerEnv);
776 worker->workerEnv_ = workerEnv;
777 worker->hostEnv_ = nullptr;
778 worker->state_ = WorkerState::BLOCKED;
779 worker->ReleaseWorkerThreadContent();
780 napi_env workerEnv1 = nullptr;
781 napi_create_runtime(env, &workerEnv1);
782 worker->hostEnv_ = env;
783 worker->workerEnv_ = workerEnv1;
784 worker->state_ = WorkerState::IDLE;
785 worker->ReleaseWorkerThreadContent();
786 }
787
PerformTask(napi_env env)788 void NativeEngineTest::PerformTask(napi_env env)
789 {
790 ExceptionScope scope(env);
791 TaskManager& taskManager = TaskManager::GetInstance();
792 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
793 napi_env workerEnv = nullptr;
794 napi_create_runtime(env, &workerEnv);
795 worker->workerEnv_ = workerEnv;
796
797 TaskGroup* group = new TaskGroup();
798 uint64_t groupId = reinterpret_cast<uint64_t>(group);
799 group->groupState_ = ExecuteState::WAITING;
800 TaskGroupManager& groupManager = TaskGroupManager::GetInstance();
801 groupManager.StoreTaskGroup(groupId, group);
802
803 Task* task = new Task();
804 taskManager.StoreTask(task);
805 Priority priority = Priority::DEFAULT;
806 auto& mediumTaskQueue = taskManager.taskQueues_[priority];
807 uint32_t id = mediumTaskQueue->DequeueTaskId();
808 while (id != 0) {
809 id = mediumTaskQueue->DequeueTaskId();
810 }
811 mediumTaskQueue->EnqueueTaskId(task->taskId_);
812
813 uv_async_t* req = new uv_async_t;
814 req->data = worker;
815 task->taskState_ = ExecuteState::WAITING;
816 task->taskType_ = TaskType::GROUP_COMMON_TASK;
817 task->groupId_ = groupId;
818 Worker::PerformTask(req);
819 usleep(100000); // 100000: is sleep 100ms
820 }
821
NotifyHandleTaskResult(napi_env env)822 void NativeEngineTest::NotifyHandleTaskResult(napi_env env)
823 {
824 ExceptionScope scope(env);
825 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
826 Task* task = new Task();
827 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
828 task->env_ = worker->workerEnv_;
829 uv_loop_t* loop = worker->GetWorkerLoop();
830 Task* task1 = new Task();
831 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
832 worker->currentTaskId_.push_back(task1->taskId_);
833 task->worker_ = worker;
834 task->isMainThreadTask_ = true;
835 task->taskRefCount_.fetch_add(1);
836 TaskManager::GetInstance().StoreTask(task);
837 Worker::NotifyHandleTaskResult(task);
838 }
839
TaskResultCallback(napi_env env)840 void NativeEngineTest::TaskResultCallback(napi_env env)
841 {
842 ExceptionScope scope(env);
843 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
844 Task* task = new Task();
845 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
846 task->env_ = env;
847 task->taskRefCount_.fetch_add(1);
848 task->worker_ = worker;
849 task->cpuTime_ = UINT64_ZERO;
850 Worker::TaskResultCallback(worker->workerEnv_, nullptr, false, reinterpret_cast<void*>(task));
851 task->taskRefCount_.fetch_add(1);
852 task->cpuTime_ = task->taskId_;
853 Worker::TaskResultCallback(worker->workerEnv_, nullptr, true, reinterpret_cast<void*>(task));
854
855 worker->priority_ = Priority::LOW;
856 worker->ResetWorkerPriority();
857 TaskManager& taskManager = TaskManager::GetInstance();
858 taskManager.globalEnableFfrtFlag_ = true;
859 worker->priority_ = Priority::HIGH;
860 worker->ResetWorkerPriority();
861 taskManager.globalEnableFfrtFlag_ = false;
862 worker->state_ = WorkerState::BLOCKED;
863 worker->UpdateExecutedInfo();
864 worker->state_ = WorkerState::IDLE;
865 worker->UpdateExecutedInfo();
866
867 uint32_t id = task->taskId_ + MAX_TIMEOUT_TIME;
868 std::unordered_set<uint32_t> set{ task->taskId_, id };
869 worker->longTasksSet_ = std::move(set);
870 worker->TerminateTask(task->taskId_);
871 }
872
HandleFunctionResult(napi_env env)873 void NativeEngineTest::HandleFunctionResult(napi_env env)
874 {
875 ExceptionScope scope(env);
876 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
877 Task* task = new Task();
878 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
879 task->env_ = env;
880 task->IncreaseRefCount();
881 uv_loop_t* loop = NapiHelper::GetLibUV(env);
882 task->worker_ = worker;
883 Worker::HandleFunctionResult(env, task);
884 task->IncreaseRefCount();
885 Worker::HandleFunctionResult(env, task);
886 }
887
WorkerConstructor(napi_env env)888 void* NativeEngineTest::WorkerConstructor(napi_env env)
889 {
890 uint32_t sleepTime = 50000; // 50000: is sleep 50ms
891 Worker* worker = Worker::WorkerConstructor(env);
892 usleep(sleepTime);
893 uv_loop_t* loop = worker->GetWorkerLoop();
894 int num = 0;
895 while (loop == nullptr && num < 10) { // 10: is loop 10 times
896 usleep(sleepTime);
897 loop = worker->GetWorkerLoop();
898 num++;
899 }
900 ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);
901 return worker;
902 }
903
GetWorkerTid(uv_timer_t * handle)904 pid_t NativeEngineTest::GetWorkerTid(uv_timer_t* handle)
905 {
906 Worker* worker = reinterpret_cast<Worker*>(handle->data);
907 return worker->tid_;
908 }
909
WorkerPostTask(napi_env env)910 void NativeEngineTest::WorkerPostTask(napi_env env)
911 {
912 ExceptionScope scope(env);
913 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
914 std::function<void()> myTask = []() {
915 return;
916 };
917 usleep(100000); // 100000: is sleep 100ms
918 worker->CloseHandles();
919 usleep(100000); // 100000: is sleep 100ms
920 worker->debuggerOnPostTaskSignal_ = nullptr;
921 worker->DebuggerOnPostTask(std::move(myTask));
922 uv_async_t* req = new uv_async_t;
923 req->data = nullptr;
924 Worker::HandleDebuggerTask(req);
925 worker->IsLoopActive();
926 worker->NotifyExecuteTask();
927 Worker::TriggerGCCheck(nullptr);
928 Worker::TriggerGCCheck(req);
929 worker->NotifyTaskFinished();
930 worker->PostReleaseSignal();
931 }
932
ResetTaskManager()933 void NativeEngineTest::ResetTaskManager()
934 {
935 TaskManager& taskManager = TaskManager::GetInstance();
936 taskManager.workers_.clear();
937 taskManager.idleWorkers_.clear();
938 taskManager.timeoutWorkers_.clear();
939 taskManager.highPrioExecuteCount_ = 0;
940 taskManager.mediumPrioExecuteCount_ = 0;
941 }
942
CheckAndCreateAsyncRunner(napi_env env,napi_value name,napi_value runningCapacity,napi_value waitingCapacity)943 void NativeEngineTest::CheckAndCreateAsyncRunner(napi_env env, napi_value name, napi_value runningCapacity,
944 napi_value waitingCapacity)
945 {
946 napi_value thisVar = nullptr;
947 AsyncRunner::CheckAndCreateAsyncRunner(env, thisVar, name, runningCapacity, waitingCapacity);
948 }
949
AsyncRunnerDestructor(napi_env env,void * data)950 void NativeEngineTest::AsyncRunnerDestructor(napi_env env, void* data)
951 {
952 void* hint = nullptr;
953 AsyncRunner::AsyncRunnerDestructor(env, data, hint);
954 }
955
AddTasksToAsyncRunner(void * asyncData,void * taskData)956 void NativeEngineTest::AddTasksToAsyncRunner(void* asyncData, void* taskData)
957 {
958 AsyncRunner* async = reinterpret_cast<AsyncRunner*>(asyncData);
959 Task* task = reinterpret_cast<Task*>(taskData);
960 AsyncRunner::AddTasksToAsyncRunner(async, task);
961 }
962
RemoveSequenceRunnerByName(std::string name)963 void NativeEngineTest::RemoveSequenceRunnerByName(std::string name)
964 {
965 SequenceRunnerManager::GetInstance().RemoveSequenceRunnerByName(name);
966 }
967
RemoveSequenceRunner(uint64_t seqId)968 void NativeEngineTest::RemoveSequenceRunner(uint64_t seqId)
969 {
970 SequenceRunnerManager::GetInstance().RemoveSequenceRunner(seqId);
971 }
972
StoreTaskId(Worker * worker,uint32_t taskId)973 void NativeEngineTest::StoreTaskId(Worker* worker, uint32_t taskId)
974 {
975 auto& container = worker->currentTaskId_;
976 container.push_back(taskId);
977 }
978
RemoveTaskId(Worker * worker,uint32_t taskId)979 void NativeEngineTest::RemoveTaskId(Worker* worker, uint32_t taskId)
980 {
981 auto& container = worker->currentTaskId_;
982 auto iter = std::find(container.begin(), container.end(), taskId);
983 if (iter != container.end()) {
984 container.erase(iter);
985 }
986 }
987
FindTaskId(Worker * worker,uint32_t taskId)988 bool NativeEngineTest::FindTaskId(Worker* worker, uint32_t taskId)
989 {
990 auto& container = worker->currentTaskId_;
991 return std::find(container.begin(), container.end(), taskId) != container.end();
992 }
993
PerformTask(napi_env env,void * data)994 void NativeEngineTest::PerformTask(napi_env env, void* data)
995 {
996 TaskManager& taskManager = TaskManager::GetInstance();
997 uint32_t id = 0;
998 for (size_t i = 0; i < taskManager.taskQueues_.size(); i++) {
999 id = taskManager.taskQueues_[i]->DequeueTaskId();
1000 while (id != 0) {
1001 id = taskManager.taskQueues_[i]->DequeueTaskId();
1002 }
1003 }
1004 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
1005 napi_env workerEnv = nullptr;
1006 napi_create_runtime(env, &workerEnv);
1007 worker->workerEnv_ = workerEnv;
1008 Task* task = reinterpret_cast<Task*>(data);
1009 if (task != nullptr) {
1010 taskManager.StoreTask(task);
1011 taskManager.SetIsPerformIdle(false);
1012 taskManager.taskQueues_[task->asyncTaskPriority_]->EnqueueTaskId(task->taskId_);
1013 }
1014 uv_async_t* req = new uv_async_t;
1015 req->data = worker;
1016 Worker::PerformTask(req);
1017 usleep(100000); // 100000: is sleep 100ms
1018 }
1019
GetIdleTaskByPriority(napi_env env)1020 void NativeEngineTest::GetIdleTaskByPriority(napi_env env)
1021 {
1022 TaskManager& taskManager = TaskManager::GetInstance();
1023 uint32_t id = 0;
1024 for (size_t i = 0; i < taskManager.taskQueues_.size(); i++) {
1025 id = taskManager.taskQueues_[i]->DequeueTaskId();
1026 while (id != 0) {
1027 id = taskManager.taskQueues_[i]->DequeueTaskId();
1028 }
1029 }
1030 Task* task = new Task();
1031 taskManager.StoreTask(task);
1032 auto& taskQueue = taskManager.taskQueues_[Priority::IDLE];
1033 taskQueue->EnqueueTaskId(task->taskId_);
1034 taskManager.GetTaskByPriority(taskQueue, Priority::IDLE);
1035 taskManager.SetIsPerformIdle(false);
1036 taskManager.tasks_.clear();
1037 delete task;
1038 }
1039
WorkerRunningScope(napi_env env)1040 void NativeEngineTest::WorkerRunningScope(napi_env env)
1041 {
1042 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
1043 worker->priority_ = Priority::IDLE;
1044 worker->workerEnv_ = env;
1045 Worker::RunningScope runningScope(worker);
1046 }
1047
SetNonIdleTaskNum(uint32_t num)1048 void NativeEngineTest::SetNonIdleTaskNum(uint32_t num)
1049 {
1050 TaskManager& taskManager = TaskManager::GetInstance();
1051 taskManager.nonIdleTaskNum_ = num;
1052 }
1053
EnqueueTaskIdToQueue(void * data)1054 void NativeEngineTest::EnqueueTaskIdToQueue(void* data)
1055 {
1056 TaskManager& taskManager = TaskManager::GetInstance();
1057 Task* task = reinterpret_cast<Task*>(data);
1058 auto& taskQueue = taskManager.taskQueues_[task->asyncTaskPriority_];
1059 taskQueue->EnqueueTaskId(task->taskId_);
1060 }
1061
DecreaseTaskNum()1062 void NativeEngineTest::DecreaseTaskNum()
1063 {
1064 TaskManager& taskManager = TaskManager::GetInstance();
1065 taskManager.nonIdleTaskNum_ = 1;
1066 taskManager.DecreaseTaskNum(Priority::IDLE);
1067 taskManager.nonIdleTaskNum_ = 0;
1068 taskManager.DecreaseTaskNum(Priority::HIGH);
1069 }
1070
ResetPerformIdleState(napi_env env)1071 void NativeEngineTest::ResetPerformIdleState(napi_env env)
1072 {
1073 Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));
1074 worker->priority_ = Priority::IDLE;
1075 worker->workerEnv_ = env;
1076 worker->ResetPerformIdleState();
1077 }
1078
SetTotalTaskNum(uint32_t num)1079 void NativeEngineTest::SetTotalTaskNum(uint32_t num)
1080 {
1081 TaskManager& taskManager = TaskManager::GetInstance();
1082 taskManager.totalTaskNum_ = num;
1083 }
1084
ExecuteOnReceiveDataCallback(void * callbackInfo,void * resultInfo)1085 void NativeEngineTest::ExecuteOnReceiveDataCallback(void* callbackInfo, void* resultInfo)
1086 {
1087 CallbackInfo* cbInfo = reinterpret_cast<CallbackInfo*>(callbackInfo);
1088 TaskResultInfo* resInfo = reinterpret_cast<TaskResultInfo*>(resultInfo);
1089 TaskPool::ExecuteOnReceiveDataCallback(cbInfo, resInfo);
1090 }
1091
TriggerTask(void * data,bool isCancel)1092 void NativeEngineTest::TriggerTask(void* data, bool isCancel)
1093 {
1094 Task* task = reinterpret_cast<Task*>(data);
1095 TaskPool::TriggerTask(task, isCancel);
1096 }
1097 } // namespace Commonlibrary::Concurrent::TaskPoolModule