diff --git a/js_concurrent_module/taskpool/task_manager.cpp b/js_concurrent_module/taskpool/task_manager.cpp index 14f8e9b59b22f38f3a7ceec34f54b41cc6f9d403..cd9e489191773535423bdb252cf2b3a8772dcc46 100644 --- a/js_concurrent_module/taskpool/task_manager.cpp +++ b/js_concurrent_module/taskpool/task_manager.cpp @@ -133,9 +133,14 @@ TaskManager::~TaskManager() CountTraceForWorker(); } -void TaskManager::CountTraceForWorker() +void TaskManager::CountTraceForWorker(bool needLog) { std::lock_guard lock(workersMutex_); + CountTraceForWorkerWithoutLock(needLog); +} + +inline void TaskManager::CountTraceForWorkerWithoutLock(bool needLog) +{ int64_t threadNum = static_cast(workers_.size()); int64_t idleWorkers = static_cast(idleWorkers_.size()); int64_t timeoutWorkers = static_cast(timeoutWorkers_.size()); @@ -143,6 +148,7 @@ void TaskManager::CountTraceForWorker() HITRACE_HELPER_COUNT_TRACE("threadNum", threadNum); HITRACE_HELPER_COUNT_TRACE("runningThreadNum", threadNum - idleWorkers); HITRACE_HELPER_COUNT_TRACE("idleThreadNum", idleWorkers); + AddCountTraceForWorkerLog(needLog, threadNum, idleWorkers, timeoutWorkers); } napi_value TaskManager::GetThreadInfos(napi_env env) @@ -461,7 +467,6 @@ void TaskManager::NotifyShrink(uint32_t targetNum) std::lock_guard lock(workersMutex_); uint32_t workerCount = workers_.size(); uint32_t minThread = ConcurrentHelper::IsLowMemory() ? 0 : DEFAULT_MIN_THREADS; - CheckTasksAndReportHisysEvent(); // update the maxThreads_ periodically maxThreads_ = ConcurrentHelper::GetMaxThreads(); if (minThread == 0) { @@ -519,7 +524,7 @@ void TaskManager::TriggerLoadBalance([[maybe_unused]] const uv_timer_t* req) taskManager.CheckForBlockedWorkers(); uint32_t targetNum = taskManager.ComputeSuitableThreadNum(); taskManager.NotifyShrink(targetNum); - taskManager.CountTraceForWorker(); + taskManager.CountTraceForWorker(true); } void TaskManager::DispatchAndTryExpand([[maybe_unused]] const uv_async_t* req) @@ -552,6 +557,9 @@ template void TaskManager::TryExpandWithCheckIdle() { if (GetNonIdleTaskNum() == 0) { + if constexpr (!needCheckIdle) { + HILOG_DEBUG("taskpool:: no need expand"); + } return; } @@ -650,7 +658,7 @@ void TaskManager::CancelTask(napi_env env, uint32_t taskId) if (task->currentTaskInfo_ == nullptr || task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED || task->taskState_ == ExecuteState::ENDING) { std::string errMsg = "taskpool:: task is not executed or has been executed"; - HILOG_ERROR("%{public}s", errMsg.c_str()); + HILOG_DEBUG("%{public}s", errMsg.c_str()); ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str()); return; } @@ -683,7 +691,7 @@ void TaskManager::CancelTask(napi_env env, uint32_t taskId) task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED || task->taskState_ == ExecuteState::ENDING) { std::string errMsg = "taskpool:: task is not executed or has been executed"; - HILOG_ERROR("%{public}s", errMsg.c_str()); + HILOG_DEBUG("%{public}s", errMsg.c_str()); ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str()); return; } @@ -743,7 +751,7 @@ void TaskManager::NotifyWorkerRunning(Worker* worker) { std::lock_guard lock(workersMutex_); idleWorkers_.erase(worker); - CountTraceForWorker(); + CountTraceForWorkerWithoutLock(); } uint32_t TaskManager::GetRunningWorkers() @@ -889,6 +897,11 @@ void TaskManager::NotifyExecuteTask() std::lock_guard lock(workersMutex_); if (GetNonIdleTaskNum() == 0 && workers_.size() != idleWorkers_.size()) { // When there are only idle tasks and workers executing them, it is not triggered + HILOG_INFO("taskpool:: no need notify"); + return; + } + if (idleWorkers_.size() == 0) { + HILOG_INFO("taskpool:: idleWorkers is 0"); return; } @@ -1676,4 +1689,14 @@ void TaskManager::UvReportHisysEvent(Worker* worker, std::string methodName, std WriteHisysForFfrtAndUv(worker, hisyseventParams); #endif } + +void TaskManager::AddCountTraceForWorkerLog(bool needLog, int64_t threadNum, int64_t idleThreadNum, + int64_t timeoutThreadNum) +{ + if (needLog) { + HILOG_INFO("taskpool:: threads: %{public}s, running: %{public}s, idle: %{public}s, timeout: %{public}s", + std::to_string(threadNum).c_str(), std::to_string(threadNum - idleThreadNum).c_str(), + std::to_string(idleThreadNum).c_str(), std::to_string(timeoutThreadNum).c_str()); + } +} } // namespace Commonlibrary::Concurrent::TaskPoolModule \ No newline at end of file diff --git a/js_concurrent_module/taskpool/task_manager.h b/js_concurrent_module/taskpool/task_manager.h index d5bf95f7e3c7983e1dc46181e0f1c4d271b3b0c4..6ad081f13f940d7cf38d540f45685e4c4f8de786 100644 --- a/js_concurrent_module/taskpool/task_manager.h +++ b/js_concurrent_module/taskpool/task_manager.h @@ -97,7 +97,8 @@ public: napi_value GetTaskInfos(napi_env env); // for countTrace for worker - void CountTraceForWorker(); + void CountTraceForWorker(bool needLog = false); + void CountTraceForWorkerWithoutLock(bool needLog = false); std::shared_ptr GetCallbackInfo(uint32_t taskId); void RegisterCallback(napi_env env, uint32_t taskId, std::shared_ptr callbackInfo); @@ -189,6 +190,7 @@ private: void CheckTasksAndReportHisysEvent(); void WorkerAliveAndReport(Worker* worker); void WriteHisysForFfrtAndUv(Worker* worker, HisyseventParams* hisyseventParams); + void AddCountTraceForWorkerLog(bool needLog, int64_t threadNum, int64_t idleThreadNum, int64_t timeoutThreadNum); // std::unordered_map tasks_ {}; diff --git a/js_concurrent_module/taskpool/taskpool.cpp b/js_concurrent_module/taskpool/taskpool.cpp index 23cb446bc31665c30036f1e0e0dc0e2ca2519548..cf88a45524e09082b3244d1f45ec0ac0e5f47dbe 100644 --- a/js_concurrent_module/taskpool/taskpool.cpp +++ b/js_concurrent_module/taskpool/taskpool.cpp @@ -601,14 +601,16 @@ void TaskPool::ExecuteTask(napi_env env, Task* task, Priority priority) HITRACE_HELPER_METER_NAME(strTrace); std::string taskLog = "Task Allocation: " + std::to_string(task->taskId_) + ", " + std::to_string(priority); - HILOG_TASK_INFO("taskpool:: %{public}s", taskLog.c_str()); task->IncreaseRefCount(); TaskManager::GetInstance().IncreaseRefCount(task->taskId_); if (task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED || (task->taskState_ == ExecuteState::CANCELED && task->isCancelToFinish_)) { task->taskState_ = ExecuteState::WAITING; + HILOG_TASK_INFO("taskpool:: %{public}s", taskLog.c_str()); task->isCancelToFinish_ = false; TaskManager::GetInstance().EnqueueTaskId(task->taskId_, priority); + } else { + HILOG_WARN("taskpool:: %{public}s, not enqueue", taskLog.c_str()); } } diff --git a/js_concurrent_module/taskpool/test/test_taskpool.cpp b/js_concurrent_module/taskpool/test/test_taskpool.cpp index 010c9994332e28fa3d7453b323393beccf9356be..c9ce10ae44f03f043057796170266873933a0677 100644 --- a/js_concurrent_module/taskpool/test/test_taskpool.cpp +++ b/js_concurrent_module/taskpool/test/test_taskpool.cpp @@ -6357,4 +6357,20 @@ HWTEST_F(NativeEngineTest, TaskpoolTest312, testing::ext::TestSize.Level0) result = NativeEngineTest::Execute(env, argv2, 1); ASSERT_TRUE(result != nullptr); TaskManager::GetInstance().RemoveTask(task2->taskId_); +} + +HWTEST_F(NativeEngineTest, TaskpoolTest333, testing::ext::TestSize.Level0) +{ + napi_env env = (napi_env)engine_; + ExceptionScope scope(env); + napi_value napiTask = CreateTaskObject(env, TaskType::TASK, ExecuteState::RUNNING, true); + napi_value argv[] = {napiTask}; + napi_value result = NativeEngineTest::Execute(env, argv, 1); + ASSERT_TRUE(result != nullptr); + Task* task = nullptr; + napi_unwrap(env, napiTask, reinterpret_cast(&task)); + TaskManager::GetInstance().RemoveTask(task->taskId_); + napi_value exception = nullptr; + napi_get_and_clear_last_exception(env, &exception); + ASSERT_TRUE(exception == nullptr); } \ No newline at end of file diff --git a/js_concurrent_module/taskpool/worker.cpp b/js_concurrent_module/taskpool/worker.cpp index 55358219b7afe2c003285ec8330bb487a66aeff2..48690f1ee6d80e44a4d1bf7176e094da2051eb6c 100644 --- a/js_concurrent_module/taskpool/worker.cpp +++ b/js_concurrent_module/taskpool/worker.cpp @@ -352,9 +352,12 @@ void Worker::NotifyExecuteTask() if (LIKELY(performTaskSignal_ != nullptr && !uv_is_closing(reinterpret_cast(performTaskSignal_)))) { int ret = uv_async_send(performTaskSignal_); if (ret != 0) { + HILOG_ERROR("taskpool:: worker NotifyExecuteTask uv send failed"); TaskManager::GetInstance().UvReportHisysEvent(this, "NotifyExecuteTask", "uv_async_send", "uv send performTaskSignal_ failed", ret); } + } else { + HILOG_ERROR("taskpool:: performTaskSignal_ is invalid"); } }