Lines Matching refs:task
16 #include "task.h"
47 errMessage = "taskpool:: create task need more than one param";
58 // if the first is task name, the second might be func
70 errMessage = "taskpool:: the first or second param of task must be function";
73 "the type of the first or second param of task must be function.");
77 Task* task = GenerateTask(env, thisVar, func, name, args, argc);
78 TaskManager::GetInstance().StoreTask(task->taskId_, task);
79 napi_wrap(env, thisVar, task, TaskDestructor, nullptr, nullptr);
80 napi_create_reference(env, thisVar, 0, &task->taskRef_);
81 if (!task->IsMainThreadTask()) {
82 napi_add_env_cleanup_hook(env, Task::CleanupHookFunc, task);
90 Task* task;
91 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
92 task->isLongTask_ = true;
98 Task* task = static_cast<Task*>(data);
99 HILOG_INFO("taskpool:: taskId:%{public}s TaskDestructor", std::to_string(task->taskId_).c_str());
100 if (!task->IsMainThreadTask()) {
101 napi_remove_env_cleanup_hook(env, Task::CleanupHookFunc, task);
104 if (task->IsMainThreadTask() || task->refCount_ == 0) {
105 TaskManager::GetInstance().ReleaseTaskData(env, task);
106 napi_delete_reference(env, task->taskRef_);
107 delete task;
112 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
113 task->SetValid(false);
114 if (task->refCount_ == 0) {
117 TaskManager::GetInstance().ReleaseTaskData(env, task, shouldDelete);
118 napi_delete_reference(env, task->taskRef_);
121 delete task;
131 Task* task = static_cast<Task*>(arg);
132 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
133 if (task->onResultSignal_ != nullptr) {
134 uv_close(reinterpret_cast<uv_handle_t*>(task->onResultSignal_), nullptr);
136 if (task->onStartExecutionSignal_ != nullptr) {
137 uv_close(reinterpret_cast<uv_handle_t*>(task->onStartExecutionSignal_), nullptr);
139 if (task->IsFunctionTask()) {
140 task->SetValid(false);
147 HILOG_DEBUG("taskpool:: task GenerateTask");
156 Task* task = new Task(env, TaskType::TASK, nameStr);
158 task->taskId_ = reinterpret_cast<uint64_t>(task);
159 task->InitHandle(env);
161 napi_value taskId = NapiHelper::CreateUint64(env, task->taskId_);
182 return task;
187 HILOG_DEBUG("taskpool:: task GenerateFunctionTask");
196 HILOG_ERROR("taskpool:: task GenerateFunctionTask end, taskInfo is nullptr");
201 Task* task = new Task(env, type, nameStr);
203 task->taskId_ = reinterpret_cast<uint64_t>(task);
204 task->currentTaskInfo_ = taskInfo;
205 task->InitHandle(env);
206 if (!task->IsMainThreadTask()) {
207 napi_add_env_cleanup_hook(env, CleanupHookFunc, task);
209 return task;
212 napi_value Task::GetTaskInfoPromise(napi_env env, napi_value task, TaskType taskType, Priority priority)
214 TaskInfo* taskInfo = GetTaskInfo(env, task, priority);
227 std::string errMessage = "taskpool:: task value is error";
276 Task* task = nullptr;
277 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
278 if (task == nullptr) {
279 HILOG_ERROR("taskpool:: task is nullptr");
285 HILOG_DEBUG("taskpool:: set task params not transfer");
287 // set task.defaultTransfer false
288 task->defaultTransfer_ = false;
296 // set task.defaultTransfer false
297 task->defaultTransfer_ = false;
300 HILOG_DEBUG("taskpool:: set task params not transfer");
336 Task* task = nullptr;
337 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
338 if (task == nullptr) {
339 HILOG_ERROR("taskpool:: task is nullptr");
369 // Get task and query task cancel state
374 Task* task = static_cast<Task*>(data);
375 isCanceled = task->taskState_ == ExecuteState::CANCELED ? true : false;
414 auto task = TaskManager::GetInstance().GetTask(taskId);
415 std::shared_ptr<CallbackInfo> callbackInfo = std::make_shared<CallbackInfo>(env, 1, callbackRef, task);
417 if (!task->IsMainThreadTask()) {
447 Task* task = nullptr;
454 task = static_cast<Task*>(data);
470 TaskResultInfo* resultInfo = new TaskResultInfo(task->env_, env, task->taskId_, serializationArgs);
471 return TaskManager::GetInstance().NotifyCallbackExecute(env, resultInfo, task);
489 Task* task = nullptr;
490 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
491 if (task == nullptr) {
492 HILOG_ERROR("taskpool:: task is nullptr");
496 if (task->IsPeriodicTask()) {
497 HILOG_ERROR("taskpool:: the periodic task cannot have a dependency");
501 if (task->IsCommonTask() || task->IsSeqRunnerTask()) {
507 if (task->IsGroupCommonTask()) {
513 task->SetHasDependency(true);
517 errMessage = "taskpool:: addDependency param is not task";
519 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the addDependency param must be task.");
528 if (dependentTask->taskId_ == task->taskId_) {
534 HILOG_ERROR("taskpool:: the periodic task cannot have a dependency");
554 if (!TaskManager::GetInstance().StoreTaskDependency(task->taskId_, idSet)) {
559 HITRACE_HELPER_METER_NAME(strTrace + TaskManager::GetInstance().GetTaskDependInfoToString(task->taskId_));
577 Task* task = nullptr;
578 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
579 if (task == nullptr) {
580 HILOG_ERROR("taskpool:: the task is nullptr");
581 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the task is nullptr");
584 if (!task->HasDependency()) {
588 if (task->IsPeriodicTask()) {
589 HILOG_ERROR("taskpool:: the periodic task cannot call removeDependency");
593 if (task->IsCommonTask()) {
601 std::string errMessage = "taskpool:: removeDependency param is not task";
603 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of removeDependency param must be task.");
609 HILOG_ERROR("taskpool:: the dependent task is nullptr");
610 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the dependent task is nullptr");
618 HILOG_ERROR("taskpool:: the periodic task cannot call removeDependency");
623 std::string errMessage = "taskpool:: cannot removeDependency on a dependent and executed task";
628 if (!TaskManager::GetInstance().RemoveTaskDependency(task->taskId_, dependentTask->taskId_)) {
635 task->TryClearHasDependency();
637 HITRACE_HELPER_METER_NAME(strTrace + TaskManager::GetInstance().GetTaskDependInfoToString(task->taskId_));
643 HILOG_DEBUG("taskpool:: task StartExecutionCallback");
673 HILOG_DEBUG("taskpool:: task ExecuteListenerCallback");
721 Task* task = nullptr;
722 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
723 if (task == nullptr) {
724 HILOG_ERROR("taskpool:: task is nullptr");
728 if (task->taskState_ != ExecuteState::NOT_FOUND) {
729 HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
735 task->onEnqueuedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
759 Task* task = nullptr;
760 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
761 if (task == nullptr) {
762 HILOG_ERROR("taskpool:: task is nullptr");
766 if (task->taskState_ != ExecuteState::NOT_FOUND) {
767 HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
773 task->onStartExecutionCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
775 if (!task->IsMainThreadTask()) {
777 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_,
778 Task::StartExecutionCallback, task->onStartExecutionCallBackInfo_);
782 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_,
783 Task::StartExecutionCallback, task->onStartExecutionCallBackInfo_);
809 Task* task = nullptr;
810 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
811 if (task == nullptr) {
812 HILOG_ERROR("taskpool:: task is nullptr");
816 if (task->taskState_ != ExecuteState::NOT_FOUND) {
817 HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
823 task->onExecutionFailedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
847 Task* task = nullptr;
848 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
849 if (task == nullptr) {
850 HILOG_ERROR("taskpool:: task is nullptr");
854 if (task->taskState_ != ExecuteState::NOT_FOUND) {
855 HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
861 task->onExecutionSucceededCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
869 Task* task = nullptr;
870 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
871 if (task == nullptr) {
872 HILOG_ERROR("taskpool:: task is nullptr");
876 if (task->taskState_ == ExecuteState::FINISHED || task->taskState_ == ExecuteState::ENDING) {
885 Task* task = nullptr;
887 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
888 if (task == nullptr) {
892 uint64_t totalDuration = TaskManager::GetInstance().GetTaskDuration(task->taskId_, durationType);
914 Task* task = nullptr;
916 napi_unwrap(env, thisVar, reinterpret_cast<void**>(&task));
917 if (task == nullptr) {
921 napi_create_string_utf8(env, task->name_.c_str(), NAPI_AUTO_LENGTH, &name);
981 // The uninitialized state is Task, and then taskType_ will be updated based on the task type.
991 HILOG_DEBUG("taskpool:: task GenerateTaskInfo");
1038 HILOG_DEBUG("taskpool:: task:%{public}s NotifyPendingTask", std::to_string(taskId_).c_str());
1044 HILOG_DEBUG("taskpool:: task:%{public}s NotifyPendingTask end, currentTaskInfo_ nullptr",
1056 HILOG_DEBUG("taskpool:: task:%{public}s CancelPendingTask", std::to_string(taskId_).c_str());
1058 HILOG_DEBUG("taskpool:: task CancelPendingTask end, pendingTaskInfos_ nullptr");
1063 error = ErrorHelper::NewError(env, 0, "taskpool:: task has been canceled");
1079 HILOG_DEBUG("taskpool:: task:%{public}s UpdateTask", std::to_string(taskId_).c_str());
1080 if (taskState_ == ExecuteState::CANCELED) { // task may have been canceled
1081 HILOG_INFO("taskpool:: task has been canceled, taskId %{public}s", std::to_string(taskId_).c_str());
1094 HILOG_ERROR("taskpool:: the currentTaskInfo is nullptr, the task may have been cancelled");
1128 HILOG_DEBUG("taskpool:: task:%{public}s StoreTaskDuration", std::to_string(taskId_).c_str());
1142 // task with dependence is not allowed
1144 errMessage = "seqRunner:: dependent task not allowed.";
1174 errMessage = "taskpool:: dependent task not allowed.";
1198 errMessage = "taskpool:: The interface does not support the long task";
1229 errMessage = "taskpool:: The long task can only be executed once";
1287 "taskpool:: the task with dependency cannot executePeriodically");
1305 HILOG_DEBUG("taskpool:: task:%{public}s TryClearHasDependency", std::to_string(taskId_).c_str());
1307 HILOG_DEBUG("taskpool:: task TryClearHasDependency end, task is executed");
1318 std::string errMessage = "taskpool:: task has no dependency";
1350 HILOG_DEBUG("taskpool:: task ClearDelayedTimers");
1358 napi_value error = ErrorHelper::NewError(env_, 0, "taskpool:: task has been canceled");
1378 Task* task = TaskManager::GetInstance().GetTask(taskId);
1379 if (task == nullptr) {
1382 TaskPool::HandleTaskResultCallback(task);
1418 HILOG_WARN("taskpool:: task is invalid");
1438 Task* task = TaskManager::GetInstance().GetTask(taskId);
1439 if (task == nullptr || task->onStartExecutionCallBackInfo_ == nullptr) {
1442 Task::StartExecutionTask(task->onStartExecutionCallBackInfo_);