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
17 #include "sequence_runner_manager.h"
18
19 #include "helper/error_helper.h"
20 #include "helper/hitrace_helper.h"
21 #include "sequence_runner.h"
22 #include "task_manager.h"
23
24 namespace Commonlibrary::Concurrent::TaskPoolModule {
25 using namespace Commonlibrary::Concurrent::Common::Helper;
26
GetInstance()27 SequenceRunnerManager& SequenceRunnerManager::GetInstance()
28 {
29 static SequenceRunnerManager sequenceRunnerManager;
30 return sequenceRunnerManager;
31 }
32
CreateOrGetGlobalRunner(napi_env env,napi_value thisVar,size_t argc,const std::string & name,uint32_t priority)33 SequenceRunner* SequenceRunnerManager::CreateOrGetGlobalRunner(napi_env env, napi_value thisVar, size_t argc,
34 const std::string& name, uint32_t priority)
35 {
36 SequenceRunner* seqRunner = nullptr;
37 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
38 auto iter = globalSeqRunner_.find(name);
39 if (iter == globalSeqRunner_.end()) {
40 Priority priorityVal = Priority::DEFAULT;
41 if (argc == 2) { // 2: The number of parameters is 2.
42 priorityVal = static_cast<Priority>(priority);
43 }
44 seqRunner = new SequenceRunner(priorityVal, name, true);
45 globalSeqRunner_.emplace(name, seqRunner);
46 return seqRunner;
47 }
48
49 seqRunner = iter->second;
50 if (priority != seqRunner->priority_) {
51 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "seqRunner:: priority can not changed.");
52 return nullptr;
53 }
54 seqRunner->IncreaseSeqCount();
55
56 return seqRunner;
57 }
58
RemoveSequenceRunnerByName(const std::string & name)59 void SequenceRunnerManager::RemoveSequenceRunnerByName(const std::string& name)
60 {
61 auto iter = globalSeqRunner_.find(name.c_str());
62 if (iter != globalSeqRunner_.end()) {
63 globalSeqRunner_.erase(iter->first);
64 }
65 }
66
SequenceRunnerDestructor(SequenceRunner * seqRunner)67 void SequenceRunnerManager::SequenceRunnerDestructor(SequenceRunner* seqRunner)
68 {
69 auto runner = GetSeqRunner(seqRunner->seqRunnerId_);
70 if (runner == nullptr) {
71 return;
72 }
73 UnrefAndDestroyRunner(seqRunner);
74 }
75
StoreSequenceRunner(uint64_t seqRunnerId,SequenceRunner * seqRunner)76 void SequenceRunnerManager::StoreSequenceRunner(uint64_t seqRunnerId, SequenceRunner* seqRunner)
77 {
78 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
79 seqRunners_.emplace(seqRunnerId, seqRunner);
80 }
81
RemoveSequenceRunner(uint64_t seqRunnerId)82 void SequenceRunnerManager::RemoveSequenceRunner(uint64_t seqRunnerId)
83 {
84 seqRunners_.erase(seqRunnerId);
85 }
86
GetSeqRunner(uint64_t seqRunnerId)87 SequenceRunner* SequenceRunnerManager::GetSeqRunner(uint64_t seqRunnerId)
88 {
89 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
90 auto iter = seqRunners_.find(seqRunnerId);
91 if (iter != seqRunners_.end()) {
92 return iter->second;
93 }
94 HILOG_DEBUG("taskpool:: sequenceRunner has been released.");
95 return nullptr;
96 }
97
AddTaskToSeqRunner(uint64_t seqRunnerId,Task * task)98 void SequenceRunnerManager::AddTaskToSeqRunner(uint64_t seqRunnerId, Task* task)
99 {
100 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
101 auto iter = seqRunners_.find(seqRunnerId);
102 if (iter == seqRunners_.end()) {
103 HILOG_ERROR("seqRunner:: seqRunner not found.");
104 return;
105 } else {
106 iter->second->AddTask(task);
107 }
108 }
109
TriggerSeqRunner(napi_env env,Task * lastTask)110 bool SequenceRunnerManager::TriggerSeqRunner(napi_env env, Task* lastTask)
111 {
112 uint64_t seqRunnerId = lastTask->seqRunnerId_;
113 SequenceRunner* seqRunner = GetSeqRunner(seqRunnerId);
114 if (seqRunner == nullptr) {
115 HILOG_ERROR("taskpool:: trigger seqRunner not exist.");
116 return false;
117 }
118 if (UnrefAndDestroyRunner(seqRunner)) {
119 HILOG_WARN("taskpool:: trigger seqRunner is removed.");
120 return false;
121 }
122 if (seqRunner->currentTaskId_ != lastTask->taskId_) {
123 HILOG_ERROR("taskpool:: only front task can trigger seqRunner.");
124 return false;
125 }
126 seqRunner->TriggerTask(env);
127 return true;
128 }
129
RemoveWaitingTask(Task * task)130 void SequenceRunnerManager::RemoveWaitingTask(Task* task)
131 {
132 auto seqRunner = GetSeqRunner(task->seqRunnerId_);
133 if (seqRunner == nullptr) {
134 return;
135 }
136 if (seqRunner->RemoveWaitingTask(task)) {
137 UnrefAndDestroyRunner(seqRunner);
138 }
139 }
140
FindRunnerAndRef(uint64_t seqRunnerId)141 bool SequenceRunnerManager::FindRunnerAndRef(uint64_t seqRunnerId)
142 {
143 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
144 auto iter = seqRunners_.find(seqRunnerId);
145 if (iter == seqRunners_.end()) {
146 HILOG_ERROR("taskpool:: seqRunner not exist.");
147 return false;
148 }
149 iter->second->IncreaseSeqCount();
150 return true;
151 }
152
UnrefAndDestroyRunner(SequenceRunner * seqRunner)153 bool SequenceRunnerManager::UnrefAndDestroyRunner(SequenceRunner* seqRunner)
154 {
155 std::unique_lock<std::mutex> lock(seqRunnersMutex_);
156 if (seqRunner->DecreaseSeqCount() != 0) {
157 return false;
158 }
159 RemoveSequenceRunner(seqRunner->seqRunnerId_);
160
161 if (seqRunner->isGlobalRunner_) {
162 RemoveSequenceRunnerByName(seqRunner->seqName_);
163 }
164 delete seqRunner;
165 return true;
166 }
167 } // namespace Commonlibrary::Concurrent::TaskPoolModule