Lines Matching refs:task
188 size_t argc = 1; // 1: long task
201 auto task = TaskManager::GetInstance().GetTask(taskId);
202 if (task == nullptr || !task->IsLongTask()) {
203 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the params must be long task.");
239 Task* task = nullptr;
240 napi_unwrap(env, args[0], reinterpret_cast<void**>(&task));
241 if (task == nullptr) {
242 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the first param must be task.");
245 if (!task->CanExecute(env)) {
248 napi_value promise = task->GetTaskInfoPromise(env, args[0], TaskType::COMMON_TASK,
253 ExecuteTask(env, task, static_cast<Priority>(priority));
261 Task* task = Task::GenerateFunctionTask(env, args[0], args + 1, argc - 1, TaskType::FUNCTION_TASK);
262 if (task == nullptr) {
266 TaskManager::GetInstance().StoreTask(task->taskId_, task);
267 napi_value promise = NapiHelper::CreatePromise(env, &task->currentTaskInfo_->deferred);
268 ExecuteTask(env, task);
275 auto task = TaskManager::GetInstance().GetTask(taskMessage->taskId);
276 if (task == nullptr) {
277 HILOG_DEBUG("taskpool:: task is nullptr");
278 } else if (task->taskState_ == ExecuteState::CANCELED) {
279 HILOG_DEBUG("taskpool:: DelayTask task has been canceled");
280 napi_value error = ErrorHelper::NewError(task->env_, 0, "taskpool:: task has been canceled");
281 napi_reject_deferred(task->env_, taskMessage->deferred, error);
285 task->IncreaseRefCount();
286 napi_value napiTask = NapiHelper::GetReferenceValue(task->env_, task->taskRef_);
287 TaskInfo* taskInfo = task->GetTaskInfo(task->env_, napiTask, taskMessage->priority);
290 if (task->taskState_ == ExecuteState::DELAYED || task->taskState_ == ExecuteState::FINISHED) {
291 task->taskState_ = ExecuteState::WAITING;
296 napi_get_and_clear_last_exception(task->env_, &execption);
298 napi_reject_deferred(task->env_, taskMessage->deferred, execption);
302 if (task != nullptr) {
303 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
304 task->delayedTimers_.erase(handle);
320 Task* task = nullptr;
321 if (!CheckDelayedParams(env, cbinfo, priority, delayTime, task)) {
325 if (!task->IsExecuted() || task->taskState_ == ExecuteState::CANCELED ||
326 task->taskState_ == ExecuteState::FINISHED) {
327 task->taskState_ = ExecuteState::DELAYED;
329 task->UpdateTaskType(TaskType::COMMON_TASK);
337 taskMessage->taskId = task->taskId_;
341 std::string strTrace = "ExecuteDelayed: taskId: " + std::to_string(task->taskId_);
349 std::lock_guard<RECURSIVE_MUTEX> lock(task->taskMutex_);
350 task->delayedTimers_.insert(timer);
387 Task* task = nullptr;
388 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
389 if (task == nullptr) {
390 HILOG_ERROR("taskpool::ExecuteGroup task is nullptr");
393 napi_reference_ref(env, task->taskRef_, nullptr);
394 if (task->IsGroupCommonTask()) {
395 task->GetTaskInfo(env, napiTask, static_cast<Priority>(priority));
397 ExecuteTask(env, task, static_cast<Priority>(priority));
408 HILOG_DEBUG("taskpool:: HandleTaskResult task");
410 auto task = static_cast<Task*>(req->data);
411 if (task == nullptr) { // LCOV_EXCL_BR_LINE
412 HILOG_FATAL("taskpool:: HandleTaskResult task is null");
415 if (!task->IsMainThreadTask()) {
416 if (task->ShouldDeleteTask(false)) {
417 delete task;
420 if (task->IsFunctionTask()) {
421 napi_remove_env_cleanup_hook(task->env_, Task::CleanupHookFunc, task);
424 task->DecreaseTaskRefCount();
425 HandleTaskResultCallback(task);
428 void TaskPool::HandleTaskResultCallback(Task* task)
431 NAPI_CALL_RETURN_VOID(task->env_, napi_open_handle_scope(task->env_, &scope));
433 napi_status status = napi_deserialize(task->env_, task->result_, &napiTaskResult);
434 napi_delete_serialization_data(task->env_, task->result_);
437 std::string strTrace = "Task PerformTask End: taskId : " + std::to_string(task->taskId_);
438 if (task->taskState_ == ExecuteState::CANCELED) {
440 napiTaskResult = ErrorHelper::NewError(task->env_, 0, "taskpool:: task has been canceled");
444 } else if (task->success_) {
452 napi_get_undefined(task->env_, &napiTaskResult);
454 reinterpret_cast<NativeEngine*>(task->env_)->DecreaseSubEnvCounter();
455 bool success = ((status == napi_ok) && (task->taskState_ != ExecuteState::CANCELED)) && (task->success_);
456 task->taskState_ = ExecuteState::ENDING;
457 if (task->IsGroupTask()) {
458 UpdateGroupInfoByResult(task->env_, task, napiTaskResult, success);
459 } else if (!task->IsPeriodicTask()) {
461 napi_resolve_deferred(task->env_, task->currentTaskInfo_->deferred, napiTaskResult);
462 if (task->onExecutionSucceededCallBackInfo_ != nullptr) {
463 task->ExecuteListenerCallback(task->onExecutionSucceededCallBackInfo_);
466 napi_reject_deferred(task->env_, task->currentTaskInfo_->deferred, napiTaskResult);
467 if (task->onExecutionFailedCallBackInfo_ != nullptr) {
468 task->onExecutionFailedCallBackInfo_->taskError_ = napiTaskResult;
469 task->ExecuteListenerCallback(task->onExecutionFailedCallBackInfo_);
473 NAPI_CALL_RETURN_VOID(task->env_, napi_close_handle_scope(task->env_, scope));
474 TriggerTask(task);
477 void TaskPool::TriggerTask(Task* task)
479 HILOG_DEBUG("taskpool:: task:%{public}s TriggerTask", std::to_string(task->taskId_).c_str());
480 if (task->IsGroupTask()) {
483 TaskManager::GetInstance().DecreaseRefCount(task->env_, task->taskId_);
484 task->taskState_ = ExecuteState::FINISHED;
486 if (task->IsSeqRunnerTask()) {
487 if (!TaskGroupManager::GetInstance().TriggerSeqRunner(task->env_, task)) {
488 HILOG_ERROR("seqRunner:: task %{public}s trigger in seqRunner %{public}s failed",
489 std::to_string(task->taskId_).c_str(), std::to_string(task->seqRunnerId_).c_str());
491 } else if (task->IsCommonTask()) {
492 task->NotifyPendingTask();
494 if (task->IsPeriodicTask()) {
497 if (!task->IsFunctionTask()) {
498 napi_reference_unref(task->env_, task->taskRef_, nullptr);
501 TaskManager::GetInstance().RemoveTask(task->taskId_);
502 delete task;
505 void TaskPool::UpdateGroupInfoByResult(napi_env env, Task* task, napi_value res, bool success)
507 HILOG_DEBUG("taskpool:: task:%{public}s UpdateGroupInfoByResult", std::to_string(task->taskId_).c_str());
508 TaskManager::GetInstance().DecreaseRefCount(task->env_, task->taskId_);
509 task->taskState_ = ExecuteState::FINISHED;
510 napi_reference_unref(env, task->taskRef_, nullptr);
511 if (task->IsGroupCommonTask()) {
512 delete task->currentTaskInfo_;
513 task->currentTaskInfo_ = nullptr;
515 TaskGroup* taskGroup = TaskGroupManager::GetInstance().GetTaskGroup(task->groupId_);
524 uint32_t index = taskGroup->GetTaskIndex(task->taskId_);
536 HILOG_INFO("taskpool:: taskGroup perform end, taskGroupId %{public}s", std::to_string(task->groupId_).c_str());
539 auto task = TaskManager::GetInstance().GetTask(taskId);
540 if (task->onExecutionSucceededCallBackInfo_ != nullptr) {
541 task->ExecuteListenerCallback(task->onExecutionSucceededCallBackInfo_);
546 if (task->onExecutionFailedCallBackInfo_ != nullptr) {
547 task->onExecutionFailedCallBackInfo_->taskError_ = res;
548 task->ExecuteListenerCallback(task->onExecutionFailedCallBackInfo_);
559 void TaskPool::ExecuteTask(napi_env env, Task* task, Priority priority)
562 std::string strTrace = "Task Allocation: taskId : " + std::to_string(task->taskId_)
567 task->IncreaseRefCount();
568 TaskManager::GetInstance().IncreaseRefCount(task->taskId_);
569 if (task->IsFunctionTask() || (task->taskState_ != ExecuteState::WAITING &&
570 task->taskState_ != ExecuteState::RUNNING && task->taskState_ != ExecuteState::ENDING)) {
571 task->taskState_ = ExecuteState::WAITING;
572 TaskManager::GetInstance().EnqueueTaskId(task->taskId_, priority);
595 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the params must be task.");
633 Task* task = reinterpret_cast<Task*>(handle->data);
634 if (task == nullptr) {
635 HILOG_DEBUG("taskpool:: the task is nullptr");
637 } else if (!task->IsPeriodicTask()) {
638 HILOG_DEBUG("taskpool:: the current task is not a periodic task");
640 } else if (task->taskState_ == ExecuteState::CANCELED) {
641 HILOG_DEBUG("taskpool:: the periodic task has been canceled");
644 TaskManager::GetInstance().IncreaseRefCount(task->taskId_);
646 if (!task->isFirstTaskInfo_) {
647 napi_value napiTask = NapiHelper::GetReferenceValue(task->env_, task->taskRef_);
648 TaskInfo* taskInfo = task->GetTaskInfo(task->env_, napiTask, task->periodicTaskPriority_);
650 HILOG_DEBUG("taskpool:: the periodic task taskInfo is nullptr");
654 task->isFirstTaskInfo_ = false;
656 task->IncreaseRefCount();
657 HILOG_INFO("taskpool:: PeriodicTaskCallback taskId %{public}s", std::to_string(task->taskId_).c_str());
658 if (task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED) {
659 task->taskState_ = ExecuteState::WAITING;
660 TaskManager::GetInstance().EnqueueTaskId(task->taskId_, task->periodicTaskPriority_);
685 periodicTask->isFirstTaskInfo_ = true; // periodic task first Generate TaskInfo
691 void TaskPool::TriggerTimer(napi_env env, Task* task, int32_t period)
693 HILOG_INFO("taskpool::TriggerTimer taskId %{public}s", std::to_string(task->taskId_).c_str());
695 task->timer_ = new uv_timer_t;
696 uv_timer_init(loop, task->timer_);
697 task->timer_->data = task;
699 uv_timer_start(task->timer_, PeriodicTaskCallback, period, period);
711 Task* &task)
713 size_t argc = 3; // 3: delayTime, task and priority
714 napi_value args[3]; // 3: delayTime, task and priority
716 if (argc < 2 || argc > 3) { // 2: delayTime and task 3: delayTime, task and priority
742 priority = NapiHelper::GetUint32Value(env, args[2]); // 2: get task priority
749 napi_unwrap(env, args[1], reinterpret_cast<void**>(&task));
750 if (task == nullptr) {
751 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of second param must be task");
754 if (!task->CanExecuteDelayed(env)) {
763 size_t argc = 3; // 3 : period, task, priority
764 napi_value args[3]; // 3 : period, task, priority
766 if (argc < 2 || argc > 3) { // 2 : period, task and 3 : period, task, priority
780 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the second param must be task.");
798 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the second param must be task.");