Lines Matching refs:task
117 for (auto& [_, task] : tasks_) {
118 delete task;
119 task = nullptr;
182 for (const auto& [_, task] : tasks_) {
183 if (task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::DELAYED ||
184 task->taskState_ == ExecuteState::FINISHED) {
188 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
189 napi_value taskId = NapiHelper::CreateUint32(env, task->taskId_);
191 napi_create_string_utf8(env, task->name_.c_str(), task->name_.size(), &name);
193 ExecuteState state = task->taskState_;
196 duration = ConcurrentHelper::GetMilliseconds() - task->startTime_;
254 // When executing the promise task, the worker state may not be updated and will be
257 // the task like I/O in uv threads, we should also exclude this situation.
297 // read /proc/[pid]/task/[tid]/stat to get the number of idle threads.
303 int ret = snprintf_s(path, sizeof(path), sizeof(path) - 1, "/proc/%d/task/%d/stat", pid, tid);
518 // dispatch task in the TaskPoolManager thread
596 Task* task = GetTask(taskId);
597 if (task == nullptr) {
598 std::string errMsg = "taskpool:: the task may not exist";
603 if (task->taskState_ == ExecuteState::CANCELED) {
604 HILOG_DEBUG("taskpool:: task has been canceled");
607 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
608 if (task->IsPeriodicTask()) {
609 task->CancelPendingTask(env);
610 uv_timer_stop(task->timer_);
611 uv_close(reinterpret_cast<uv_handle_t*>(task->timer_), [](uv_handle_t* handle) {
616 } else if (task->IsSeqRunnerTask()) {
617 CancelSeqRunnerTask(env, task);
620 if ((task->currentTaskInfo_ == nullptr && task->taskState_ != ExecuteState::DELAYED) ||
621 task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED ||
622 task->taskState_ == ExecuteState::ENDING) {
623 std::string errMsg = "taskpool:: task is not executed or has been executed";
629 task->ClearDelayedTimers();
630 ExecuteState state = task->taskState_.exchange(ExecuteState::CANCELED);
631 task->CancelPendingTask(env);
632 if (state == ExecuteState::WAITING && task->currentTaskInfo_ != nullptr) {
634 task->DecreaseTaskRefCount();
635 EraseWaitingTaskId(task->taskId_, task->currentTaskInfo_->priority);
636 napi_value error = ErrorHelper::NewError(env, 0, "taskpool:: task has been canceled");
637 napi_reject_deferred(env, task->currentTaskInfo_->deferred, error);
638 napi_reference_unref(env, task->taskRef_, nullptr);
639 delete task->currentTaskInfo_;
640 task->currentTaskInfo_ = nullptr;
644 void TaskManager::CancelSeqRunnerTask(napi_env env, Task *task)
646 if (task->taskState_ == ExecuteState::FINISHED) {
647 std::string errMsg = "taskpool:: sequenceRunner task has been executed";
651 task->taskState_ = ExecuteState::CANCELED;
746 Task* task = GetTask(taskId);
747 if (task == nullptr) {
748 HILOG_FATAL("taskpool:: task is nullptr");
751 task->IncreaseTaskRefCount();
752 if (task->onEnqueuedCallBackInfo_ != nullptr) {
753 task->ExecuteListenerCallback(task->onEnqueuedCallBackInfo_);
802 // If there is a worker running a task, do not take the idle task.
805 // Only when all workers are free, will idle task be taken.
950 auto task = reinterpret_cast<Task*>(taskId);
951 if (!task->IsValid()) {
962 napi_value TaskManager::NotifyCallbackExecute(napi_env env, TaskResultInfo* resultInfo, Task* task)
964 HILOG_DEBUG("taskpool:: task:%{public}s NotifyCallbackExecute", std::to_string(task->taskId_).c_str());
966 auto iter = callbackTable_.find(task->taskId_);
973 Worker* worker = static_cast<Worker*>(task->worker_);
974 worker->Enqueue(task->env_, resultInfo);
981 if (task->IsMainThreadTask()) {
1028 HILOG_DEBUG("taskpool:: task:%{public}s NotifyDependencyTaskInfo", std::to_string(taskId).c_str());
1048 HILOG_DEBUG("taskpool::task:%{public}s RemoveDependencyById", std::to_string(taskId).c_str());
1049 // remove dependency after task execute
1082 HILOG_DEBUG("taskpool:: task:%{public}s StoreTaskDependency", std::to_string(taskId).c_str());
1136 HILOG_DEBUG("taskpool:: task:%{public}s RemoveTaskDependency", std::to_string(taskId).c_str());
1179 HILOG_DEBUG("taskpool:: task:%{public}s RemovePendingTaskInfo", std::to_string(taskId).c_str());
1186 HILOG_DEBUG("taskpool:: task:%{public}s StoreDependentTaskInfo", std::to_string(taskId).c_str());
1201 HILOG_DEBUG("taskpool:: task:%{public}s RemoveDependentTaskInfo", std::to_string(taskId).c_str());
1229 HILOG_DEBUG("taskpool:: task:%{public}s StoreTaskDuration", std::to_string(taskId).c_str());
1264 HILOG_DEBUG("taskpool:: task:%{public}s RemoveTaskDuration", std::to_string(taskId).c_str());
1293 HILOG_DEBUG("taskpool:: task:%{public}s TerminateTask", std::to_string(taskId).c_str());
1302 void TaskManager::ReleaseTaskData(napi_env env, Task* task, bool shouldDeleteTask)
1304 uint64_t taskId = task->taskId_;
1308 if (task->onResultSignal_ != nullptr) {
1309 if (!uv_is_closing((uv_handle_t*)task->onResultSignal_)) {
1310 ConcurrentHelper::UvHandleClose(task->onResultSignal_);
1312 delete task->onResultSignal_;
1314 task->onResultSignal_ = nullptr;
1317 if (task->currentTaskInfo_ != nullptr) {
1318 delete task->currentTaskInfo_;
1319 task->currentTaskInfo_ = nullptr;
1322 task->CancelPendingTask(env);
1324 task->ClearDelayedTimers();
1326 if (task->IsFunctionTask() || task->IsGroupFunctionTask()) {
1332 ReleaseCallBackInfo(task);
1350 void TaskManager::ReleaseCallBackInfo(Task* task)
1352 HILOG_DEBUG("taskpool:: ReleaseCallBackInfo task:%{public}s", std::to_string(task->taskId_).c_str());
1353 if (task->onEnqueuedCallBackInfo_ != nullptr) {
1354 delete task->onEnqueuedCallBackInfo_;
1355 task->onEnqueuedCallBackInfo_ = nullptr;
1358 if (task->onStartExecutionCallBackInfo_ != nullptr) {
1359 delete task->onStartExecutionCallBackInfo_;
1360 task->onStartExecutionCallBackInfo_ = nullptr;
1363 if (task->onExecutionFailedCallBackInfo_ != nullptr) {
1364 delete task->onExecutionFailedCallBackInfo_;
1365 task->onExecutionFailedCallBackInfo_ = nullptr;
1368 if (task->onExecutionSucceededCallBackInfo_ != nullptr) {
1369 delete task->onExecutionSucceededCallBackInfo_;
1370 task->onExecutionSucceededCallBackInfo_ = nullptr;
1374 if (!task->IsMainThreadTask() && task->onStartExecutionSignal_ != nullptr) {
1375 if (!uv_is_closing((uv_handle_t*)task->onStartExecutionSignal_)) {
1376 ConcurrentHelper::UvHandleClose(task->onStartExecutionSignal_);
1378 delete task->onStartExecutionSignal_;
1380 task->onStartExecutionSignal_ = nullptr;
1383 if (task->onStartExecutionSignal_ != nullptr) {
1384 if (!uv_is_closing((uv_handle_t*)task->onStartExecutionSignal_)) {
1385 ConcurrentHelper::UvHandleClose(task->onStartExecutionSignal_);
1387 delete task->onStartExecutionSignal_;
1389 task->onStartExecutionSignal_ = nullptr;
1394 void TaskManager::StoreTask(uint64_t taskId, Task* task)
1397 tasks_.emplace(taskId, task);
1446 bool TaskManager::PostTask(std::function<void()> task, const char* taskName, Priority priority)
1448 return mainThreadHandler_->PostTask(task, taskName, 0, TASK_EVENTHANDLER_PRIORITY_MAP.at(priority));
1489 Task* task = TaskManager::GetInstance().GetTask(taskId);
1490 if (task == nullptr || !task->IsValid()) {
1493 napi_reference_unref(task->env_, task->taskRef_, nullptr);
1548 HILOG_DEBUG("taskpool:: CancelGroupTask task:%{public}s", std::to_string(taskId).c_str());
1549 auto task = TaskManager::GetInstance().GetTask(taskId);
1550 if (task == nullptr) {
1551 HILOG_INFO("taskpool:: CancelGroupTask task is nullptr");
1554 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
1555 if (task->taskState_ == ExecuteState::WAITING && task->currentTaskInfo_ != nullptr) {
1557 task->DecreaseTaskRefCount();
1558 TaskManager::GetInstance().EraseWaitingTaskId(task->taskId_, task->currentTaskInfo_->priority);
1559 delete task->currentTaskInfo_;
1560 task->currentTaskInfo_ = nullptr;
1562 task->taskState_ = ExecuteState::CANCELED;
1588 void TaskGroupManager::AddTaskToSeqRunner(uint64_t seqRunnerId, Task* task)
1597 iter->second->seqRunnerTasks_.push(task);
1614 HILOG_ERROR("seqRunner:: only front task can trigger seqRunner.");
1624 Task* task = seqRunner->seqRunnerTasks_.front();
1626 while (task->taskState_ == ExecuteState::CANCELED) {
1627 DisposeCanceledTask(env, task);
1634 task = seqRunner->seqRunnerTasks_.front();
1637 seqRunner->currentTaskId_ = task->taskId_;
1638 task->IncreaseRefCount();
1639 task->taskState_ = ExecuteState::WAITING;
1640 HILOG_DEBUG("seqRunner:: Trigger task %{public}s in seqRunner %{public}s.",
1641 std::to_string(task->taskId_).c_str(), std::to_string(seqRunnerId).c_str());
1642 TaskManager::GetInstance().EnqueueTaskId(task->taskId_, seqRunner->priority_);
1647 void TaskGroupManager::DisposeCanceledTask(napi_env env, Task* task)
1649 napi_value error = ErrorHelper::NewError(env, 0, "taskpool:: sequenceRunner task has been canceled");
1650 napi_reject_deferred(env, task->currentTaskInfo_->deferred, error);
1652 napi_reference_unref(env, task->taskRef_, nullptr);
1653 delete task->currentTaskInfo_;
1654 task->currentTaskInfo_ = nullptr;