Lines Matching refs:task

21 #include "task.h"

182     Task* task = reinterpret_cast<Task*>(handle->data);

183     TaskPool::UpdateGroupInfoByResult(env, task, res, success);

329     Task* task = new Task();

330     task->taskType_ = TaskType::COMMON_TASK;

331     task->taskId_ = reinterpret_cast<uint64_t>(task);

334     task->taskRef_ = ref;

335     taskManager.StoreTask(task->taskId_, task);

336     task->taskState_ = ExecuteState::CANCELED;

337     taskManager.CancelTask(env, task->taskId_);

340     task->timer_ = new uv_timer_t;

341     uv_timer_init(loop, task->timer_);

342     task->taskState_ = ExecuteState::RUNNING;

343     task->isPeriodicTask_ = true;

344     taskManager.CancelTask(env, task->taskId_);

346     task->isPeriodicTask_ = false;

347     task->taskType_ = TaskType::SEQRUNNER_TASK;

348     taskManager.CancelTask(env, task->taskId_);

350     task->taskState_ = ExecuteState::FINISHED;

351     taskManager.CancelTask(env, task->taskId_);

354     task->taskState_ = ExecuteState::WAITING;

355     task->currentTaskInfo_ = taskInfo;

356     taskManager.CancelTask(env, task->taskId_);

358     delete task;

364     Task* task = new Task();

365     task->taskId_ = reinterpret_cast<uint64_t>(task);

366     taskManager.taskQueues_[Priority::DEFAULT]->EnqueueTaskId(task->taskId_);

375     delete task;

381     Task* task = new Task();

382     task->taskId_ = reinterpret_cast<uint64_t>(task);

383     taskManager.StoreTask(task->taskId_, task);

386     task->onEnqueuedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);

387     taskManager.EnqueueTaskId(task->taskId_);

396     delete task;

402     Task* task = new Task();

403     task->taskId_ = reinterpret_cast<uint64_t>(task);

404     taskManager.StoreTask(task->taskId_, task);

410     taskManager.EnqueueTaskId(task->taskId_);

411     std::set<uint64_t> set{task->taskId_};

412     taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));

416     delete task;

427     Task* task = new Task();

428     task->taskId_ = reinterpret_cast<uint64_t>(task);

429     taskManager.EnqueueTaskId(task->taskId_);

476     Task* task = new Task();

477     task->taskId_ = reinterpret_cast<uint64_t>(task);

478     task->env_ = env;

481     task->worker_ = worker;

482     uint64_t id = task->taskId_ + MAX_TIMEOUT_TIME;

483     std::set<uint64_t> set{ task->taskId_, id };

484     taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set));

485     taskManager.NotifyDependencyTaskInfo(task->taskId_);

486     std::set<uint64_t> set1{ task->taskId_, id };

487     taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set1));

490     taskManager.EnqueuePendingTaskInfo(task->taskId_, Priority::DEFAULT);

491     taskManager.NotifyDependencyTaskInfo(task->taskId_);

492     std::set<uint64_t> set2{ task->taskId_, id };

493     taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set2));

494     taskManager.IsDependentByTaskId(task->taskId_);

500     Task* task = new Task();

501     task->taskId_ = reinterpret_cast<uint64_t>(task);

502     task->env_ = env;

510     uint64_t id1 = task->taskId_;

511     uint64_t id2 = task->taskId_ + MAX_TIMEOUT_TIME;

538     Task* task = new Task();

539     task->taskId_ = reinterpret_cast<uint64_t>(task);

540     uint64_t id = task->taskId_ + MAX_TIMEOUT_TIME;

546     taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));

547     taskManager.RemoveTaskDependency(task->taskId_, task1->taskId_);

548     taskManager.RemoveTaskDependency(task->taskId_, id);

550     taskManager.dependentTaskInfos_.emplace(task->taskId_, std::move(set2));

551     std::set<uint64_t> dependentTaskIdSet{ task->taskId_ };

553     taskManager.RemoveDependentTaskInfo(task->taskId_, id2);

554     taskManager.RemoveDependentTaskInfo(task->taskId_, id);

556     taskManager.taskDurationInfos_.emplace(task->taskId_, std::make_pair(UINT64_ZERO_, task1->taskId_));

557     taskManager.StoreTaskDuration(task->taskId_, UINT64_ZERO_, UINT64_ZERO_);

558     taskManager.GetTaskDuration(task->taskId_, "");

559     taskManager.RemoveTaskDuration(task->taskId_);

565     Task* task = new Task();

566     task->taskId_ = reinterpret_cast<uint64_t>(task);

567     task->onResultSignal_ = nullptr;

568     task->taskType_ = TaskType::FUNCTION_TASK;

569     taskManager.StoreTask(task->taskId_, task);

570     taskManager.ReleaseTaskData(env, task);

571     task->taskType_ = TaskType::GROUP_FUNCTION_TASK;

572     taskManager.StoreTask(task->taskId_, task);

573     taskManager.ReleaseTaskData(env, task);

574     std::set<uint64_t> set{ task->taskId_ };

575     taskManager.dependTaskInfos_.emplace(task->taskId_, std::move(set));

576     task->taskType_ = TaskType::COMMON_TASK;

577     taskManager.StoreTask(task->taskId_, task);

578     taskManager.ReleaseTaskData(env, task);

593     ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_, NativeEngineTest::foo, task2);

600     Task* task = new Task();

601     task->taskId_ = reinterpret_cast<uint64_t>(task);

604     taskManager.StoreTask(task->taskId_, task);

614     groupManager.AddTask(groupId, nullptr, task->taskId_);

634     group->taskIds_.push_back(task->taskId_);

652     Task* task = new Task();

653     task->taskId_ = reinterpret_cast<uint64_t>(task);

654     taskManager.StoreTask(task->taskId_, task);

655     task->taskState_ = ExecuteState::RUNNING;

656     groupManager.CancelGroupTask(env, task->taskId_, group);

657     task->taskState_ = ExecuteState::WAITING;

658     groupManager.CancelGroupTask(env, task->taskId_, group);

659     task->taskState_ = ExecuteState::WAITING;

661     task->currentTaskInfo_ = taskInfo;

662     groupManager.CancelGroupTask(env, task->taskId_, group);

675     Task* task = new Task();

676     task->taskId_ = reinterpret_cast<uint64_t>(task);

682     task->seqRunnerId_ = seqRunnerId;

685     bool res = groupManager.TriggerSeqRunner(env, task);

689     groupManager.TriggerSeqRunner(env, task);

692     seqRunner->currentTaskId_ = task->taskId_;

693     groupManager.TriggerSeqRunner(env, task);

699     seqRunner->currentTaskId_ = task->taskId_;

700     groupManager.TriggerSeqRunner(env, task);

705     seqRunner->seqRunnerTasks_.push(task);

706     task->taskState_ = ExecuteState::RUNNING;

707     seqRunner->currentTaskId_ = task->taskId_;

708     groupManager.TriggerSeqRunner(env, task);

716     Task* task = new Task();

717     task->taskId_ = reinterpret_cast<uint64_t>(task);

719     groupManager.UpdateGroupState(task->taskId_);

807     Task* task = new Task();

808     task->taskId_ = reinterpret_cast<uint64_t>(task);

809     taskManager.StoreTask(task->taskId_, task);

816     mediumTaskQueue->EnqueueTaskId(task->taskId_);

820     task->taskState_ = ExecuteState::WAITING;

821     task->taskType_ = TaskType::GROUP_COMMON_TASK;

822     task->groupId_ = groupId;

831     Task* task = new Task();

832     task->taskId_ = reinterpret_cast<uint64_t>(task);

833     task->env_ = worker->workerEnv_;

835     ConcurrentHelper::UvHandleInit(loop, task->onResultSignal_, NativeEngineTest::foo, task);

839     task->worker_ = worker;

840     task->isMainThreadTask_ = true;

841     task->taskRefCount_.fetch_add(1);

842     TaskManager::GetInstance().StoreTask(task->taskId_, task);

843     Worker::NotifyHandleTaskResult(task);

850     Task* task = new Task();

851     task->taskId_ = reinterpret_cast<uint64_t>(task);

852     task->env_ = worker->workerEnv_;

853     task->taskRefCount_.fetch_add(1);

854     task->worker_ = worker;

855     task->cpuTime_ = UINT64_ZERO_;

856     Worker::TaskResultCallback(worker->workerEnv_, nullptr, false, reinterpret_cast<void*>(task));

857     task->taskRefCount_.fetch_add(1);

858     task->cpuTime_ = task->taskId_;

859     Worker::TaskResultCallback(worker->workerEnv_, nullptr, true, reinterpret_cast<void*>(task));

873     uint64_t id = task->taskId_ + MAX_TIMEOUT_TIME;

874     std::unordered_set<uint64_t> set{ task->taskId_, id };

876     worker->TerminateTask(task->taskId_);

886     Task* task = new Task();

887     task->taskId_ = reinterpret_cast<uint64_t>(task);

888     task->env_ = workerEnv;

889     TaskResultInfo* resultInfo = new TaskResultInfo(env, workerEnv, task->taskId_, nullptr);

890     TaskManager::GetInstance().NotifyCallbackExecute(env, resultInfo, task);

891     task->IncreaseRefCount();

893     ConcurrentHelper::UvHandleInit(loop, task->onResultSignal_, NativeEngineTest::foo, task);

894     task->worker_ = worker;

895     Worker::HandleFunctionException(env, task);

896     task->IncreaseRefCount();

897     Worker::HandleFunctionException(env, task);