Lines Matching refs:taskId

152             napi_value taskId = nullptr;
153             napi_create_array(env, &taskId);
159                     napi_set_element(env, taskId, j, id);
167             napi_set_named_property(env, threadInfo, "taskIds", taskId);
189             napi_value taskId = NapiHelper::CreateUint32(env, task->taskId_);
199             napi_set_named_property(env, taskInfoValue, "taskId", taskId);
587 void TaskManager::CancelTask(napi_env env, uint64_t taskId)
593     std::string strTrace = "CancelTask: taskId: " + std::to_string(taskId);
596     Task* task = GetTask(taskId);
738 void TaskManager::EnqueueTaskId(uint64_t taskId, Priority priority)
743         taskQueues_[priority]->EnqueueTaskId(taskId);
746     Task* task = GetTask(taskId);
757 void TaskManager::EraseWaitingTaskId(uint64_t taskId, Priority priority)
760     if (!taskQueues_[priority]->EraseWaitingTaskId(taskId)) {
761         HILOG_WARN("taskpool:: taskId is not in executeQueue when cancel");
812     uint64_t taskId = taskQueue->DequeueTaskId();
813     if (IsDependendByTaskId(taskId)) {
814         EnqueuePendingTaskInfo(taskId, priority);
818     return std::make_pair(taskId, priority);
909 void TaskManager::RegisterCallback(napi_env env, uint64_t taskId, std::shared_ptr<CallbackInfo> callbackInfo)
912     callbackTable_[taskId] = callbackInfo;
915 std::shared_ptr<CallbackInfo> TaskManager::GetCallbackInfo(uint64_t taskId)
918     auto iter = callbackTable_.find(taskId);
926 void TaskManager::IncreaseRefCount(uint64_t taskId)
928     if (taskId == 0) { // do not support func
932     auto iter = callbackTable_.find(taskId);
939 void TaskManager::DecreaseRefCount(napi_env env, uint64_t taskId)
941     if (taskId == 0) { // do not support func
945     auto iter = callbackTable_.find(taskId);
950     auto task = reinterpret_cast<Task*>(taskId);
1026 void TaskManager::NotifyDependencyTaskInfo(uint64_t taskId)
1028     HILOG_DEBUG("taskpool:: task:%{public}s NotifyDependencyTaskInfo", std::to_string(taskId).c_str());
1031     auto iter = dependentTaskInfos_.find(taskId);
1038         RemoveDependencyById(taskId, *taskIdIter);
1046 void TaskManager::RemoveDependencyById(uint64_t dependentTaskId, uint64_t taskId)
1048     HILOG_DEBUG("taskpool::task:%{public}s RemoveDependencyById", std::to_string(taskId).c_str());
1051     auto dependTaskIter = dependTaskInfos_.find(taskId);
1060 bool TaskManager::IsDependendByTaskId(uint64_t taskId)
1063     auto iter = dependTaskInfos_.find(taskId);
1080 bool TaskManager::StoreTaskDependency(uint64_t taskId, std::set<uint64_t> taskIdSet)
1082     HILOG_DEBUG("taskpool:: task:%{public}s StoreTaskDependency", std::to_string(taskId).c_str());
1083     StoreDependentTaskInfo(taskIdSet, taskId);
1085     auto iter = dependTaskInfos_.find(taskId);
1092             if (!CheckCircularDependency(taskIdSet, idIter->second, taskId)) {
1096         dependTaskInfos_.emplace(taskId, std::move(taskIdSet));
1105         if (!CheckCircularDependency(iter->second, idIter->second, taskId)) {
1113 bool TaskManager::CheckCircularDependency(std::set<uint64_t> dependentIdSet, std::set<uint64_t> idSet, uint64_t taskId)
1116         if (id == taskId) {
1127         if (!CheckCircularDependency(dependentIdSet, dIter->second, taskId)) {
1134 bool TaskManager::RemoveTaskDependency(uint64_t taskId, uint64_t dependentId)
1136     HILOG_DEBUG("taskpool:: task:%{public}s RemoveTaskDependency", std::to_string(taskId).c_str());
1137     RemoveDependentTaskInfo(dependentId, taskId);
1139     auto iter = dependTaskInfos_.find(taskId);
1151 void TaskManager::EnqueuePendingTaskInfo(uint64_t taskId, Priority priority)
1153     if (taskId == 0) {
1157     pendingTaskInfos_.emplace(taskId, priority);
1160 std::pair<uint64_t, Priority> TaskManager::DequeuePendingTaskInfo(uint64_t taskId)
1168         if (it->first == taskId) {
1177 void TaskManager::RemovePendingTaskInfo(uint64_t taskId)
1179     HILOG_DEBUG("taskpool:: task:%{public}s RemovePendingTaskInfo", std::to_string(taskId).c_str());
1181     pendingTaskInfos_.erase(taskId);
1184 void TaskManager::StoreDependentTaskInfo(std::set<uint64_t> dependentTaskIdSet, uint64_t taskId)
1186     HILOG_DEBUG("taskpool:: task:%{public}s StoreDependentTaskInfo", std::to_string(taskId).c_str());
1191             std::set<uint64_t> set{taskId};
1194             iter->second.emplace(taskId);
1199 void TaskManager::RemoveDependentTaskInfo(uint64_t dependentTaskId, uint64_t taskId)
1201     HILOG_DEBUG("taskpool:: task:%{public}s RemoveDependentTaskInfo", std::to_string(taskId).c_str());
1207     auto taskIter = iter->second.find(taskId);
1214 std::string TaskManager::GetTaskDependInfoToString(uint64_t taskId)
1217     std::string str = "TaskInfos: taskId: " + std::to_string(taskId) + ", dependTaskId:";
1218     auto iter = dependTaskInfos_.find(taskId);
1227 void TaskManager::StoreTaskDuration(uint64_t taskId, uint64_t totalDuration, uint64_t cpuDuration)
1229     HILOG_DEBUG("taskpool:: task:%{public}s StoreTaskDuration", std::to_string(taskId).c_str());
1231     auto iter = taskDurationInfos_.find(taskId);
1234         taskDurationInfos_.emplace(taskId, std::move(durationData));
1245 uint64_t TaskManager::GetTaskDuration(uint64_t taskId, std::string durationType)
1248     auto iter = taskDurationInfos_.find(taskId);
1262 void TaskManager::RemoveTaskDuration(uint64_t taskId)
1264     HILOG_DEBUG("taskpool:: task:%{public}s RemoveTaskDuration", std::to_string(taskId).c_str());
1266     auto iter = taskDurationInfos_.find(taskId);
1272 void TaskManager::StoreLongTaskInfo(uint64_t taskId, Worker* worker)
1275     longTasksMap_.emplace(taskId, worker);
1278 void TaskManager::RemoveLongTaskInfo(uint64_t taskId)
1281     longTasksMap_.erase(taskId);
1284 Worker* TaskManager::GetLongTaskInfo(uint64_t taskId)
1287     auto iter = longTasksMap_.find(taskId);
1291 void TaskManager::TerminateTask(uint64_t taskId)
1293     HILOG_DEBUG("taskpool:: task:%{public}s TerminateTask", std::to_string(taskId).c_str());
1294     auto worker = GetLongTaskInfo(taskId);
1298     worker->TerminateTask(taskId);
1299     RemoveLongTaskInfo(taskId);
1304     uint64_t taskId = task->taskId_;
1306         RemoveTask(taskId);
1329     DecreaseRefCount(env, taskId);
1330     RemoveTaskDuration(taskId);
1331     RemovePendingTaskInfo(taskId);
1336             if (dependentTaskIter->second.find(taskId) != dependentTaskIter->second.end()) {
1344     auto dependTaskIter = dependTaskInfos_.find(taskId);
1394 void TaskManager::StoreTask(uint64_t taskId, Task* task)
1397     tasks_.emplace(taskId, task);
1400 void TaskManager::RemoveTask(uint64_t taskId)
1403     tasks_.erase(taskId);
1406 Task* TaskManager::GetTask(uint64_t taskId)
1409     auto iter = tasks_.find(taskId);
1452 bool TaskManager::CheckTask(uint64_t taskId)
1455     auto item = tasks_.find(taskId);
1466 void TaskGroupManager::AddTask(uint64_t groupId, napi_ref taskRef, uint64_t taskId)
1481     taskGroup->taskIds_.push_back(taskId);
1488     for (uint64_t taskId : group->taskIds_) {
1489         Task* task = TaskManager::GetInstance().GetTask(taskId);
1528         for (uint64_t taskId : taskGroup->taskIds_) {
1529             CancelGroupTask(env, taskId, taskGroup);
1546 void TaskGroupManager::CancelGroupTask(napi_env env, uint64_t taskId, TaskGroup* group)
1548     HILOG_DEBUG("taskpool:: CancelGroupTask task:%{public}s", std::to_string(taskId).c_str());
1549     auto task = TaskManager::GetInstance().GetTask(taskId);